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  * Bit Stream Class
66  *
67  * $Id: jpc_bs.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
68  */
69 
70 /******************************************************************************\
71 * Includes.
72 \******************************************************************************/
73 
74 #include <assert.h>
75 #include <stdlib.h>
76 #include <stdarg.h>
77 
78 #include "jasper/jas_malloc.h"
79 #include "jasper/jas_math.h"
80 #include "jasper/jas_debug.h"
81 
82 #include "jpc_bs.h"
83 
84 /******************************************************************************\
85 * Local function prototypes.
86 \******************************************************************************/
87 
88 static jpc_bitstream_t *jpc_bitstream_alloc(void);
89 
90 /******************************************************************************\
91 * Code for opening and closing bit streams.
92 \******************************************************************************/
93 
94 /* Open a bit stream from a stream. */
jpc_bitstream_sopen(jas_stream_t * stream,char * mode)95 jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, char *mode)
96 {
97     jpc_bitstream_t *bitstream;
98 
99     /* Ensure that the open mode is valid. */
100 #if 1
101 /* This causes a string literal too long error (with c99 pedantic mode). */
102     assert(!strcmp(mode, "r") || !strcmp(mode, "w") || !strcmp(mode, "r+")
103       || !strcmp(mode, "w+"));
104 #endif
105 
106     if (!(bitstream = jpc_bitstream_alloc())) {
107         return 0;
108     }
109 
110     /* By default, do not close the underlying (character) stream, upon
111       the close of the bit stream. */
112     bitstream->flags_ = JPC_BITSTREAM_NOCLOSE;
113 
114     bitstream->stream_ = stream;
115     bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE :
116       JPC_BITSTREAM_READ;
117 
118     /* Mark the data buffer as empty. */
119     bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8;
120     bitstream->buf_ = 0;
121 
122     return bitstream;
123 }
124 
125 /* Close a bit stream. */
jpc_bitstream_close(jpc_bitstream_t * bitstream)126 int jpc_bitstream_close(jpc_bitstream_t *bitstream)
127 {
128     int ret = 0;
129 
130     /* Align to the next byte boundary while considering the effects of
131       bit stuffing. */
132     if (jpc_bitstream_align(bitstream)) {
133         ret = -1;
134     }
135 
136     /* If necessary, close the underlying (character) stream. */
137     if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) {
138         if (jas_stream_close(bitstream->stream_)) {
139             ret = -1;
140         }
141         bitstream->stream_ = 0;
142     }
143 
144     jas_free(bitstream);
145     return ret;
146 }
147 
148 /* Allocate a new bit stream. */
jpc_bitstream_alloc()149 static jpc_bitstream_t *jpc_bitstream_alloc()
150 {
151     jpc_bitstream_t *bitstream;
152 
153     /* Allocate memory for the new bit stream object. */
154     if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) {
155         return 0;
156     }
157     /* Initialize all of the data members. */
158     bitstream->stream_ = 0;
159     bitstream->cnt_ = 0;
160     bitstream->flags_ = 0;
161     bitstream->openmode_ = 0;
162 
163     return bitstream;
164 }
165 
166 /******************************************************************************\
167 * Code for reading/writing from/to bit streams.
168 \******************************************************************************/
169 
170 /* Get a bit from a bit stream. */
jpc_bitstream_getbit_func(jpc_bitstream_t * bitstream)171 int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream)
172 {
173     int ret;
174     JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream));
175     ret = jpc_bitstream_getbit_macro(bitstream);
176     JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret));
177     return ret;
178 }
179 
180 /* Put a bit to a bit stream. */
jpc_bitstream_putbit_func(jpc_bitstream_t * bitstream,int b)181 int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int b)
182 {
183     int ret;
184     JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b));
185     ret = jpc_bitstream_putbit_macro(bitstream, b);
186     JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret));
187     return ret;
188 }
189 
190 /* Get one or more bits from a bit stream. */
jpc_bitstream_getbits(jpc_bitstream_t * bitstream,int n)191 long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n)
192 {
193     long v;
194     int u;
195 
196     /* We can reliably get at most 31 bits since ISO/IEC 9899 only
197       guarantees that a long can represent values up to 2^31-1. */
198     assert(n >= 0 && n < 32);
199 
200     /* Get the number of bits requested from the specified bit stream. */
201     v = 0;
202     while (--n >= 0) {
203         if ((u = jpc_bitstream_getbit(bitstream)) < 0) {
204             return -1;
205         }
206         v = (v << 1) | u;
207     }
208     return v;
209 }
210 
211 /* Put one or more bits to a bit stream. */
jpc_bitstream_putbits(jpc_bitstream_t * bitstream,int n,long v)212 int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v)
213 {
214     int m;
215 
216     /* We can reliably put at most 31 bits since ISO/IEC 9899 only
217       guarantees that a long can represent values up to 2^31-1. */
218     assert(n >= 0 && n < 32);
219     /* Ensure that only the bits to be output are nonzero. */
220     assert(!(v & (~JAS_ONES(n))));
221 
222     /* Put the desired number of bits to the specified bit stream. */
223     m = n - 1;
224     while (--n >= 0) {
225         if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) {
226             return EOF;
227         }
228         v <<= 1;
229     }
230     return 0;
231 }
232 
233 /******************************************************************************\
234 * Code for buffer filling and flushing.
235 \******************************************************************************/
236 
237 /* Fill the buffer for a bit stream. */
jpc_bitstream_fillbuf(jpc_bitstream_t * bitstream)238 int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream)
239 {
240     int c;
241     /* Note: The count has already been decremented by the caller. */
242     assert(bitstream->openmode_ & JPC_BITSTREAM_READ);
243     assert(bitstream->cnt_ <= 0);
244 
245     if (bitstream->flags_ & JPC_BITSTREAM_ERR) {
246         bitstream->cnt_ = 0;
247         return -1;
248     }
249 
250     if (bitstream->flags_ & JPC_BITSTREAM_EOF) {
251         bitstream->buf_ = 0x7f;
252         bitstream->cnt_ = 7;
253         return 1;
254     }
255 
256     bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
257     if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) {
258         bitstream->flags_ |= JPC_BITSTREAM_EOF;
259         return 1;
260     }
261     bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7;
262     bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1);
263     return (bitstream->buf_ >> bitstream->cnt_) & 1;
264 }
265 
266 
267 /******************************************************************************\
268 * Code related to flushing.
269 \******************************************************************************/
270 
271 /* Does the bit stream need to be aligned to a byte boundary (considering
272   the effects of bit stuffing)? */
jpc_bitstream_needalign(jpc_bitstream_t * bitstream)273 int jpc_bitstream_needalign(jpc_bitstream_t *bitstream)
274 {
275     if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
276         /* The bit stream is open for reading. */
277         /* If there are any bits buffered for reading, or the
278           previous byte forced a stuffed bit, alignment is
279           required. */
280         if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) ||
281           ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
282             return 1;
283         }
284     } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
285         /* The bit stream is open for writing. */
286         /* If there are any bits buffered for writing, or the
287           previous byte forced a stuffed bit, alignment is
288           required. */
289         if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) ||
290           ((bitstream->buf_ >> 8) & 0xff) == 0xff) {
291             return 1;
292         }
293     } else {
294         /* This should not happen.  Famous last words, eh? :-) */
295         assert(0);
296         return -1;
297     }
298     return 0;
299 }
300 
301 /* How many additional bytes would be output if we align the bit stream? */
jpc_bitstream_pending(jpc_bitstream_t * bitstream)302 int jpc_bitstream_pending(jpc_bitstream_t *bitstream)
303 {
304     if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
305         /* The bit stream is being used for writing. */
306 #if 1
307         /* XXX - Is this really correct?  Check someday... */
308         if (bitstream->cnt_ < 8) {
309             return 1;
310         }
311 #else
312         if (bitstream->cnt_ < 8) {
313             if (((bitstream->buf_ >> 8) & 0xff) == 0xff) {
314                 return 2;
315             }
316             return 1;
317         }
318 #endif
319         return 0;
320     } else {
321         /* This operation should not be invoked on a bit stream that
322           is being used for reading. */
323         return -1;
324     }
325 }
326 
327 /* Align the bit stream to a byte boundary. */
jpc_bitstream_align(jpc_bitstream_t * bitstream)328 int jpc_bitstream_align(jpc_bitstream_t *bitstream)
329 {
330     int ret;
331     if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
332         ret = jpc_bitstream_inalign(bitstream, 0, 0);
333     } else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
334         ret = jpc_bitstream_outalign(bitstream, 0);
335     } else {
336         abort();
337     }
338     return ret;
339 }
340 
341 /* Align a bit stream in the input case. */
jpc_bitstream_inalign(jpc_bitstream_t * bitstream,int fillmask,int filldata)342 int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask,
343   int filldata)
344 {
345     int n;
346     int v;
347     int u;
348     int numfill;
349     int m;
350 
351     numfill = 7;
352     m = 0;
353     v = 0;
354     if (bitstream->cnt_ > 0) {
355         n = bitstream->cnt_;
356     } else if (!bitstream->cnt_) {
357         n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0;
358     } else {
359         n = 0;
360     }
361     if (n > 0) {
362         if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) {
363             return -1;
364         }
365         m += n;
366         v = (v << n) | u;
367     }
368     if ((bitstream->buf_ & 0xff) == 0xff) {
369         if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) {
370             return -1;
371         }
372         v = (v << 7) | u;
373         m += 7;
374     }
375     if (m > numfill) {
376         v >>= m - numfill;
377     } else {
378         filldata >>= numfill - m;
379         fillmask >>= numfill - m;
380     }
381     if (((~(v ^ filldata)) & fillmask) != fillmask) {
382         /* The actual fill pattern does not match the expected one. */
383         return 1;
384     }
385 
386     return 0;
387 }
388 
389 /* Align a bit stream in the output case. */
jpc_bitstream_outalign(jpc_bitstream_t * bitstream,int filldata)390 int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata)
391 {
392     int n;
393     int v;
394 
395     /* Ensure that this bit stream is open for writing. */
396     assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE);
397 
398     /* Ensure that the first bit of fill data is zero. */
399     /* Note: The first bit of fill data must be zero.  If this were not
400       the case, the fill data itself could cause further bit stuffing to
401       be required (which would cause numerous complications). */
402     assert(!(filldata & (~0x3f)));
403 
404     if (!bitstream->cnt_) {
405         if ((bitstream->buf_ & 0xff) == 0xff) {
406             n = 7;
407             v = filldata;
408         } else {
409             n = 0;
410             v = 0;
411         }
412     } else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) {
413         n = bitstream->cnt_;
414         v = filldata >> (7 - n);
415     } else {
416         n = 0;
417         v = 0;
418         return 0;
419     }
420 
421     /* Write the appropriate fill data to the bit stream. */
422     if (n > 0) {
423         if (jpc_bitstream_putbits(bitstream, n, v)) {
424             return -1;
425         }
426     }
427     if (bitstream->cnt_ < 8) {
428         assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8);
429         assert((bitstream->buf_ & 0xff) != 0xff);
430         /* Force the pending byte of output to be written to the
431           underlying (character) stream. */
432         if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) {
433             return -1;
434         }
435         bitstream->cnt_ = 8;
436         bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
437     }
438 
439     return 0;
440 }
441