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) { /* WHY STEPSIZES WHEN 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
 499 void j2k_write_qcd()
 500 {
 501   int lenp, len;
 502
 503   cio_write(J2K_MS_QCD, 2);     /* QCD */
 504   lenp = cio_tell();
 505   cio_skip(2);
 506   j2k_write_qcx(0);
 507   len = cio_tell() - lenp;
 508   cio_seek(lenp);
 509   cio_write(len, 2);            /* Lqcd */
 510   cio_seek(lenp + len);
 511 }
 512
 513 void j2k_read_qcd()
 514 {
 515   int len, i, pos;
 516
 517   len = cio_read(2);            /* Lqcd */
 518   pos = cio_tell();
 519   for (i = 0; i < j2k_img->numcomps; i++) {
 520     cio_seek(pos);
 521     j2k_read_qcx(i, len - 2);
 522   }
 523 }
 524
 525 void j2k_write_qcc(int compno)
 526 {
 527   int lenp, len;
 528
 529   cio_write(J2K_MS_QCC, 2);     /* QCC */
 530   lenp = cio_tell();
 531   cio_skip(2);
 532   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Cqcc */
 533   j2k_write_qcx(compno);
 534   len = cio_tell() - lenp;
 535   cio_seek(lenp);
 536   cio_write(len, 2);            /* Lqcc */
 537   cio_seek(lenp + len);
 538 }
 539
 540 void j2k_read_qcc()
 541 {
 542   int len, compno;
 543
 544   len = cio_read(2);            /* Lqcc */
 545   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Cqcc */
 546   j2k_read_qcx(compno, len - 2 - (j2k_img->numcomps <= 256 ? 1 : 2));
 547 }
 548
 549 void j2k_write_poc()
 550 {
 551   int len, numpchgs, i;
 552   j2k_tcp_t *tcp;
 553   j2k_tccp_t *tccp;
 554
 555   tcp = &j2k_cp->tcps[j2k_curtileno];
 556   tccp = &tcp->tccps[0];
 557   numpchgs = tcp->numpocs;
 558   cio_write(J2K_MS_POC, 2);     /* POC  */
 559   len = 2 + (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2)) * numpchgs;
 560   cio_write(len, 2);            /* Lpoc */
 561   for (i = 0; i < numpchgs; i++) {
 562     // MODIF
 563     j2k_poc_t *poc;
 564     poc = &tcp->pocs[i];
 565     cio_write(poc->resno0, 1);  /* RSpoc_i */
 566     cio_write(poc->compno0, (j2k_img->numcomps <= 256 ? 1 : 2));        /* CSpoc_i */
 567     cio_write(poc->layno1, 2);  /* LYEpoc_i */
 568     poc->layno1 = int_min(poc->layno1, tcp->numlayers);
 569     cio_write(poc->resno1, 1);  /* REpoc_i */
 570     poc->resno1 = int_min(poc->resno1, tccp->numresolutions);
 571     cio_write(poc->compno1, (j2k_img->numcomps <= 256 ? 1 : 2));        /* CEpoc_i */
 572     poc->compno1 = int_min(poc->compno1, j2k_img->numcomps);
 573     cio_write(poc->prg, 1);     /* Ppoc_i */
 574   }
 575 }
 576
 577 void j2k_read_poc()
 578 {
 579   int len, numpchgs, i, old_poc;
 580   j2k_tcp_t *tcp;
 581   j2k_tccp_t *tccp;
 582
 583   tcp =
 584     j2k_state ==
 585     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 586
 587   old_poc = tcp->POC ? tcp->numpocs + 1 : 0;
 588   tcp->POC = 1;
 589   tccp = &tcp->tccps[0];
 590   len = cio_read(2);            /* Lpoc */
 591   numpchgs = (len - 2) / (5 + 2 * (j2k_img->numcomps <= 256 ? 1 : 2));
 592
 593   for (i = old_poc; i < numpchgs + old_poc; i++) {
 594     j2k_poc_t *poc;
 595     poc = &tcp->pocs[i];
 596     poc->resno0 = cio_read(1);  /* RSpoc_i */
 597     poc->compno0 = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* CSpoc_i */
 598     poc->layno1 = int_min(cio_read(2), tcp->numlayers); /* LYEpoc_i */
 599     poc->resno1 = int_min(cio_read(1), tccp->numresolutions);   /* REpoc_i */
 600     poc->compno1 = int_min(cio_read(j2k_img->numcomps <= 256 ? 1 : 2), j2k_img->numcomps);      /* CEpoc_i */
 601     poc->prg = cio_read(1);     /* Ppoc_i */
 602   }
 603
 604   tcp->numpocs = numpchgs + old_poc - 1;
 605 }
 606
 607 void j2k_read_crg()
 608 {
 609   int len, i, Xcrg_i, Ycrg_i;
 610
 611   len = cio_read(2);            /* Lcrg */
 612   for (i = 0; i < j2k_img->numcomps; i++) {
 613     Xcrg_i = cio_read(2);       /* Xcrg_i */
 614     Ycrg_i = cio_read(2);       /* Ycrg_i */
 615   }
 616 }
 617
 618 void j2k_read_tlm()
 619 {
 620   int len, Ztlm, Stlm, ST, SP, tile_tlm, i;
 621   long int Ttlm_i, Ptlm_i;
 622
 623   len = cio_read(2);            /* Ltlm */
 624   Ztlm = cio_read(1);           /* Ztlm */
 625   Stlm = cio_read(1);           /* Stlm */
 626   ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
 627   SP = (Stlm >> 6) & 0x01;
 628   tile_tlm = (len - 4) / ((SP + 1) * 2 + ST);
 629   for (i = 0; i < tile_tlm; i++) {
 630     Ttlm_i = cio_read(ST);      /* Ttlm_i */
 631     Ptlm_i = cio_read(SP ? 4 : 2);      /* Ptlm_i */
 632   }
 633 }
 634
 635 void j2k_read_plm()
 636 {
 637   int len, i, Zplm, Nplm, add, packet_len = 0;
 638
 639   len = cio_read(2);            /* Lplm */
 640   Zplm = cio_read(1);           /* Zplm */
 641   len -= 3;
 642   while (len > 0) {
 643     Nplm = cio_read(4);         /* Nplm */
 644     len -= 4;
 645     for (i = Nplm; i > 0; i--) {
 646       add = cio_read(1);
 647       len--;
 648       packet_len = (packet_len << 7) + add;     /* Iplm_ij */
 649       if ((add & 0x80) == 0) {
 650         /* New packet */
 651         packet_len = 0;
 652       }
 653       if (len <= 0)
 654         break;
 655     }
 656   }
 657 }
 658
 659 void j2k_read_plt()
 660 {
 661   int len, i, Zplt, packet_len = 0, add;
 662
 663   len = cio_read(2);            /* Lplt */
 664   Zplt = cio_read(1);           /* Zplt */
 665   for (i = len - 3; i > 0; i--) {
 666     add = cio_read(1);
 667     packet_len = (packet_len << 7) + add;       /* Iplt_i */
 668     if ((add & 0x80) == 0) {
 669       /* New packet */
 670       packet_len = 0;
 671     }
 672   }
 673 }
 674
 675 void j2k_read_ppm()
 676 {
 677   int len, Z_ppm, i, j;
 678   int N_ppm;
 679
 680   len = cio_read(2);
 681   j2k_cp->ppm = 1;
 682
 683   Z_ppm = cio_read(1);          /* Z_ppm */
 684   len -= 3;
 685   while (len > 0) {
 686     if (j2k_cp->ppm_previous == 0) {
 687       N_ppm = cio_read(4);      /* N_ppm */
 688       len -= 4;
 689     } else {
 690       N_ppm = j2k_cp->ppm_previous;
 691     }
 692
 693     j = j2k_cp->ppm_store;
 694     if (Z_ppm == 0)             /* First PPM marker */
 695       j2k_cp->ppm_data =
 696         (unsigned char *) calloc(N_ppm, sizeof(unsigned char));
 697     else                        /* NON-first PPM marker */
 698       j2k_cp->ppm_data =
 699         (unsigned char *) realloc(j2k_cp->ppm_data,
 700                                   (N_ppm +
 701                                    j2k_cp->ppm_store) *
 702                                   sizeof(unsigned char));
 703
 704     for (i = N_ppm; i > 0; i--) {       /* Read packet header */
 705       j2k_cp->ppm_data[j] = cio_read(1);
 706       j++;
 707       len--;
 708       if (len == 0)
 709         break;                  /* Case of non-finished packet header in present marker but finished in next one */
 710     }
 711
 712     j2k_cp->ppm_previous = i - 1;
 713     j2k_cp->ppm_store = j;
 714   }
 715 }
 716
 717 void j2k_read_ppt()
 718 {
 719   int len, Z_ppt, i, j = 0;
 720   j2k_tcp_t *tcp;
 721
 722   len = cio_read(2);
 723   Z_ppt = cio_read(1);
 724   tcp = &j2k_cp->tcps[j2k_curtileno];
 725   tcp->ppt = 1;
 726   if (Z_ppt == 0) {             /* First PPT marker */
 727     tcp->ppt_data =
 728       (unsigned char *) calloc(len - 3, sizeof(unsigned char));
 729     tcp->ppt_store = 0;
 730   } else                        /* NON-first PPT marker */
 731     tcp->ppt_data =
 732       (unsigned char *) realloc(tcp->ppt_data,
 733                                 (len - 3 +
 734                                  tcp->ppt_store) * sizeof(unsigned char));
 735
 736   j = tcp->ppt_store;
 737   for (i = len - 3; i > 0; i--) {
 738     tcp->ppt_data[j] = cio_read(1);
 739     j++;
 740   }
 741   tcp->ppt_store = j;
 742 }
 743
 744 void j2k_write_sot()
 745 {
 746   int lenp, len;
 747
 748   j2k_sot_start = cio_tell();
 749   cio_write(J2K_MS_SOT, 2);     /* SOT */
 750   lenp = cio_tell();
 751   cio_skip(2);                  /* Lsot (further) */
 752   cio_write(j2k_curtileno, 2);  /* Isot */
 753   cio_skip(4);                  /* Psot (further in j2k_write_sod) */
 754   cio_write(0, 1);              /* TPsot */
 755   cio_write(1, 1);              /* TNsot */
 756   len = cio_tell() - lenp;
 757   cio_seek(lenp);
 758   cio_write(len, 2);            /* Lsot */
 759   cio_seek(lenp + len);
 760 }
 761
 762 void j2k_read_sot()
 763 {
 764   int len, tileno, totlen, partno, numparts, i;
 765   j2k_tcp_t *tcp;
 766   j2k_tccp_t *tmp;
 767   char status = 0;
 768
 769   len = cio_read(2);
 770   tileno = cio_read(2);
 771
 772   if (j2k_cp->tileno_size == 0) {
 773     j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 774     j2k_cp->tileno_size++;
 775   } else {
 776     i = 0;
 777     while (i < j2k_cp->tileno_size && status == 0) {
 778       status = j2k_cp->tileno[i] == tileno ? 1 : 0;
 779       i++;
 780     }
 781     if (status == 0) {
 782       j2k_cp->tileno[j2k_cp->tileno_size] = tileno;
 783       j2k_cp->tileno_size++;
 784     }
 785   }
 786
 787   totlen = cio_read(4);
 788   if (!totlen)
 789     totlen = cio_numbytesleft() + 8;
 790
 791   partno = cio_read(1);
 792   numparts = cio_read(1);
 793
 794   j2k_curtileno = tileno;
 795   j2k_eot = cio_getbp() - 12 + totlen;
 796   j2k_state = J2K_STATE_TPH;
 797   tcp = &j2k_cp->tcps[j2k_curtileno];
 798
 799   if (tcp->first == 1) {
 800     tmp = tcp->tccps;
 801     *tcp = j2k_default_tcp;
 802
 803     /* Initialization PPT */
 804     tcp->ppt = 0;
 805     tcp->ppt_data = NULL;
 806
 807     tcp->tccps = tmp;
 808     for (i = 0; i < j2k_img->numcomps; i++) {
 809       tcp->tccps[i] = j2k_default_tcp.tccps[i];
 810     }
 811     j2k_cp->tcps[j2k_curtileno].first = 0;
 812   }
 813 }
 814
 815 void j2k_write_sod()
 816 {
 817   int l, layno;
 818   int totlen;
 819   j2k_tcp_t *tcp;
 820   static int j2k_sod_start;
 821
 822   cio_write(J2K_MS_SOD, 2);
 823   if (j2k_curtileno == 0) {
 824     j2k_sod_start = cio_tell() + pos_correction;
 825   }
 826
 827   /* INDEX >> */
 828   if (info_IM.index_on) {
 829     info_IM.tile[j2k_curtileno].end_header =
 830       cio_tell() + pos_correction - 1;
 831     info_IM.tile[j2k_curtileno].packet =
 832       (info_packet *) calloc(info_IM.Comp * info_IM.Layer *
 833                              (info_IM.Decomposition + 1) * 100,
 834                              sizeof(info_packet));
 835   }
 836   /* << INDEX */
 837
 838   tcp = &j2k_cp->tcps[j2k_curtileno];
 839   for (layno = 0; layno < tcp->numlayers; layno++) {
 840     tcp->rates[layno] -= (j2k_sod_start / (j2k_cp->th * j2k_cp->tw));
 841   }
 842
 843   info_IM.num = 0;
 844   if (j2k_cp->image_type)
 845     l = tcd_encode_tile_pxm(j2k_curtileno, cio_getbp(),
 846                             cio_numbytesleft() - 2, &info_IM);
 847   else
 848     l = tcd_encode_tile_pgx(j2k_curtileno, cio_getbp(),
 849                             cio_numbytesleft() - 2, &info_IM);
 850
 851   /* Writing Psot in SOT marker */
 852   totlen = cio_tell() + l - j2k_sot_start;
 853   cio_seek(j2k_sot_start + 6);
 854   cio_write(totlen, 4);
 855   cio_seek(j2k_sot_start + totlen);
 856 }
 857
 858 void j2k_read_sod()
 859 {
 860   int len, truncate = 0, i;
 861   unsigned char *data;
 862
 863   len = int_min(j2k_eot - cio_getbp(), cio_numbytesleft() + 1);
 864   if (len == cio_numbytesleft() + 1)
 865     truncate = 1;               /* Case of a truncate codestream */
 866
 867   data =
 868     (unsigned char *) malloc((j2k_tile_len[j2k_curtileno] + len) *
 869                              sizeof(unsigned char));
 870   for (i = 0; i < j2k_tile_len[j2k_curtileno]; i++)
 871     data[i] = j2k_tile_data[j2k_curtileno][i];
 872   for (i = 0; i < len; i++)
 873     data[i + j2k_tile_len[j2k_curtileno]] = cio_read(1);
 874
 875   j2k_tile_len[j2k_curtileno] += len;
 876   free(j2k_tile_data[j2k_curtileno]);
 877   j2k_tile_data[j2k_curtileno] = data;
 878   data = NULL;
 879
 880   if (!truncate)
 881     j2k_state = J2K_STATE_TPHSOT;
 882   else
 883     j2k_state = J2K_STATE_NEOC; /* RAJOUTE !! */
 884 }
 885
 886 void j2k_write_rgn(int compno, int tileno)
 887 {
 888   j2k_tcp_t *tcp = &j2k_cp->tcps[tileno];
 889
 890   cio_write(J2K_MS_RGN, 2);     /* RGN  */
 891   cio_write(j2k_img->numcomps <= 256 ? 5 : 6, 2);       /* Lrgn */
 892   cio_write(compno, j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 893   cio_write(0, 1);              /* Srgn */
 894   cio_write(tcp->tccps[compno].roishift, 1);    /* SPrgn */
 895 }
 896
 897 void j2k_read_rgn()
 898 {
 899   int len, compno, roisty;
 900   j2k_tcp_t *tcp;
 901
 902   tcp =
 903     j2k_state ==
 904     J2K_STATE_TPH ? &j2k_cp->tcps[j2k_curtileno] : &j2k_default_tcp;
 905   len = cio_read(2);            /* Lrgn */
 906   compno = cio_read(j2k_img->numcomps <= 256 ? 1 : 2);  /* Crgn */
 907   roisty = cio_read(1);         /* Srgn */
 908   tcp->tccps[compno].roishift = cio_read(1);    /* SPrgn */
 909 }
 910
 911 void j2k_write_eoc()
 912 {
 913   /* fprintf(stderr, "%.8x: EOC\n", cio_tell() + pos_correction); */
 914   cio_write(J2K_MS_EOC, 2);
 915 }
 916
 917 void j2k_read_eoc()
 918 {
 919   int i, tileno;
 920
 921   tcd_init(j2k_img, j2k_cp);
 922
 923   for (i = 0; i < j2k_cp->tileno_size; i++) {
 924     tileno = j2k_cp->tileno[i];
 925     tcd_decode_tile(j2k_tile_data[tileno], j2k_tile_len[tileno], tileno);
 926   }
 927
 928   j2k_state = J2K_STATE_MT;
 929   longjmp(j2k_error, 1);
 930 }
 931
 932 void j2k_read_unk()
 933 {
 934   fprintf(stderr, "warning: unknown marker\n");
 935 }
 936
 937 LIBJ2K_API int j2k_encode(j2k_image_t * img, j2k_cp_t * cp, char *outfile,
 938                           int len, char *index)
 939 {
 940   int tileno, compno, layno, resno, precno, pack_nb;
 941   char *dest;
 942   FILE *INDEX;
 943   FILE *f;
 944
 945   if (setjmp(j2k_error)) {
 946     return 0;
 947   }
 948
 949   f = fopen(outfile, "wb");
 950
 951   if (!f) {
 952     fprintf(stderr, "failed to open %s for writing\n", outfile);
 953     return 1;
 954   }
 955
 956   dest = (char *) malloc(len);
 957   cio_init(dest, len);
 958
 959   j2k_img = img;
 960   j2k_cp = cp;
 961   /* j2k_dump_cp(j2k_img, j2k_cp); */
 962
 963   /* INDEX >> */
 964   info_IM.index_on = j2k_img->index_on;
 965   if (info_IM.index_on) {
 966     info_IM.tile =
 967       (info_tile *) malloc(j2k_cp->tw * j2k_cp->th * sizeof(info_tile));
 968     info_IM.Im_w = j2k_img->x1 - j2k_img->x0;
 969     info_IM.Im_h = j2k_img->y1 - j2k_img->y0;
 970     info_IM.Prog = (&j2k_cp->tcps[0])->prg;
 971     /* info_IM.Tile_x=j2k_cp->tw; old version parser */
 972     /* info_IM.Tile_y=j2k_cp->th; old version parser */
 973     info_IM.Tile_x = j2k_cp->tdx;       /* new version parser */
 974     info_IM.Tile_y = j2k_cp->tdy;       /* new version parser */
 975     info_IM.Comp = j2k_img->numcomps;
 976     info_IM.Layer = (&j2k_cp->tcps[0])->numlayers;
 977     info_IM.Decomposition = (&j2k_cp->tcps[0])->tccps->numresolutions - 1;
 978     info_IM.D_max = 0;          /* ADD Marcela */
 979   }
 980   /* << INDEX */
 981
 982   j2k_write_soc();
 983   j2k_write_siz();
 984   j2k_write_cod();
 985   j2k_write_qcd();
 986   for (compno = 0; compno < j2k_img->numcomps; compno++) {
 987     j2k_tcp_t *tcp = &j2k_cp->tcps[0];
 988     if (tcp->tccps[compno].roishift)
 989       j2k_write_rgn(compno, 0);
 990   }
 991   if (j2k_cp->comment != NULL)
 992     j2k_write_com();
 993
 994   /* Writing the main header */
 995   pos_correction = cio_tell();
 996   fwrite(dest, 1, cio_tell(), f);
 997
 998   /* INDEX >> */
 999   if (info_IM.index_on) {
1000     info_IM.Main_head_end = cio_tell() - 1;
1001   }
1002   /* << INDEX */
1003
1004
1005   for (tileno = 0; tileno < cp->tw * cp->th; tileno++) {
1006     fprintf(stderr, "\nTile number %d / %d \n", tileno + 1,
1007             cp->tw * cp->th);
1008
1009     /* new dest for each tile  */
1010     free(dest);
1011     dest = (char *) malloc(len);
1012     cio_init(dest, len);
1013     j2k_curtileno = tileno;
1014     /* initialisation before tile encoding  */
1015
1016     if (tileno == 0) {
1017       tcd_malloc_encode(j2k_img, j2k_cp, j2k_curtileno);
1018     } else {
1019       tcd_init_encode(j2k_img, j2k_cp, j2k_curtileno);
1020     }
1021
1022     /* INDEX >> */
1023     if (info_IM.index_on) {
1024       info_IM.tile[j2k_curtileno].num_tile = j2k_curtileno;
1025       info_IM.tile[j2k_curtileno].start_pos = cio_tell() + pos_correction;
1026     }
1027     /* << INDEX */
1028     j2k_write_sot();
1029
1030     for (compno = 1; compno < img->numcomps; compno++) {
1031       j2k_write_coc(compno);
1032       j2k_write_qcc(compno);
1033     }
1034
1035     if (cp->tcps[tileno].numpocs)
1036       j2k_write_poc();
1037     j2k_write_sod();
1038
1039     /* INDEX >> */
1040     if (info_IM.index_on) {
1041       info_IM.tile[j2k_curtileno].end_pos =
1042         cio_tell() + pos_correction - 1;
1043     }
1044     /* << INDEX */
1045
1046     /*
1047        if (tile->PPT)  BAD PPT !!!
1048        {
1049        FILE *PPT_file;
1050
1051        int i;
1052        PPT_file=fopen("PPT","rb");
1053        fprintf(stderr,"%c%c%c%c",255,97,tile->len_ppt/256,tile->len_ppt%256);
1054        for (i=0;i<tile->len_ppt;i++)
1055        {
1056        unsigned char elmt;
1057        fread(&elmt, 1, 1, PPT_file);
1058        fwrite(&elmt,1,1,f);
1059        }
1060        fclose(PPT_file);
1061        unlink("PPT");
1062        }
1063      */
1064
1065     fwrite(dest, 1, cio_tell(), f);
1066     pos_correction = cio_tell() + pos_correction;
1067   }
1068
1069   free(dest);
1070   dest = (char *) malloc(len);
1071   cio_init(dest, len);
1072
1073   j2k_write_eoc();
1074
1075   fwrite(dest, 1, 2, f);
1076   free(dest);
1077   /* closing file *.j2k */
1078   fclose(f);
1079
1080   /* Creation of the index file     */
1081   if (info_IM.index_on) {
1082     info_IM.codestream_size = cio_tell() + pos_correction;      /* Correction 14/4/03 suite rmq de Patrick */
1083     INDEX = fopen(index, "w");
1084
1085     if (!INDEX) {
1086       fprintf(stderr, "failed to open %s for writing\n", index);
1087       return 1;
1088     }
1089
1090     fprintf(INDEX, "%d %d\n", info_IM.Im_w, info_IM.Im_h);
1091     fprintf(INDEX, "%d\n", info_IM.Prog);
1092     fprintf(INDEX, "%d %d\n", info_IM.Tile_x, info_IM.Tile_y);
1093     fprintf(INDEX, "%d\n", info_IM.Comp);
1094     fprintf(INDEX, "%d\n", info_IM.Layer);
1095     fprintf(INDEX, "%d\n", info_IM.Decomposition);
1096     fprintf(INDEX, "%d %d\n", info_IM.pdx, info_IM.pdy);
1097     fprintf(INDEX, "%d\n", info_IM.Main_head_end);
1098     fprintf(INDEX, "%d\n", info_IM.codestream_size);
1099     fprintf(INDEX, "%f\n", info_IM.D_max);
1100     for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {
1101       fprintf(INDEX, "%d %d %d %d", info_IM.tile[tileno].num_tile,
1102               info_IM.tile[tileno].start_pos,
1103               info_IM.tile[tileno].end_header,
1104               info_IM.tile[tileno].end_pos);
1105       /*for (layno=0;layno<info_IM.Layer;layno++)
1106          fprintf(INDEX, " %f",info_IM.tile[tileno].thresh[layno]);
1107        */ fprintf(INDEX, "\n");
1108     }
1109     for (tileno = 0; tileno < j2k_cp->tw * j2k_cp->th; tileno++) {
1110       pack_nb = 0;
1111       if (info_IM.Prog == 0) {  /* LRCP */
1112         for (layno = 0; layno < info_IM.Layer; layno++) {
1113           for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1114             for (compno = 0; compno < info_IM.Comp; compno++) {
1115               for (precno = 0;
1116                    precno <
1117                    info_IM.tile[tileno].pw *
1118                    info_IM.tile[tileno].ph; precno++) {
1119                 fprintf(INDEX,
1120                         "%d %d %d %d %d %d %d %d %.08f\n",
1121                         pack_nb, tileno, layno, resno,
1122                         compno, precno,
1123                         info_IM.tile[tileno].
1124                         packet[pack_nb].start_pos,
1125                         info_IM.tile[tileno].
1126                         packet[pack_nb].end_pos,
1127                         info_IM.tile[tileno].
1128                         packet[pack_nb].disto / info_IM.D_max);
1129                 /*fprintf(INDEX, "%d %d %d %d %d %d %d %d\n", pack_nb, tileno, layno, resno, compno, precno, info_IM.tile[tileno].packet[pack_nb].start_pos, info_IM.tile[tileno].packet[pack_nb].end_pos); */
1130                 pack_nb++;
1131               }
1132             }
1133           }
1134         }
1135       } else if (info_IM.Prog == 1) {   /* RLCP */
1136         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1137           for (layno = 0; layno < info_IM.Layer; layno++) {
1138             for (compno = 0; compno < info_IM.Comp; compno++) {
1139               for (precno = 0; precno < info_IM.pw * info_IM.ph; precno++) {
1140                 /* fprintf(INDEX,"%d %d %d %d %d %d %d %d %.04f\n",pack_nb,tileno,layno,resno,compno,precno,info_IM.tile[tileno].packet[pack_nb].start_pos,info_IM.tile[tileno].packet[pack_nb].end_pos,info_IM.tile[tileno].packet[pack_nb].disto/info_IM.D_max); */
1141                 fprintf(INDEX, "%d %d %d %d %d %d %d %d\n",
1142                         pack_nb, tileno, layno, resno,
1143                         compno, precno,
1144                         info_IM.tile[tileno].
1145                         packet[pack_nb].start_pos,
1146                         info_IM.tile[tileno].packet[pack_nb].end_pos);
1147                 pack_nb++;
1148               }
1149             }
1150           }
1151         }
1152       } else if (info_IM.Prog == 2) {   /* RPCL */
1153         for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1154           for (precno = 0; precno < info_IM.pw * info_IM.ph; precno++) {
1155             for (compno = 0; compno < info_IM.Comp; compno++) {
1156               for (layno = 0; layno < info_IM.Layer; layno++) {
1157                 /* fprintf(INDEX,"%d %d %d %d %d %d %d %d %.04f\n",pack_nb,tileno,layno,resno,compno,precno,info_IM.tile[tileno].packet[pack_nb].start_pos,info_IM.tile[tileno].packet[pack_nb].end_pos,info_IM.tile[tileno].packet[pack_nb].disto/info_IM.D_max); */
1158                 fprintf(INDEX, "%d %d %d %d %d %d %d %d\n",
1159                         pack_nb, tileno, layno, resno,
1160                         compno, precno,
1161                         info_IM.tile[tileno].
1162                         packet[pack_nb].start_pos,
1163                         info_IM.tile[tileno].packet[pack_nb].end_pos);
1164                 pack_nb++;
1165               }
1166             }
1167           }
1168         }
1169       } else if (info_IM.Prog == 3) {   /* PCRL */
1170         for (precno = 0; precno < info_IM.pw * info_IM.ph; precno++) {
1171           for (compno = 0; compno < info_IM.Comp; compno++) {
1172             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1173               for (layno = 0; layno < info_IM.Layer; layno++) {
1174                 /* fprintf(INDEX,"%d %d %d %d %d %d %d %d %.04f\n",pack_nb,tileno,layno,resno,compno,precno,info_IM.tile[tileno].packet[pack_nb].start_pos,info_IM.tile[tileno].packet[pack_nb].end_pos,info_IM.tile[tileno].packet[pack_nb].disto/info_IM.D_max); */
1175                 fprintf(INDEX, "%d %d %d %d %d %d %d %d\n",
1176                         pack_nb, tileno, layno, resno,
1177                         compno, precno,
1178                         info_IM.tile[tileno].
1179                         packet[pack_nb].start_pos,
1180                         info_IM.tile[tileno].packet[pack_nb].end_pos);
1181                 pack_nb++;
1182               }
1183             }
1184           }
1185         }
1186       } else {                  /* CPRL */
1187
1188         for (compno = 0; compno < info_IM.Comp; compno++) {
1189           for (precno = 0; precno < info_IM.pw * info_IM.ph; precno++) {
1190             for (resno = 0; resno < info_IM.Decomposition + 1; resno++) {
1191               for (layno = 0; layno < info_IM.Layer; layno++) {
1192                 /*fprintf(INDEX,"%d %d %d %d %d %d %d %d %.04f\n",pack_nb,tileno,layno,resno,compno,precno,info_IM.tile[tileno].packet[pack_nb].start_pos,info_IM.tile[tileno].packet[pack_nb].end_pos,info_IM.tile[tileno].packet[pack_nb].disto/info_IM.D_max); */
1193                 fprintf(INDEX, "%d %d %d %d %d %d %d %d\n",
1194                         pack_nb, tileno, layno, resno,
1195                         compno, precno,
1196                         info_IM.tile[tileno].
1197                         packet[pack_nb].start_pos,
1198                         info_IM.tile[tileno].packet[pack_nb].end_pos);
1199                 pack_nb++;
1200               }
1201             }
1202           }
1203         }
1204       }
1205     }
1206     fclose(INDEX);
1207   }
1208
1209   j2k_clean();
1210
1211   return cio_tell();
1212 }
1213
1214 typedef struct {
1215   int id;
1216   int states;
1217   void (*handler) ();
1218 } j2k_dec_mstabent_t;
1219
1220 j2k_dec_mstabent_t j2k_dec_mstab[] = {
1221   {J2K_MS_SOC, J2K_STATE_MHSOC, j2k_read_soc},
1222   {J2K_MS_SOT, J2K_STATE_MH | J2K_STATE_TPHSOT, j2k_read_sot},
1223   {J2K_MS_SOD, J2K_STATE_TPH, j2k_read_sod},
1224   {J2K_MS_EOC, J2K_STATE_TPHSOT, j2k_read_eoc},
1225   {J2K_MS_SIZ, J2K_STATE_MHSIZ, j2k_read_siz},
1226   {J2K_MS_COD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_cod},
1227   {J2K_MS_COC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_coc},
1228   {J2K_MS_RGN, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_rgn},
1229   {J2K_MS_QCD, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcd},
1230   {J2K_MS_QCC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_qcc},
1231   {J2K_MS_POC, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_poc},
1232   {J2K_MS_TLM, J2K_STATE_MH, j2k_read_tlm},
1233   {J2K_MS_PLM, J2K_STATE_MH, j2k_read_plm},
1234   {J2K_MS_PLT, J2K_STATE_TPH, j2k_read_plt},
1235   {J2K_MS_PPM, J2K_STATE_MH, j2k_read_ppm},
1236   {J2K_MS_PPT, J2K_STATE_TPH, j2k_read_ppt},
1237   {J2K_MS_SOP, 0, 0},
1238   {J2K_MS_CRG, J2K_STATE_MH, j2k_read_crg},
1239   {J2K_MS_COM, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_com},
1240   {0, J2K_STATE_MH | J2K_STATE_TPH, j2k_read_unk}
1241 };
1242
1243 j2k_dec_mstabent_t *j2k_dec_mstab_lookup(int id)
1244 {
1245   j2k_dec_mstabent_t *e;
1246   for (e = j2k_dec_mstab; e->id != 0; e++) {
1247     if (e->id == id) {
1248       break;
1249     }
1250   }
1251   return e;
1252 }
1253
1254 LIBJ2K_API int j2k_decode(unsigned char *src, int len, j2k_image_t ** img,
1255                           j2k_cp_t ** cp, j2k_option_t option)
1256 {
1257
1258   if (setjmp(j2k_error)) {
1259     if (j2k_state != J2K_STATE_MT) {
1260       fprintf(stderr, "WARNING: incomplete bitstream\n");
1261       return 0;
1262     }
1263     return cio_numbytes();
1264   }
1265
1266   j2k_img = (j2k_image_t *) malloc(sizeof(j2k_image_t));
1267   j2k_cp = (j2k_cp_t *) malloc(sizeof(j2k_cp_t));
1268   *img = j2k_img;
1269   *cp = j2k_cp;
1270   /* Option */
1271   j2k_cp->reduce_on = option.reduce_on;
1272   j2k_cp->reduce_value = option.reduce_value;
1273
1274   j2k_state = J2K_STATE_MHSOC;
1275   cio_init(src, len);
1276
1277   for (;;) {
1278     j2k_dec_mstabent_t *e;
1279     int id = cio_read(2);
1280     if (id >> 8 != 0xff) {
1281       fprintf(stderr, "%.8x: expected a marker instead of %x\n",
1282               cio_tell() - 2, id);
1283       return 0;
1284     }
1285     e = j2k_dec_mstab_lookup(id);
1286     if (!(j2k_state & e->states)) {
1287       fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1288       return 0;
1289     }
1290     if (e->handler) {
1291       (*e->handler) ();
1292     }
1293     if (j2k_state == J2K_STATE_NEOC)
1294       break;                    /* RAJOUTE */
1295   }
1296   if (j2k_state == J2K_STATE_NEOC)
1297     j2k_read_eoc();             /* RAJOUTE */
1298
1299   return 0;
1300 }
1301
1302 /*
1303  * Read a JPT-stream and decode file
1304  *
1305  */
1306 int j2k_decode_jpt_stream(unsigned char *src, int len, j2k_image_t ** img,
1307                           j2k_cp_t ** cp)
1308 {
1309   jpt_msg_header_struct_t header;
1310   int position;
1311
1312   if (setjmp(j2k_error)) {
1313     if (j2k_state != J2K_STATE_MT) {
1314       fprintf(stderr, "WARNING: incomplete bitstream\n");
1315       return 0;
1316     }
1317     return cio_numbytes();
1318   }
1319
1320   j2k_img = (j2k_image_t *) malloc(sizeof(j2k_image_t));
1321   j2k_cp = (j2k_cp_t *) malloc(sizeof(j2k_cp_t));
1322   *img = j2k_img;
1323   *cp = j2k_cp;
1324
1325   j2k_state = J2K_STATE_MHSOC;
1326   cio_init(src, len);
1327
1328   /* Initialize the header */
1329   jpt_init_Msg_Header(&header);
1330   /* Read the first header of the message */
1331   jpt_read_Msg_Header(&header);
1332
1333   position = cio_tell();
1334   if (header.Class_Id != 6) {   /* 6 : Main header data-bin message */
1335     fprintf(stderr,
1336             "[JPT-stream] : Expecting Main header first [class_Id %d] !\n",
1337             header.Class_Id);
1338     return 0;
1339   }
1340
1341   for (;;) {
1342     j2k_dec_mstabent_t *e;
1343     int id;
1344
1345     if (!cio_numbytesleft()) {
1346       j2k_read_eoc();
1347       return 0;
1348     }
1349     /* data-bin read -> need to read a new header */
1350     if ((unsigned int)(cio_tell() - position) == header.Msg_length) {
1351       jpt_read_Msg_Header(&header);
1352       position = cio_tell();
1353       if (header.Class_Id != 4) {       /* 4 : Tile data-bin message */
1354         fprintf(stderr, "[JPT-stream] : Expecting Tile info !\n");
1355         return 0;
1356       }
1357     }
1358
1359     id = cio_read(2);
1360     if (id >> 8 != 0xff) {
1361       fprintf(stderr, "%.8x: expected a marker instead of %x\n",
1362               cio_tell() - 2, id);
1363       return 0;
1364     }
1365     e = j2k_dec_mstab_lookup(id);
1366     if (!(j2k_state & e->states)) {
1367       fprintf(stderr, "%.8x: unexpected marker %x\n", cio_tell() - 2, id);
1368       return 0;
1369     }
1370     if (e->handler) {
1371       (*e->handler) ();
1372     }
1373     if (j2k_state == J2K_STATE_NEOC)
1374       break;                    /* RAJOUTE */
1375   }
1376   if (j2k_state == J2K_STATE_NEOC)
1377     j2k_read_eoc();             /* RAJOUTE */
1378
1379   return 0;
1380 }
1381
1382 #ifdef WIN32
1383 #include <windows.h>
1384
1385 BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call,
1386                       LPVOID lpReserved)
1387 {
1388   switch (ul_reason_for_call) {
1389   case DLL_PROCESS_ATTACH:
1390   case DLL_THREAD_ATTACH:
1391   case DLL_THREAD_DETACH:
1392   case DLL_PROCESS_DETACH:
1393     break;
1394   }
1395   return TRUE;
1396 }
1397 #endif