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