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