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