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