]> Creatis software - gdcm.git/blob - src/gdcmopenjpeg/libopenjpeg/t2.c
Add IsParsable() method, to avoid confusion with IsReadable()
[gdcm.git] / src / gdcmopenjpeg / libopenjpeg / t2.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 "t2.h"
30 #include "tcd.h"
31 #include "bio.h"
32 #include "j2k.h"
33 #include "pi.h"
34 #include "tgt.h"
35 #include "int.h"
36 #include "cio.h"
37 #include <stdio.h>
38 #include <setjmp.h>
39 #include <string.h>
40 #include <stdlib.h>
41
42 #define RESTART 0x04
43
44 extern jmp_buf j2k_error;
45
46 void t2_putcommacode(int n)
47 {
48   while (--n >= 0) {
49     bio_write(1, 1);
50   }
51   bio_write(0, 1);
52 }
53
54 int t2_getcommacode()
55 {
56   int n;
57   for (n = 0; bio_read(1); n++) {
58   }
59   return n;
60 }
61
62 /* <summary> */
63 /* Variable length code for signalling delta Zil (truncation point) */
64 /* <val> n : delta Zil */
65 /* <\summary> */
66 void t2_putnumpasses(int n)
67 {
68   if (n == 1) {
69     bio_write(0, 1);
70   } else if (n == 2) {
71     bio_write(2, 2);
72   } else if (n <= 5) {
73     bio_write(0xc | (n - 3), 4);
74   } else if (n <= 36) {
75     bio_write(0x1e0 | (n - 6), 9);
76   } else if (n <= 164) {
77     bio_write(0xff80 | (n - 37), 16);
78   }
79 }
80
81 int t2_getnumpasses()
82 {
83   int n;
84   if (!bio_read(1))
85     return 1;
86   if (!bio_read(1))
87     return 2;
88   if ((n = bio_read(2)) != 3)
89     return 3 + n;
90   if ((n = bio_read(5)) != 31)
91     return 6 + n;
92   return 37 + bio_read(7);
93 }
94
95 /*
96  * Encode a packet of a tile to a destination buffer
97  *
98  * Tile    : the tile for which to write the packets
99  * tcp     : the tile coding parameters
100  * compno  : Identity of the packet --> component value
101  * resno   : Identity of the packet --> resolution level value
102  * precno  : Identity of the packet --> precinct value
103  * layno   : Identity of the packet --> quality layer value
104  * dest    : the destination buffer
105  * len     : the length of the destination buffer
106  * info_IM : structure to create an index file
107  * tileno  : number of the tile encoded
108 */
109 int t2_encode_packet(tcd_tile_t * tile, j2k_tcp_t * tcp, int compno,
110            int resno, int precno, int layno, unsigned char *dest,
111            int len, info_image * info_IM, int tileno)
112 {
113   int bandno, cblkno;
114   unsigned char *sop = 0, *eph = 0;
115   tcd_tilecomp_t *tilec = &tile->comps[compno];
116   tcd_resolution_t *res = &tilec->resolutions[resno];
117   unsigned char *c = dest;
118
119   /* <SOP 0xff91> */
120   if (tcp->csty & J2K_CP_CSTY_SOP) {
121     sop = (unsigned char *) malloc(6 * sizeof(unsigned char));
122     sop[0] = 255;
123     sop[1] = 145;
124     sop[2] = 0;
125     sop[3] = 4;
126     sop[4] = (info_IM->num % 65536) / 256;
127     sop[5] = (info_IM->num % 65536) % 256;
128     memcpy(c, sop, 6);
129     free(sop);
130     c += 6;
131   }
132   /* </SOP> */
133
134   if (!layno) {
135     for (bandno = 0; bandno < res->numbands; bandno++) {
136       tcd_band_t *band = &res->bands[bandno];
137       tcd_precinct_t *prc = &band->precincts[precno];
138       tgt_reset(prc->incltree);
139       tgt_reset(prc->imsbtree);
140       for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
141    tcd_cblk_t *cblk = &prc->cblks[cblkno];
142    cblk->numpasses = 0;
143    tgt_setvalue(prc->imsbtree, cblkno, band->numbps - cblk->numbps);
144       }
145     }
146   }
147
148   bio_init_enc(c, len);
149   bio_write(1, 1);      /* Empty header bit */
150
151   /* Writing Packet header */
152   for (bandno = 0; bandno < res->numbands; bandno++) {
153     tcd_band_t *band = &res->bands[bandno];
154     tcd_precinct_t *prc = &band->precincts[precno];
155     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
156       tcd_cblk_t *cblk = &prc->cblks[cblkno];
157       tcd_layer_t *layer = &cblk->layers[layno];
158       if (!cblk->numpasses && layer->numpasses) {
159    tgt_setvalue(prc->incltree, cblkno, layno);
160       }
161     }
162     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
163       tcd_cblk_t *cblk = &prc->cblks[cblkno];
164       tcd_layer_t *layer = &cblk->layers[layno];
165       int increment = 0;
166       int nump = 0;
167       int len = 0, passno;
168       /* cblk inclusion bits */
169       if (!cblk->numpasses) {
170    tgt_encode(prc->incltree, cblkno, layno + 1);
171       } else {
172    bio_write(layer->numpasses != 0, 1);
173       }
174       /* if cblk not included, go to the next cblk  */
175       if (!layer->numpasses) {
176    continue;
177       }
178       /* if first instance of cblk --> zero bit-planes information */
179       if (!cblk->numpasses) {
180    cblk->numlenbits = 3;
181    tgt_encode(prc->imsbtree, cblkno, 999);
182       }
183       /* number of coding passes included */
184       t2_putnumpasses(layer->numpasses);
185
186       /* computation of the increase of the length indicator and insertion in the header     */
187       for (passno = cblk->numpasses;
188       passno < cblk->numpasses + layer->numpasses; passno++) {
189    tcd_pass_t *pass = &cblk->passes[passno];
190    nump++;
191    len += pass->len;
192    if (pass->term
193        || passno == (cblk->numpasses + layer->numpasses) - 1) {
194      increment =
195        int_max(increment,
196           int_floorlog2(len) + 1 -
197           (cblk->numlenbits + int_floorlog2(nump)));
198      len = 0;
199      nump = 0;
200    }
201       }
202       t2_putcommacode(increment);
203       /* computation of the new Length indicator */
204       cblk->numlenbits += increment;
205       /* insertion of the codeword segment length */
206
207       for (passno = cblk->numpasses;
208       passno < cblk->numpasses + layer->numpasses; passno++) {
209    tcd_pass_t *pass = &cblk->passes[passno];
210    nump++;
211    len += pass->len;
212    if (pass->term
213        || passno == (cblk->numpasses + layer->numpasses) - 1) {
214      bio_write(len, cblk->numlenbits + int_floorlog2(nump));
215      len = 0;
216      nump = 0;
217    }
218       }
219     }
220   }
221
222   if (bio_flush())
223     return -999;      /* modified to eliminate longjmp !! */
224
225   c += bio_numbytes();
226
227   /* <EPH 0xff92> */
228   if (tcp->csty & J2K_CP_CSTY_EPH) {
229     eph = (unsigned char *) malloc(2 * sizeof(unsigned char));
230     eph[0] = 255;
231     eph[1] = 146;
232     memcpy(c, eph, 2);
233     free(eph);
234     c += 2;
235   }
236   /* </EPH> */
237
238   /* Writing the packet body */
239
240   for (bandno = 0; bandno < res->numbands; bandno++) {
241     tcd_band_t *band = &res->bands[bandno];
242     tcd_precinct_t *prc = &band->precincts[precno];
243     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
244       tcd_cblk_t *cblk = &prc->cblks[cblkno];
245       tcd_layer_t *layer = &cblk->layers[layno];
246       if (!layer->numpasses) {
247    continue;
248       }
249       if (c + layer->len > dest + len) {
250    return -999;
251       }
252
253       memcpy(c, layer->data, layer->len);
254       cblk->numpasses += layer->numpasses;
255       c += layer->len;
256       /* ADD for index Cfr. Marcela --> delta disto by packet */
257       if (info_IM->index_write && info_IM->index_on) {
258    info_tile *info_TL = &info_IM->tile[tileno];
259    info_packet *info_PK = &info_TL->packet[info_IM->num];
260    info_PK->disto += layer->disto;
261    if (info_IM->D_max < info_PK->disto)
262      info_IM->D_max = info_PK->disto;
263       }            /* </ADD> */
264     }
265   }
266   return c - dest;
267 }
268
269 void t2_init_seg(tcd_seg_t * seg, int cblksty, int first)
270 {
271   seg->numpasses = 0;
272   seg->len = 0;
273   if (cblksty & J2K_CCP_CBLKSTY_TERMALL)
274     seg->maxpasses = 1;
275   else if (cblksty & J2K_CCP_CBLKSTY_LAZY) {
276     if (first)
277       seg->maxpasses = 10;
278     else
279       seg->maxpasses = (((seg - 1)->maxpasses == 1)
280          || ((seg - 1)->maxpasses == 10)) ? 2 : 1;
281   } else
282     seg->maxpasses = 109;
283 }
284
285 /*  
286  * Decode a packet of a tile from a source buffer
287  *
288  * src          : the source buffer
289  * len          : the length of the source buffer
290  * tile         : the tile for which to write the packets
291  * cp           : the image coding parameters
292  * tcp          : the tile coding parameters
293  * compno  : Identity of the packet --> component value
294  * resno      : Identity of the packet --> resolution level value
295  * precno    : Identity of the packet --> precinct value
296  * layno      : Identity of the packet --> quality layer value
297  */
298 int t2_decode_packet(unsigned char *src, int len, tcd_tile_t * tile,
299            j2k_cp_t * cp, j2k_tcp_t * tcp, int compno, int resno,
300            int precno, int layno)
301 {
302   int bandno, cblkno;
303   tcd_tilecomp_t *tilec = &tile->comps[compno];
304   tcd_resolution_t *res = &tilec->resolutions[resno];
305   unsigned char *c = src;
306
307   unsigned char *hd = NULL;
308   int present;
309
310   if (layno == 0) {
311     for (bandno = 0; bandno < res->numbands; bandno++) {
312       tcd_band_t *band = &res->bands[bandno];
313       tcd_precinct_t *prc = &band->precincts[precno];
314
315       
316
317       /*Add Antonin : sizebug1*/
318
319       if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
320
321       /*ddA*/
322
323       
324       tgt_reset(prc->incltree);
325       tgt_reset(prc->imsbtree);
326       for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
327    tcd_cblk_t *cblk = &prc->cblks[cblkno];
328    cblk->numsegs = 0;
329       }
330     }
331   }
332
333   
334
335   /* SOP markers*/
336
337   if (tcp->csty & J2K_CP_CSTY_SOP) {
338
339     if ((*c) != 0xff || (*(c + 1) != 0x91)) {
340
341       fprintf(stderr,"Warning : expected SOP marker\n");
342
343     } else {
344
345       c += 6;
346
347     }
348
349     /*TODO : check the Nsop value*/
350
351   }
352
353   /* When the marker PPT/PPM is used the packet header are store in PPT/PPM marker
354   This part deal with this caracteristic
355   step 1: Read packet header in the saved structure
356   step 2: Return to codestream for decoding */
357
358
359   if (cp->ppm == 1) {      /* PPM */
360     hd = cp->ppm_data;
361     bio_init_dec(hd, cp->ppm_len); /*Mod Antonin : ppmbug1*/
362   } else if (tcp->ppt == 1) {   /* PPT */
363     hd = tcp->ppt_data;
364     bio_init_dec(hd, tcp->ppt_len);  /*Mod Antonin : ppmbug1*/
365   } else {         /* Normal Case */
366
367     hd = c;
368
369     bio_init_dec(hd, src+len-hd);
370
371   }
372   
373   present = bio_read(1);
374
375   if (!present) {
376     bio_inalign();
377
378     hd += bio_numbytes();
379
380
381
382     /* EPH markers*/
383
384     if (tcp->csty & J2K_CP_CSTY_EPH) {
385
386       if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
387
388    printf("Error : expected EPH marker\n");
389
390       } else {
391
392    hd += 2;
393
394       }
395
396     }
397
398     if (cp->ppm == 1) {      /* PPM case */
399
400       cp->ppm_len+=cp->ppm_data-hd;
401       cp->ppm_data = hd;
402       return c - src;
403     }
404     if (tcp->ppt == 1) {   /* PPT case */
405
406       tcp->ppt_len+=tcp->ppt_data-hd;
407       tcp->ppt_data = hd;
408       return c - src;
409     }
410
411
412     return hd - src;
413   }
414
415
416   for (bandno = 0; bandno < res->numbands; bandno++) {
417     tcd_band_t *band = &res->bands[bandno];
418     tcd_precinct_t *prc = &band->precincts[precno];
419
420
421
422     /*Add Antonin : sizebug1*/
423
424     if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
425
426     /*ddA*/
427
428
429     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
430       int included, increment, n;
431       tcd_cblk_t *cblk = &prc->cblks[cblkno];
432       tcd_seg_t *seg;
433       /* if cblk not yet included before --> inclusion tagtree */
434       if (!cblk->numsegs) {
435    included = tgt_decode(prc->incltree, cblkno, layno + 1);
436    /* else one bit */
437       } else {
438    included = bio_read(1);
439       }
440       /* if cblk not included */
441       if (!included) {
442    cblk->numnewpasses = 0;
443    continue;
444       }
445       /* if cblk not yet included --> zero-bitplane tagtree */
446       if (!cblk->numsegs) {
447    int i, numimsbs;
448    for (i = 0; !tgt_decode(prc->imsbtree, cblkno, i); i++) {
449    }
450    numimsbs = i - 1;
451    cblk->numbps = band->numbps - numimsbs;
452    cblk->numlenbits = 3;
453       }
454       /* number of coding passes */
455       cblk->numnewpasses = t2_getnumpasses();
456       increment = t2_getcommacode();
457       /* length indicator increment */
458       cblk->numlenbits += increment;
459       if (!cblk->numsegs) {
460    seg = &cblk->segs[0];
461    t2_init_seg(seg, tcp->tccps[compno].cblksty, 1);
462       } else {
463    seg = &cblk->segs[cblk->numsegs - 1];
464    if (seg->numpasses == seg->maxpasses) {
465      t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
466    }
467       }
468       n = cblk->numnewpasses;
469
470       do {
471    seg->numnewpasses = int_min(seg->maxpasses - seg->numpasses, n);
472    seg->newlen =
473      bio_read(cblk->numlenbits + int_floorlog2(seg->numnewpasses));
474    n -= seg->numnewpasses;
475    if (n > 0) {
476      t2_init_seg(++seg, tcp->tccps[compno].cblksty, 0);
477    }
478       } while (n > 0);
479     }
480   }
481   if (bio_inalign())
482     return -999;
483
484   hd += bio_numbytes();
485
486
487   /* EPH markers*/
488   if (tcp->csty & J2K_CP_CSTY_EPH) {
489     if ((*hd) != 0xff || (*(hd + 1) != 0x92)) {
490       fprintf(stderr,"Error : expected EPH marker\n");
491     } else {
492       hd += 2;
493
494     }
495   }
496
497
498
499   if (cp->ppm==1) {
500
501     cp->ppm_len+=cp->ppm_data-hd;
502
503     cp->ppm_data = hd;
504
505   } else if (tcp->ppt == 1) {
506
507     tcp->ppt_len+=tcp->ppt_data-hd;
508
509     tcp->ppt_data = hd;
510
511   } else {
512
513     c=hd;
514
515   }
516
517   for (bandno = 0; bandno < res->numbands; bandno++) {
518     tcd_band_t *band = &res->bands[bandno];
519     tcd_precinct_t *prc = &band->precincts[precno];
520
521
522
523     /*Add Antonin : sizebug1*/
524
525     if ((band->x1-band->x0 == 0)||(band->y1-band->y0 == 0)) continue;
526
527     /*ddA*/
528
529
530     for (cblkno = 0; cblkno < prc->cw * prc->ch; cblkno++) {
531       tcd_cblk_t *cblk = &prc->cblks[cblkno];
532       tcd_seg_t *seg;
533       if (!cblk->numnewpasses)
534    continue;
535       if (!cblk->numsegs) {
536    seg = &cblk->segs[0];
537
538    cblk->numsegs++;
539    cblk->len = 0;
540       } else {
541    seg = &cblk->segs[cblk->numsegs - 1];
542    if (seg->numpasses == seg->maxpasses) {
543      seg++;
544      cblk->numsegs++;
545    }
546       }
547       do {
548    if (c + seg->newlen > src + len) {
549      return -999;
550    }
551
552    memcpy(cblk->data + cblk->len, c, seg->newlen);
553    if (seg->numpasses == 0) {
554      seg->data = cblk->data + cblk->len;
555    }
556    c += seg->newlen;
557    cblk->len += seg->newlen;
558    seg->len += seg->newlen;
559    seg->numpasses += seg->numnewpasses;
560    cblk->numnewpasses -= seg->numnewpasses;
561    if (cblk->numnewpasses > 0) {
562      seg++;
563      cblk->numsegs++;
564    }
565       } while (cblk->numnewpasses > 0);
566     }
567   }
568
569   return c - src;
570 }
571
572
573
574 /*
575  * Encode the packets of a tile to a destination buffer
576  *
577  * img        : the source image
578  * cp         : the image coding parameters
579  * tileno     : number of the tile encoded
580  * tile       : the tile for which to write the packets
581  * maxlayers  : maximum number of layers
582  * dest       : the destination buffer
583  * len        : the length of the destination buffer
584  * info_IM    : structure to create an index file
585  */
586 int t2_encode_packets(j2k_image_t * img, j2k_cp_t * cp, int tileno,
587             tcd_tile_t * tile, int maxlayers,
588             unsigned char *dest, int len, info_image * info_IM)
589 {
590   unsigned char *c = dest;
591   int e = 0;
592   pi_iterator_t *pi;
593   int pino, compno;
594
595   pi = pi_create(img, cp, tileno);
596
597   for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
598     while (pi_next(&pi[pino])) {
599       if (pi[pino].layno < maxlayers) {
600    e = t2_encode_packet(tile, &cp->tcps[tileno],
601               pi[pino].compno, pi[pino].resno,
602               pi[pino].precno, pi[pino].layno, c,
603               dest + len - c, info_IM, tileno);
604    if (e == -999) {
605      break;
606    } else
607      c += e;
608    /* INDEX >> */
609    if (info_IM->index_write && info_IM->index_on) {
610      info_tile *info_TL = &info_IM->tile[tileno];
611      info_packet *info_PK = &info_TL->packet[info_IM->num];
612      if (!info_IM->num) {
613        info_PK->start_pos = info_TL->end_header + 1;
614      } else {
615        info_PK->start_pos =
616          info_TL->packet[info_IM->num - 1].end_pos + 1;
617      }
618      info_PK->end_pos = info_PK->start_pos + e - 1;
619
620    }
621    /* << INDEX */
622    if ((info_IM->index_write
623         && cp->tcps[tileno].csty & J2K_CP_CSTY_SOP)
624        || (info_IM->index_write && info_IM->index_on)) {
625      info_IM->num++;
626    }
627       }
628
629     }
630
631     /* FREE space memory taken by pi */
632     for (compno = 0; compno < pi[pino].numcomps; compno++) {
633       free(pi[pino].comps[compno].resolutions);
634     }
635     free(pi[pino].comps);
636   }
637   free(pi[0].include);
638   free(pi);
639   if (e == -999)
640     return e;
641   else
642     return c - dest;
643 }
644
645
646
647 /*
648  * Decode the packets of a tile from a source buffer
649  *
650  * src: the source buffer
651  * len: length of the source buffer
652  * img: destination image
653  * cp: image coding parameters
654  * tileno: number that identifies the tile for which to decode the packets
655  * tile: tile for which to decode the packets
656  */
657 int t2_decode_packets(unsigned char *src, int len, j2k_image_t * img,
658             j2k_cp_t * cp, int tileno, tcd_tile_t * tile)
659 {
660   unsigned char *c = src;
661   pi_iterator_t *pi;
662   int pino, compno, e = 0;
663   int n = 0;
664
665   pi = pi_create(img, cp, tileno);
666
667   for (pino = 0; pino <= cp->tcps[tileno].numpocs; pino++) {
668     while (pi_next(&pi[pino])) {
669       
670       if ((cp->layer==0) || (cp->layer>=((pi[pino].layno)+1))) {
671    e = t2_decode_packet(c, src + len - c, tile, cp,
672      &cp->tcps[tileno], pi[pino].compno,
673      pi[pino].resno, pi[pino].precno,
674      pi[pino].layno);
675       } else {
676    e = 0;
677       }
678       
679       /* progression in resolution */
680       img->comps[pi[pino].compno].resno_decoded =
681    e > 0 ? int_max(pi[pino].resno,
682    img->comps[pi[pino].compno].
683    resno_decoded) : img->comps[pi[pino].
684    compno].resno_decoded;
685       n++;
686       
687       if (e == -999) {      /* ADD */
688    break;
689       } else {
690    c += e;
691       }
692     }
693
694     /* FREE space memory taken by pi */
695     for (compno = 0; compno < pi[pino].numcomps; compno++) {
696       free(pi[pino].comps[compno].resolutions);
697     }
698     free(pi[pino].comps);
699   }
700   free(pi[0].include);
701   free(pi);
702
703   if (e == -999)
704     return e;
705   else
706     return c - src;
707 }