1 /*
2  * Copyright (c) 1999-2000 Image Power, Inc. and the University of
3  *   British Columbia.
4  * Copyright (c) 2001-2003 Michael David Adams.
5  * All rights reserved.
6  */
7 
8 /* __START_OF_JASPER_LICENSE__
9  *
10  * JasPer License Version 2.0
11  *
12  * Copyright (c) 2001-2006 Michael David Adams
13  * Copyright (c) 1999-2000 Image Power, Inc.
14  * Copyright (c) 1999-2000 The University of British Columbia
15  *
16  * All rights reserved.
17  *
18  * Permission is hereby granted, free of charge, to any person (the
19  * "User") obtaining a copy of this software and associated documentation
20  * files (the "Software"), to deal in the Software without restriction,
21  * including without limitation the rights to use, copy, modify, merge,
22  * publish, distribute, and/or sell copies of the Software, and to permit
23  * persons to whom the Software is furnished to do so, subject to the
24  * following conditions:
25  *
26  * 1.  The above copyright notices and this permission notice (which
27  * includes the disclaimer below) shall be included in all copies or
28  * substantial portions of the Software.
29  *
30  * 2.  The name of a copyright holder shall not be used to endorse or
31  * promote products derived from the Software without specific prior
32  * written permission.
33  *
34  * THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
35  * LICENSE.  NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
36  * THIS DISCLAIMER.  THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
37  * "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
38  * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
39  * PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  IN NO
40  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
41  * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.  NO ASSURANCES ARE
45  * PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
46  * THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
47  * EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
48  * BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
49  * PROPERTY RIGHTS OR OTHERWISE.  AS A CONDITION TO EXERCISING THE RIGHTS
50  * GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
51  * ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY.  THE SOFTWARE
52  * IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
53  * SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
54  * AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
55  * SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
56  * THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
57  * PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
58  * RISK ACTIVITIES").  THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
59  * EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
60  *
61  * __END_OF_JASPER_LICENSE__
62  */
63 
64 /*
65  * Tier 2 Decoder
66  *
67  * $Id: jpc_t2dec.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
68  */
69 
70 /******************************************************************************\
71 * Includes.
72 \******************************************************************************/
73 
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <assert.h>
77 
78 #include "jasper/jas_types.h"
79 #include "jasper/jas_fix.h"
80 #include "jasper/jas_malloc.h"
81 #include "jasper/jas_math.h"
82 #include "jasper/jas_stream.h"
83 #include "jasper/jas_debug.h"
84 
85 #include "jpc_bs.h"
86 #include "jpc_dec.h"
87 #include "jpc_cs.h"
88 #include "jpc_mqdec.h"
89 #include "jpc_t2dec.h"
90 #include "jpc_t1cod.h"
91 #include "jpc_math.h"
92 
93 /******************************************************************************\
94 *
95 \******************************************************************************/
96 
97 long jpc_dec_lookahead(jas_stream_t *in);
98 static int jpc_getcommacode(jpc_bitstream_t *in);
99 static int jpc_getnumnewpasses(jpc_bitstream_t *in);
100 static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int lvlno,
101   int prcno, int lyrno);
102 
103 /******************************************************************************\
104 * Code.
105 \******************************************************************************/
106 
jpc_getcommacode(jpc_bitstream_t * in)107 static int jpc_getcommacode(jpc_bitstream_t *in)
108 {
109     int n;
110     int v;
111 
112     n = 0;
113     for (;;) {
114         if ((v = jpc_bitstream_getbit(in)) < 0) {
115             return -1;
116         }
117         if (jpc_bitstream_eof(in)) {
118             return -1;
119         }
120         if (!v) {
121             break;
122         }
123         ++n;
124     }
125 
126     return n;
127 }
128 
jpc_getnumnewpasses(jpc_bitstream_t * in)129 static int jpc_getnumnewpasses(jpc_bitstream_t *in)
130 {
131     int n;
132 
133     if ((n = jpc_bitstream_getbit(in)) > 0) {
134         if ((n = jpc_bitstream_getbit(in)) > 0) {
135             if ((n = jpc_bitstream_getbits(in, 2)) == 3) {
136                 if ((n = jpc_bitstream_getbits(in, 5)) == 31) {
137                     if ((n = jpc_bitstream_getbits(in, 7)) >= 0) {
138                         n += 36 + 1;
139                     }
140                 } else if (n >= 0) {
141                     n += 5 + 1;
142                 }
143             } else if (n >= 0) {
144                 n += 2 + 1;
145             }
146         } else if (!n) {
147             n += 2;
148         }
149     } else if (!n) {
150         ++n;
151     }
152 
153     return n;
154 }
155 
jpc_dec_decodepkt(jpc_dec_t * dec,jas_stream_t * pkthdrstream,jas_stream_t * in,int compno,int rlvlno,int prcno,int lyrno)156 static int jpc_dec_decodepkt(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in, int compno, int rlvlno,
157   int prcno, int lyrno)
158 {
159     jpc_bitstream_t *inb;
160     jpc_dec_tcomp_t *tcomp;
161     jpc_dec_rlvl_t *rlvl;
162     jpc_dec_band_t *band;
163     jpc_dec_cblk_t *cblk;
164     int n;
165     int m;
166     int i;
167     jpc_tagtreenode_t *leaf;
168     int included;
169     int ret;
170     int numnewpasses;
171     jpc_dec_seg_t *seg;
172     int len;
173     int present;
174     int savenumnewpasses;
175     int mycounter;
176     jpc_ms_t *ms;
177     jpc_dec_tile_t *tile;
178     jpc_dec_ccp_t *ccp;
179     jpc_dec_cp_t *cp;
180     int bandno;
181     jpc_dec_prc_t *prc;
182     int usedcblkcnt;
183     int cblkno;
184     uint_fast32_t bodylen;
185     bool discard;
186     int passno;
187     int maxpasses;
188     int hdrlen;
189     int hdroffstart;
190     int hdroffend;
191 
192     /* Avoid compiler warning about possible use of uninitialized
193       variable. */
194     bodylen = 0;
195 
196     discard = (lyrno >= dec->maxlyrs);
197 
198     tile = dec->curtile;
199     cp = tile->cp;
200     ccp = &cp->ccps[compno];
201 
202     /*
203      * Decode the packet header.
204      */
205 
206     /* Decode the SOP marker segment if present. */
207     if (cp->csty & JPC_COD_SOP) {
208         if (jpc_dec_lookahead(in) == JPC_MS_SOP) {
209             if (!(ms = jpc_getms(in, dec->cstate))) {
210                 return -1;
211             }
212             if (jpc_ms_gettype(ms) != JPC_MS_SOP) {
213                 jpc_ms_destroy(ms);
214                 jas_eprintf("missing SOP marker segment\n");
215                 return -1;
216             }
217             jpc_ms_destroy(ms);
218         }
219     }
220 
221 hdroffstart = jas_stream_getrwcount(pkthdrstream);
222 
223     if (!(inb = jpc_bitstream_sopen(pkthdrstream, "r"))) {
224         return -1;
225     }
226 
227     if ((present = jpc_bitstream_getbit(inb)) < 0) {
228         return 1;
229     }
230     JAS_DBGLOG(10, ("\n", present));
231     JAS_DBGLOG(10, ("present=%d ", present));
232 
233     /* Is the packet non-empty? */
234     if (present) {
235         /* The packet is non-empty. */
236         tcomp = &tile->tcomps[compno];
237         rlvl = &tcomp->rlvls[rlvlno];
238         bodylen = 0;
239         for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
240           ++bandno, ++band) {
241             if (!band->data) {
242                 continue;
243             }
244             prc = &band->prcs[prcno];
245             if (!prc->cblks) {
246                 continue;
247             }
248             usedcblkcnt = 0;
249             for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
250               ++cblkno, ++cblk) {
251                 ++usedcblkcnt;
252                 if (!cblk->numpasses) {
253                     leaf = jpc_tagtree_getleaf(prc->incltagtree, usedcblkcnt - 1);
254                     if ((included = jpc_tagtree_decode(prc->incltagtree, leaf, lyrno + 1, inb)) < 0) {
255                         return -1;
256                     }
257                 } else {
258                     if ((included = jpc_bitstream_getbit(inb)) < 0) {
259                         return -1;
260                     }
261                 }
262                 JAS_DBGLOG(10, ("\n"));
263                 JAS_DBGLOG(10, ("included=%d ", included));
264                 if (!included) {
265                     continue;
266                 }
267                 if (!cblk->numpasses) {
268                     i = 1;
269                     leaf = jpc_tagtree_getleaf(prc->numimsbstagtree, usedcblkcnt - 1);
270                     for (;;) {
271                         if ((ret = jpc_tagtree_decode(prc->numimsbstagtree, leaf, i, inb)) < 0) {
272                             return -1;
273                         }
274                         if (ret) {
275                             break;
276                         }
277                         ++i;
278                     }
279                     cblk->numimsbs = i - 1;
280                     cblk->firstpassno = cblk->numimsbs * 3;
281                 }
282                 if ((numnewpasses = jpc_getnumnewpasses(inb)) < 0) {
283                     return -1;
284                 }
285                 JAS_DBGLOG(10, ("numnewpasses=%d ", numnewpasses));
286                 seg = cblk->curseg;
287                 savenumnewpasses = numnewpasses;
288                 mycounter = 0;
289                 if (numnewpasses > 0) {
290                     if ((m = jpc_getcommacode(inb)) < 0) {
291                         return -1;
292                     }
293                     cblk->numlenbits += m;
294                     JAS_DBGLOG(10, ("increment=%d ", m));
295                     while (numnewpasses > 0) {
296                         passno = cblk->firstpassno + cblk->numpasses + mycounter;
297     /* XXX - the maxpasses is not set precisely but this doesn't matter... */
298                         maxpasses = JPC_SEGPASSCNT(passno, cblk->firstpassno, 10000, (ccp->cblkctx & JPC_COX_LAZY) != 0, (ccp->cblkctx & JPC_COX_TERMALL) != 0);
299                         if (!discard && !seg) {
300                             if (!(seg = jpc_seg_alloc())) {
301                                 return -1;
302                             }
303                             jpc_seglist_insert(&cblk->segs, cblk->segs.tail, seg);
304                             if (!cblk->curseg) {
305                                 cblk->curseg = seg;
306                             }
307                             seg->passno = passno;
308                             seg->type = JPC_SEGTYPE(seg->passno, cblk->firstpassno, (ccp->cblkctx & JPC_COX_LAZY) != 0);
309                             seg->maxpasses = maxpasses;
310                         }
311                         n = JAS_MIN(numnewpasses, maxpasses);
312                         mycounter += n;
313                         numnewpasses -= n;
314                         if ((len = jpc_bitstream_getbits(inb, cblk->numlenbits + jpc_floorlog2(n))) < 0) {
315                             return -1;
316                         }
317                         JAS_DBGLOG(10, ("len=%d ", len));
318                         if (!discard) {
319                             seg->lyrno = lyrno;
320                             seg->numpasses += n;
321                             seg->cnt = len;
322                             seg = seg->next;
323                         }
324                         bodylen += len;
325                     }
326                 }
327                 cblk->numpasses += savenumnewpasses;
328             }
329         }
330 
331         jpc_bitstream_inalign(inb, 0, 0);
332 
333     } else {
334         if (jpc_bitstream_inalign(inb, 0x7f, 0)) {
335             jas_eprintf("alignment failed\n");
336             return -1;
337         }
338     }
339     jpc_bitstream_close(inb);
340 
341     hdroffend = jas_stream_getrwcount(pkthdrstream);
342     hdrlen = hdroffend - hdroffstart;
343     if (jas_getdbglevel() >= 5) {
344         jas_eprintf("hdrlen=%lu bodylen=%lu \n", (unsigned long) hdrlen,
345           (unsigned long) bodylen);
346     }
347 
348     if (cp->csty & JPC_COD_EPH) {
349         if (jpc_dec_lookahead(pkthdrstream) == JPC_MS_EPH) {
350             if (!(ms = jpc_getms(pkthdrstream, dec->cstate))) {
351                 jas_eprintf("cannot get (EPH) marker segment\n");
352                 return -1;
353             }
354             if (jpc_ms_gettype(ms) != JPC_MS_EPH) {
355                 jpc_ms_destroy(ms);
356                 jas_eprintf("missing EPH marker segment\n");
357                 return -1;
358             }
359             jpc_ms_destroy(ms);
360         }
361     }
362 
363     /* decode the packet body. */
364 
365     if (jas_getdbglevel() >= 1) {
366         jas_eprintf("packet body offset=%06ld\n", (long) jas_stream_getrwcount(in));
367     }
368 
369     if (!discard) {
370         tcomp = &tile->tcomps[compno];
371         rlvl = &tcomp->rlvls[rlvlno];
372         for (bandno = 0, band = rlvl->bands; bandno < rlvl->numbands;
373           ++bandno, ++band) {
374             if (!band->data) {
375                 continue;
376             }
377             prc = &band->prcs[prcno];
378             if (!prc->cblks) {
379                 continue;
380             }
381             for (cblkno = 0, cblk = prc->cblks; cblkno < prc->numcblks;
382               ++cblkno, ++cblk) {
383                 seg = cblk->curseg;
384                 while (seg) {
385                     if (!seg->stream) {
386                         if (!(seg->stream = jas_stream_memopen(0, 0))) {
387                             return -1;
388                         }
389                     }
390 #if 0
391 jas_eprintf("lyrno=%02d, compno=%02d, lvlno=%02d, prcno=%02d, bandno=%02d, cblkno=%02d, passno=%02d numpasses=%02d cnt=%d numbps=%d, numimsbs=%d\n", lyrno, compno, rlvlno, prcno, band - rlvl->bands, cblk - prc->cblks, seg->passno, seg->numpasses, seg->cnt, band->numbps, cblk->numimsbs);
392 #endif
393                     if (seg->cnt > 0) {
394                         if (jpc_getdata(in, seg->stream, seg->cnt) < 0) {
395                             return -1;
396                         }
397                         seg->cnt = 0;
398                     }
399                     if (seg->numpasses >= seg->maxpasses) {
400                         cblk->curseg = seg->next;
401                     }
402                     seg = seg->next;
403                 }
404             }
405         }
406     } else {
407         if (jas_stream_gobble(in, bodylen) != JAS_CAST(int, bodylen)) {
408             return -1;
409         }
410     }
411     return 0;
412 }
413 
414 /********************************************************************************************/
415 /********************************************************************************************/
416 
jpc_dec_decodepkts(jpc_dec_t * dec,jas_stream_t * pkthdrstream,jas_stream_t * in)417 int jpc_dec_decodepkts(jpc_dec_t *dec, jas_stream_t *pkthdrstream, jas_stream_t *in)
418 {
419     jpc_dec_tile_t *tile;
420     jpc_pi_t *pi;
421     int ret;
422 
423     tile = dec->curtile;
424     pi = tile->pi;
425     for (;;) {
426 if (!tile->pkthdrstream || jas_stream_peekc(tile->pkthdrstream) == EOF) {
427         switch (jpc_dec_lookahead(in)) {
428         case JPC_MS_EOC:
429         case JPC_MS_SOT:
430             return 0;
431             break;
432         case JPC_MS_SOP:
433         case JPC_MS_EPH:
434         case 0:
435             break;
436         default:
437             return -1;
438             break;
439         }
440 }
441         if ((ret = jpc_pi_next(pi))) {
442             return ret;
443         }
444 if (dec->maxpkts >= 0 && dec->numpkts >= dec->maxpkts) {
445     jas_eprintf("warning: stopping decode prematurely as requested\n");
446     return 0;
447 }
448         if (jas_getdbglevel() >= 1) {
449             jas_eprintf("packet offset=%08ld prg=%d cmptno=%02d "
450               "rlvlno=%02d prcno=%03d lyrno=%02d\n", (long)
451               jas_stream_getrwcount(in), jpc_pi_prg(pi), jpc_pi_cmptno(pi),
452               jpc_pi_rlvlno(pi), jpc_pi_prcno(pi), jpc_pi_lyrno(pi));
453         }
454         if (jpc_dec_decodepkt(dec, pkthdrstream, in, jpc_pi_cmptno(pi), jpc_pi_rlvlno(pi),
455           jpc_pi_prcno(pi), jpc_pi_lyrno(pi))) {
456             return -1;
457         }
458 ++dec->numpkts;
459     }
460 
461     return 0;
462 }
463 
jpc_dec_pi_create(jpc_dec_t * dec,jpc_dec_tile_t * tile)464 jpc_pi_t *jpc_dec_pi_create(jpc_dec_t *dec, jpc_dec_tile_t *tile)
465 {
466     jpc_pi_t *pi;
467     int compno;
468     jpc_picomp_t *picomp;
469     jpc_pirlvl_t *pirlvl;
470     jpc_dec_tcomp_t *tcomp;
471     int rlvlno;
472     jpc_dec_rlvl_t *rlvl;
473     int prcno;
474     int *prclyrno;
475     jpc_dec_cmpt_t *cmpt;
476 
477     if (!(pi = jpc_pi_create0())) {
478         return 0;
479     }
480     pi->numcomps = dec->numcomps;
481     if (!(pi->picomps = jas_alloc2(pi->numcomps, sizeof(jpc_picomp_t)))) {
482         jpc_pi_destroy(pi);
483         return 0;
484     }
485     for (compno = 0, picomp = pi->picomps; compno < pi->numcomps; ++compno,
486       ++picomp) {
487         picomp->pirlvls = 0;
488     }
489 
490     for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps;
491       compno < pi->numcomps; ++compno, ++tcomp, ++picomp) {
492         picomp->numrlvls = tcomp->numrlvls;
493         if (!(picomp->pirlvls = jas_alloc2(picomp->numrlvls,
494           sizeof(jpc_pirlvl_t)))) {
495             jpc_pi_destroy(pi);
496             return 0;
497         }
498         for (rlvlno = 0, pirlvl = picomp->pirlvls; rlvlno <
499           picomp->numrlvls; ++rlvlno, ++pirlvl) {
500             pirlvl->prclyrnos = 0;
501         }
502         for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
503           rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
504 /* XXX sizeof(long) should be sizeof different type */
505             pirlvl->numprcs = rlvl->numprcs;
506             if (!(pirlvl->prclyrnos = jas_alloc2(pirlvl->numprcs,
507               sizeof(long)))) {
508                 jpc_pi_destroy(pi);
509                 return 0;
510             }
511         }
512     }
513 
514     pi->maxrlvls = 0;
515     for (compno = 0, tcomp = tile->tcomps, picomp = pi->picomps, cmpt =
516       dec->cmpts; compno < pi->numcomps; ++compno, ++tcomp, ++picomp,
517       ++cmpt) {
518         picomp->hsamp = cmpt->hstep;
519         picomp->vsamp = cmpt->vstep;
520         for (rlvlno = 0, pirlvl = picomp->pirlvls, rlvl = tcomp->rlvls;
521           rlvlno < picomp->numrlvls; ++rlvlno, ++pirlvl, ++rlvl) {
522             pirlvl->prcwidthexpn = rlvl->prcwidthexpn;
523             pirlvl->prcheightexpn = rlvl->prcheightexpn;
524             for (prcno = 0, prclyrno = pirlvl->prclyrnos;
525               prcno < pirlvl->numprcs; ++prcno, ++prclyrno) {
526                 *prclyrno = 0;
527             }
528             pirlvl->numhprcs = rlvl->numhprcs;
529         }
530         if (pi->maxrlvls < tcomp->numrlvls) {
531             pi->maxrlvls = tcomp->numrlvls;
532         }
533     }
534 
535     pi->numlyrs = tile->cp->numlyrs;
536     pi->xstart = tile->xstart;
537     pi->ystart = tile->ystart;
538     pi->xend = tile->xend;
539     pi->yend = tile->yend;
540 
541     pi->picomp = 0;
542     pi->pirlvl = 0;
543     pi->x = 0;
544     pi->y = 0;
545     pi->compno = 0;
546     pi->rlvlno = 0;
547     pi->prcno = 0;
548     pi->lyrno = 0;
549     pi->xstep = 0;
550     pi->ystep = 0;
551 
552     pi->pchgno = -1;
553 
554     pi->defaultpchg.prgord = tile->cp->prgord;
555     pi->defaultpchg.compnostart = 0;
556     pi->defaultpchg.compnoend = pi->numcomps;
557     pi->defaultpchg.rlvlnostart = 0;
558     pi->defaultpchg.rlvlnoend = pi->maxrlvls;
559     pi->defaultpchg.lyrnoend = pi->numlyrs;
560     pi->pchg = 0;
561 
562     pi->valid = 0;
563 
564     return pi;
565 }
566 
jpc_dec_lookahead(jas_stream_t * in)567 long jpc_dec_lookahead(jas_stream_t *in)
568 {
569     uint_fast16_t x;
570     if (jpc_getuint16(in, &x)) {
571         return -1;
572     }
573     if (jas_stream_ungetc(in, x & 0xff) == EOF ||
574       jas_stream_ungetc(in, x >> 8) == EOF) {
575         return -1;
576     }
577     if (x >= JPC_MS_INMIN /*&& x <= JPC_MS_INMAX*/) {
578         return x;
579     }
580     return 0;
581 }
582