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