git.maemo.org Git - opencv/blob - 3rdparty/libjasper/jpc_bs.c

   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. */
  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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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. */
 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)? */
 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? */
 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. */
 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. */
 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. */
 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 }