mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
440 lines
13 KiB
440 lines
13 KiB
/* |
|
* 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; |
|
}
|
|
|