libopenjpeg/j2k.c

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