441 lines
14 KiB
C
441 lines
14 KiB
C
/*
|
|
* Copyright (c) 1999-2000, Image Power, Inc. and the University of
|
|
* British Columbia.
|
|
* Copyright (c) 2001-2003 Michael David Adams.
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/* __START_OF_JASPER_LICENSE__
|
|
*
|
|
* JasPer License Version 2.0
|
|
*
|
|
* Copyright (c) 2001-2006 Michael David Adams
|
|
* Copyright (c) 1999-2000 Image Power, Inc.
|
|
* Copyright (c) 1999-2000 The University of British Columbia
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person (the
|
|
* "User") obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without restriction,
|
|
* including without limitation the rights to use, copy, modify, merge,
|
|
* publish, distribute, and/or sell copies of the Software, and to permit
|
|
* persons to whom the Software is furnished to do so, subject to the
|
|
* following conditions:
|
|
*
|
|
* 1. The above copyright notices and this permission notice (which
|
|
* includes the disclaimer below) shall be included in all copies or
|
|
* substantial portions of the Software.
|
|
*
|
|
* 2. The name of a copyright holder shall not be used to endorse or
|
|
* promote products derived from the Software without specific prior
|
|
* written permission.
|
|
*
|
|
* THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
|
|
* LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER
|
|
* THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS
|
|
* "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
|
* BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
|
|
* INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
|
|
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
|
|
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
|
|
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE
|
|
* PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE
|
|
* THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY.
|
|
* EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS
|
|
* BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL
|
|
* PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS
|
|
* GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE
|
|
* ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE
|
|
* IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL
|
|
* SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES,
|
|
* AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL
|
|
* SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH
|
|
* THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH,
|
|
* PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH
|
|
* RISK ACTIVITIES"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY
|
|
* EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.
|
|
*
|
|
* __END_OF_JASPER_LICENSE__
|
|
*/
|
|
|
|
/*
|
|
* Bit Stream Class
|
|
*
|
|
* $Id: jpc_bs.c,v 1.2 2008-05-26 09:40:52 vp153 Exp $
|
|
*/
|
|
|
|
/******************************************************************************\
|
|
* Includes.
|
|
\******************************************************************************/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
|
|
#include "jasper/jas_malloc.h"
|
|
#include "jasper/jas_math.h"
|
|
#include "jasper/jas_debug.h"
|
|
|
|
#include "jpc_bs.h"
|
|
|
|
/******************************************************************************\
|
|
* Local function prototypes.
|
|
\******************************************************************************/
|
|
|
|
static jpc_bitstream_t *jpc_bitstream_alloc(void);
|
|
|
|
/******************************************************************************\
|
|
* Code for opening and closing bit streams.
|
|
\******************************************************************************/
|
|
|
|
/* Open a bit stream from a stream. */
|
|
jpc_bitstream_t *jpc_bitstream_sopen(jas_stream_t *stream, char *mode)
|
|
{
|
|
jpc_bitstream_t *bitstream;
|
|
|
|
/* Ensure that the open mode is valid. */
|
|
#if 1
|
|
/* This causes a string literal too long error (with c99 pedantic mode). */
|
|
assert(!strcmp(mode, "r") || !strcmp(mode, "w") || !strcmp(mode, "r+")
|
|
|| !strcmp(mode, "w+"));
|
|
#endif
|
|
|
|
if (!(bitstream = jpc_bitstream_alloc())) {
|
|
return 0;
|
|
}
|
|
|
|
/* By default, do not close the underlying (character) stream, upon
|
|
the close of the bit stream. */
|
|
bitstream->flags_ = JPC_BITSTREAM_NOCLOSE;
|
|
|
|
bitstream->stream_ = stream;
|
|
bitstream->openmode_ = (mode[0] == 'w') ? JPC_BITSTREAM_WRITE :
|
|
JPC_BITSTREAM_READ;
|
|
|
|
/* Mark the data buffer as empty. */
|
|
bitstream->cnt_ = (bitstream->openmode_ == JPC_BITSTREAM_READ) ? 0 : 8;
|
|
bitstream->buf_ = 0;
|
|
|
|
return bitstream;
|
|
}
|
|
|
|
/* Close a bit stream. */
|
|
int jpc_bitstream_close(jpc_bitstream_t *bitstream)
|
|
{
|
|
int ret = 0;
|
|
|
|
/* Align to the next byte boundary while considering the effects of
|
|
bit stuffing. */
|
|
if (jpc_bitstream_align(bitstream)) {
|
|
ret = -1;
|
|
}
|
|
|
|
/* If necessary, close the underlying (character) stream. */
|
|
if (!(bitstream->flags_ & JPC_BITSTREAM_NOCLOSE) && bitstream->stream_) {
|
|
if (jas_stream_close(bitstream->stream_)) {
|
|
ret = -1;
|
|
}
|
|
bitstream->stream_ = 0;
|
|
}
|
|
|
|
jas_free(bitstream);
|
|
return ret;
|
|
}
|
|
|
|
/* Allocate a new bit stream. */
|
|
static jpc_bitstream_t *jpc_bitstream_alloc()
|
|
{
|
|
jpc_bitstream_t *bitstream;
|
|
|
|
/* Allocate memory for the new bit stream object. */
|
|
if (!(bitstream = jas_malloc(sizeof(jpc_bitstream_t)))) {
|
|
return 0;
|
|
}
|
|
/* Initialize all of the data members. */
|
|
bitstream->stream_ = 0;
|
|
bitstream->cnt_ = 0;
|
|
bitstream->flags_ = 0;
|
|
bitstream->openmode_ = 0;
|
|
|
|
return bitstream;
|
|
}
|
|
|
|
/******************************************************************************\
|
|
* Code for reading/writing from/to bit streams.
|
|
\******************************************************************************/
|
|
|
|
/* Get a bit from a bit stream. */
|
|
int jpc_bitstream_getbit_func(jpc_bitstream_t *bitstream)
|
|
{
|
|
int ret;
|
|
JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func(%p)\n", bitstream));
|
|
ret = jpc_bitstream_getbit_macro(bitstream);
|
|
JAS_DBGLOG(1000, ("jpc_bitstream_getbit_func -> %d\n", ret));
|
|
return ret;
|
|
}
|
|
|
|
/* Put a bit to a bit stream. */
|
|
int jpc_bitstream_putbit_func(jpc_bitstream_t *bitstream, int b)
|
|
{
|
|
int ret;
|
|
JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func(%p, %d)\n", bitstream, b));
|
|
ret = jpc_bitstream_putbit_macro(bitstream, b);
|
|
JAS_DBGLOG(1000, ("jpc_bitstream_putbit_func() -> %d\n", ret));
|
|
return ret;
|
|
}
|
|
|
|
/* Get one or more bits from a bit stream. */
|
|
long jpc_bitstream_getbits(jpc_bitstream_t *bitstream, int n)
|
|
{
|
|
long v;
|
|
int u;
|
|
|
|
/* We can reliably get at most 31 bits since ISO/IEC 9899 only
|
|
guarantees that a long can represent values up to 2^31-1. */
|
|
assert(n >= 0 && n < 32);
|
|
|
|
/* Get the number of bits requested from the specified bit stream. */
|
|
v = 0;
|
|
while (--n >= 0) {
|
|
if ((u = jpc_bitstream_getbit(bitstream)) < 0) {
|
|
return -1;
|
|
}
|
|
v = (v << 1) | u;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/* Put one or more bits to a bit stream. */
|
|
int jpc_bitstream_putbits(jpc_bitstream_t *bitstream, int n, long v)
|
|
{
|
|
int m;
|
|
|
|
/* We can reliably put at most 31 bits since ISO/IEC 9899 only
|
|
guarantees that a long can represent values up to 2^31-1. */
|
|
assert(n >= 0 && n < 32);
|
|
/* Ensure that only the bits to be output are nonzero. */
|
|
assert(!(v & (~JAS_ONES(n))));
|
|
|
|
/* Put the desired number of bits to the specified bit stream. */
|
|
m = n - 1;
|
|
while (--n >= 0) {
|
|
if (jpc_bitstream_putbit(bitstream, (v >> m) & 1) == EOF) {
|
|
return EOF;
|
|
}
|
|
v <<= 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************\
|
|
* Code for buffer filling and flushing.
|
|
\******************************************************************************/
|
|
|
|
/* Fill the buffer for a bit stream. */
|
|
int jpc_bitstream_fillbuf(jpc_bitstream_t *bitstream)
|
|
{
|
|
int c;
|
|
/* Note: The count has already been decremented by the caller. */
|
|
assert(bitstream->openmode_ & JPC_BITSTREAM_READ);
|
|
assert(bitstream->cnt_ <= 0);
|
|
|
|
if (bitstream->flags_ & JPC_BITSTREAM_ERR) {
|
|
bitstream->cnt_ = 0;
|
|
return -1;
|
|
}
|
|
|
|
if (bitstream->flags_ & JPC_BITSTREAM_EOF) {
|
|
bitstream->buf_ = 0x7f;
|
|
bitstream->cnt_ = 7;
|
|
return 1;
|
|
}
|
|
|
|
bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
|
|
if ((c = jas_stream_getc((bitstream)->stream_)) == EOF) {
|
|
bitstream->flags_ |= JPC_BITSTREAM_EOF;
|
|
return 1;
|
|
}
|
|
bitstream->cnt_ = (bitstream->buf_ == 0xff00) ? 6 : 7;
|
|
bitstream->buf_ |= c & ((1 << (bitstream->cnt_ + 1)) - 1);
|
|
return (bitstream->buf_ >> bitstream->cnt_) & 1;
|
|
}
|
|
|
|
|
|
/******************************************************************************\
|
|
* Code related to flushing.
|
|
\******************************************************************************/
|
|
|
|
/* Does the bit stream need to be aligned to a byte boundary (considering
|
|
the effects of bit stuffing)? */
|
|
int jpc_bitstream_needalign(jpc_bitstream_t *bitstream)
|
|
{
|
|
if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
|
|
/* The bit stream is open for reading. */
|
|
/* If there are any bits buffered for reading, or the
|
|
previous byte forced a stuffed bit, alignment is
|
|
required. */
|
|
if ((bitstream->cnt_ < 8 && bitstream->cnt_ > 0) ||
|
|
((bitstream->buf_ >> 8) & 0xff) == 0xff) {
|
|
return 1;
|
|
}
|
|
} else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
|
|
/* The bit stream is open for writing. */
|
|
/* If there are any bits buffered for writing, or the
|
|
previous byte forced a stuffed bit, alignment is
|
|
required. */
|
|
if ((bitstream->cnt_ < 8 && bitstream->cnt_ >= 0) ||
|
|
((bitstream->buf_ >> 8) & 0xff) == 0xff) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
/* This should not happen. Famous last words, eh? :-) */
|
|
assert(0);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* How many additional bytes would be output if we align the bit stream? */
|
|
int jpc_bitstream_pending(jpc_bitstream_t *bitstream)
|
|
{
|
|
if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
|
|
/* The bit stream is being used for writing. */
|
|
#if 1
|
|
/* XXX - Is this really correct? Check someday... */
|
|
if (bitstream->cnt_ < 8) {
|
|
return 1;
|
|
}
|
|
#else
|
|
if (bitstream->cnt_ < 8) {
|
|
if (((bitstream->buf_ >> 8) & 0xff) == 0xff) {
|
|
return 2;
|
|
}
|
|
return 1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
} else {
|
|
/* This operation should not be invoked on a bit stream that
|
|
is being used for reading. */
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/* Align the bit stream to a byte boundary. */
|
|
int jpc_bitstream_align(jpc_bitstream_t *bitstream)
|
|
{
|
|
int ret;
|
|
if (bitstream->openmode_ & JPC_BITSTREAM_READ) {
|
|
ret = jpc_bitstream_inalign(bitstream, 0, 0);
|
|
} else if (bitstream->openmode_ & JPC_BITSTREAM_WRITE) {
|
|
ret = jpc_bitstream_outalign(bitstream, 0);
|
|
} else {
|
|
abort();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Align a bit stream in the input case. */
|
|
int jpc_bitstream_inalign(jpc_bitstream_t *bitstream, int fillmask,
|
|
int filldata)
|
|
{
|
|
int n;
|
|
int v;
|
|
int u;
|
|
int numfill;
|
|
int m;
|
|
|
|
numfill = 7;
|
|
m = 0;
|
|
v = 0;
|
|
if (bitstream->cnt_ > 0) {
|
|
n = bitstream->cnt_;
|
|
} else if (!bitstream->cnt_) {
|
|
n = ((bitstream->buf_ & 0xff) == 0xff) ? 7 : 0;
|
|
} else {
|
|
n = 0;
|
|
}
|
|
if (n > 0) {
|
|
if ((u = jpc_bitstream_getbits(bitstream, n)) < 0) {
|
|
return -1;
|
|
}
|
|
m += n;
|
|
v = (v << n) | u;
|
|
}
|
|
if ((bitstream->buf_ & 0xff) == 0xff) {
|
|
if ((u = jpc_bitstream_getbits(bitstream, 7)) < 0) {
|
|
return -1;
|
|
}
|
|
v = (v << 7) | u;
|
|
m += 7;
|
|
}
|
|
if (m > numfill) {
|
|
v >>= m - numfill;
|
|
} else {
|
|
filldata >>= numfill - m;
|
|
fillmask >>= numfill - m;
|
|
}
|
|
if (((~(v ^ filldata)) & fillmask) != fillmask) {
|
|
/* The actual fill pattern does not match the expected one. */
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Align a bit stream in the output case. */
|
|
int jpc_bitstream_outalign(jpc_bitstream_t *bitstream, int filldata)
|
|
{
|
|
int n;
|
|
int v;
|
|
|
|
/* Ensure that this bit stream is open for writing. */
|
|
assert(bitstream->openmode_ & JPC_BITSTREAM_WRITE);
|
|
|
|
/* Ensure that the first bit of fill data is zero. */
|
|
/* Note: The first bit of fill data must be zero. If this were not
|
|
the case, the fill data itself could cause further bit stuffing to
|
|
be required (which would cause numerous complications). */
|
|
assert(!(filldata & (~0x3f)));
|
|
|
|
if (!bitstream->cnt_) {
|
|
if ((bitstream->buf_ & 0xff) == 0xff) {
|
|
n = 7;
|
|
v = filldata;
|
|
} else {
|
|
n = 0;
|
|
v = 0;
|
|
}
|
|
} else if (bitstream->cnt_ > 0 && bitstream->cnt_ < 8) {
|
|
n = bitstream->cnt_;
|
|
v = filldata >> (7 - n);
|
|
} else {
|
|
n = 0;
|
|
v = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* Write the appropriate fill data to the bit stream. */
|
|
if (n > 0) {
|
|
if (jpc_bitstream_putbits(bitstream, n, v)) {
|
|
return -1;
|
|
}
|
|
}
|
|
if (bitstream->cnt_ < 8) {
|
|
assert(bitstream->cnt_ >= 0 && bitstream->cnt_ < 8);
|
|
assert((bitstream->buf_ & 0xff) != 0xff);
|
|
/* Force the pending byte of output to be written to the
|
|
underlying (character) stream. */
|
|
if (jas_stream_putc(bitstream->stream_, bitstream->buf_ & 0xff) == EOF) {
|
|
return -1;
|
|
}
|
|
bitstream->cnt_ = 8;
|
|
bitstream->buf_ = (bitstream->buf_ << 8) & 0xffff;
|
|
}
|
|
|
|
return 0;
|
|
}
|