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