/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "_highgui.h"
#include "bitstrm.h"
#define BS_DEF_BLOCK_SIZE (1<<15)
const ulong bs_bit_mask[] = {
0,
0x00000001, 0x00000003, 0x00000007, 0x0000000F,
0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
0x0001FFFF, 0x0003FFFF, 0x0007FFFF, 0x000FFFFF,
0x001FFFFF, 0x003FFFFF, 0x007FFFFF, 0x00FFFFFF,
0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF, 0x0FFFFFFF,
0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF
};
void bsBSwapBlock( uchar *start, uchar *end )
{
ulong* data = (ulong*)start;
int i, size = (int)(end - start+3)/4;
for( i = 0; i < size; i++ )
{
ulong temp = data[i];
temp = BSWAP( temp );
data[i] = temp;
}
}
bool bsIsBigEndian( void )
{
return (((const int*)"\0\x1\x2\x3\x4\x5\x6\x7")[0] & 255) != 0;
}
///////////////////////// RBaseStream ////////////////////////////
bool RBaseStream::IsOpened()
{
return m_is_opened;
}
void RBaseStream::Allocate()
{
if( !m_start )
{
m_start = new uchar[m_block_size + m_unGetsize];
m_start+= m_unGetsize;
}
m_end = m_start + m_block_size;
m_current = m_end;
}
RBaseStream::RBaseStream()
{
m_start = m_end = m_current = 0;
m_file = 0;
m_block_size = BS_DEF_BLOCK_SIZE;
m_unGetsize = 4; // 32 bits
m_is_opened = false;
m_jmp_set = false;
}
RBaseStream::~RBaseStream()
{
Close(); // Close files
Release(); // free buffers
}
void RBaseStream::ReadBlock()
{
size_t readed;
assert( m_file != 0 );
// copy unget buffer
if( m_start )
{
memcpy( m_start - m_unGetsize, m_end - m_unGetsize, m_unGetsize );
}
SetPos( GetPos() ); // normalize position
fseek( m_file, m_block_pos, SEEK_SET );
readed = fread( m_start, 1, m_block_size, m_file );
m_end = m_start + readed;
m_current -= m_block_size;
m_block_pos += m_block_size;
if( readed == 0 || m_current >= m_end )
{
if( m_jmp_set )
longjmp( m_jmp_buf, RBS_THROW_EOS );
}
}
bool RBaseStream::Open( const char* filename )
{
Close();
Allocate();
m_file = fopen( filename, "rb" );
if( m_file )
{
m_is_opened = true;
SetPos(0);
}
return m_file != 0;
}
void RBaseStream::Close()
{
if( m_file )
{
fclose( m_file );
m_file = 0;
}
m_is_opened = false;
}
void RBaseStream::Release()
{
if( m_start )
{
delete[] (m_start - m_unGetsize);
}
m_start = m_end = m_current = 0;
}
void RBaseStream::SetBlockSize( int block_size, int unGetsize )
{
assert( unGetsize >= 0 && block_size > 0 &&
(block_size & (block_size-1)) == 0 );
if( m_start && block_size == m_block_size && unGetsize == m_unGetsize ) return;
Release();
m_block_size = block_size;
m_unGetsize = unGetsize;
Allocate();
}
void RBaseStream::SetPos( int pos )
{
int offset = pos & (m_block_size - 1);
int block_pos = pos - offset;
assert( IsOpened() && pos >= 0 );
if( m_current < m_end && block_pos == m_block_pos - m_block_size )
{
m_current = m_start + offset;
}
else
{
m_block_pos = block_pos;
m_current = m_start + m_block_size + offset;
}
}
int RBaseStream::GetPos()
{
assert( IsOpened() );
return m_block_pos - m_block_size + (int)(m_current - m_start);
}
void RBaseStream::Skip( int bytes )
{
assert( bytes >= 0 );
m_current += bytes;
}
jmp_buf& RBaseStream::JmpBuf()
{
m_jmp_set = true;
return m_jmp_buf;
}
///////////////////////// RLByteStream ////////////////////////////
RLByteStream::~RLByteStream()
{
}
int RLByteStream::GetByte()
{
uchar *current = m_current;
int val;
if( current >= m_end )
{
ReadBlock();
current = m_current;
}
val = *((uchar*)current);
m_current = current + 1;
return val;
}
void RLByteStream::GetBytes( void* buffer, int count, int* readed )
{
uchar* data = (uchar*)buffer;
assert( count >= 0 );
if( readed) *readed = 0;
while( count > 0 )
{
int l;
for(;;)
{
l = (int)(m_end - m_current);
if( l > count ) l = count;
if( l > 0 ) break;
ReadBlock();
}
memcpy( data, m_current, l );
m_current += l;
data += l;
count -= l;
if( readed ) *readed += l;
}
}
//////////// RLByteStream & RMByteStream <Get[d]word>s ////////////////
RMByteStream::~RMByteStream()
{
}
int RLByteStream::GetWord()
{
uchar *current = m_current;
int val;
if( current+1 < m_end )
{
val = current[0] + (current[1] << 8);
m_current = current + 2;
}
else
{
val = GetByte();
val|= GetByte() << 8;
}
return val;
}
int RLByteStream::GetDWord()
{
uchar *current = m_current;
int val;
if( current+3 < m_end )
{
val = current[0] + (current[1] << 8) +
(current[2] << 16) + (current[3] << 24);
m_current = current + 4;
}
else
{
val = GetByte();
val |= GetByte() << 8;
val |= GetByte() << 16;
val |= GetByte() << 24;
}
return val;
}
int RMByteStream::GetWord()
{
uchar *current = m_current;
int val;
if( current+1 < m_end )
{
val = (current[0] << 8) + current[1];
m_current = current + 2;
}
else
{
val = GetByte() << 8;
val|= GetByte();
}
return val;
}
int RMByteStream::GetDWord()
{
uchar *current = m_current;
int val;
if( current+3 < m_end )
{
val = (current[0] << 24) + (current[1] << 16) +
(current[2] << 8) + current[3];
m_current = current + 4;
}
else
{
val = GetByte() << 24;
val |= GetByte() << 16;
val |= GetByte() << 8;
val |= GetByte();
}
return val;
}
///////////////////////// RLBitStream ////////////////////////////
RLBitStream::~RLBitStream()
{
}
void RLBitStream::ReadBlock()
{
RBaseStream::ReadBlock();
if( bsIsBigEndian() )
bsBSwapBlock( m_start, m_end );
}
void RLBitStream::SetPos( int pos )
{
RBaseStream::SetPos(pos);
int offset = (int)(m_current - m_end);
m_current = m_end + (offset & -4);
m_bit_idx = (offset&3)*8;
}
int RLBitStream::GetPos()
{
return RBaseStream::GetPos() + (m_bit_idx >> 3);
}
int RLBitStream::Get( int bits )
{
int bit_idx = m_bit_idx;
int new_bit_idx = bit_idx + bits;
int mask = new_bit_idx >= 32 ? -1 : 0;
ulong* current = (ulong*)m_current;
assert( (unsigned)bits < 32 );
if( (m_current = (uchar*)(current - mask)) >= m_end )
{
ReadBlock();
current = ((ulong*)m_current) + mask;
}
m_bit_idx = new_bit_idx & 31;
return ((current[0] >> bit_idx) |
((current[1] <<-bit_idx) & mask)) & bs_bit_mask[bits];
}
int RLBitStream::Show( int bits )
{
int bit_idx = m_bit_idx;
int new_bit_idx = bit_idx + bits;
int mask = new_bit_idx >= 32 ? -1 : 0;
ulong* current = (ulong*)m_current;
assert( (unsigned)bits < 32 );
if( (uchar*)(current - mask) >= m_end )
{
ReadBlock();
current = ((ulong*)m_current) + mask;
m_current = (uchar*)current;
}
return ((current[0] >> bit_idx) |
((current[1] <<-bit_idx) & mask)) & bs_bit_mask[bits];
}
void RLBitStream::Move( int shift )
{
int new_bit_idx = m_bit_idx + shift;
m_current += (new_bit_idx >> 5) << 2;
m_bit_idx = new_bit_idx & 31;
}
int RLBitStream::GetHuff( const short* table )
{
int val;
int code_bits;
for(;;)
{
int table_bits = table[0];
val = table[Show(table_bits) + 2];
code_bits = val & 15;
val >>= 4;
if( code_bits != 0 ) break;
table += val*2;
Move( table_bits );
}
Move( code_bits );
if( val == RBS_HUFF_FORB )
{
if( m_jmp_set )
longjmp( m_jmp_buf, RBS_THROW_FORB );
}
return val;
}
void RLBitStream::Skip( int bytes )
{
Move( bytes*8 );
}
///////////////////////// RMBitStream ////////////////////////////
RMBitStream::~RMBitStream()
{
}
void RMBitStream::ReadBlock()
{
RBaseStream::ReadBlock();
if( !bsIsBigEndian() )
bsBSwapBlock( m_start, m_end );
}
void RMBitStream::SetPos( int pos )
{
RBaseStream::SetPos(pos);
int offset = (int)(m_current - m_end);
m_current = m_end + ((offset - 1) & -4);
m_bit_idx = (32 - (offset&3)*8) & 31;
}
int RMBitStream::GetPos()
{
return RBaseStream::GetPos() + ((32 - m_bit_idx) >> 3);
}
int RMBitStream::Get( int bits )
{
int bit_idx = m_bit_idx - bits;
int mask = bit_idx >> 31;
ulong* current = ((ulong*)m_current) - mask;
assert( (unsigned)bits < 32 );
if( (m_current = (uchar*)current) >= m_end )
{
ReadBlock();
current = (ulong*)m_current;
}
m_bit_idx = bit_idx &= 31;
return (((current[-1] << -bit_idx) & mask)|
(current[0] >> bit_idx)) & bs_bit_mask[bits];
}
int RMBitStream::Show( int bits )
{
int bit_idx = m_bit_idx - bits;
int mask = bit_idx >> 31;
ulong* current = ((ulong*)m_current) - mask;
assert( (unsigned)bits < 32 );
if( ((uchar*)current) >= m_end )
{
m_current = (uchar*)current;
ReadBlock();
current = (ulong*)m_current;
m_current -= 4;
}
return (((current[-1]<<-bit_idx) & mask)|
(current[0] >> bit_idx)) & bs_bit_mask[bits];
}
int RMBitStream::GetHuff( const short* table )
{
int val;
int code_bits;
for(;;)
{
int table_bits = table[0];
val = table[Show(table_bits) + 1];
code_bits = val & 15;
val >>= 4;
if( code_bits != 0 ) break;
table += val;
Move( table_bits );
}
Move( code_bits );
if( val == RBS_HUFF_FORB )
{
if( m_jmp_set )
longjmp( m_jmp_buf, RBS_THROW_FORB );
}
return val;
}
void RMBitStream::Move( int shift )
{
int new_bit_idx = m_bit_idx - shift;
m_current -= (new_bit_idx >> 5)<<2;
m_bit_idx = new_bit_idx & 31;
}
void RMBitStream::Skip( int bytes )
{
Move( bytes*8 );
}
static const int huff_val_shift = 20, huff_code_mask = (1 << huff_val_shift) - 1;
bool bsCreateDecodeHuffmanTable( const int* src, short* table, int max_size )
{
const int forbidden_entry = (RBS_HUFF_FORB << 4)|1;
int first_bits = src[0];
struct
{
int bits;
int offset;
}
sub_tables[1 << 11];
int size = (1 << first_bits) + 1;
int i, k;
/* calc bit depths of sub tables */
memset( sub_tables, 0, ((size_t)1 << first_bits)*sizeof(sub_tables[0]) );
for( i = 1, k = 1; src[k] >= 0; i++ )
{
int code_count = src[k++];
int sb = i - first_bits;
if( sb <= 0 )
k += code_count;
else
for( code_count += k; k < code_count; k++ )
{
int code = src[k] & huff_code_mask;
sub_tables[code >> sb].bits = sb;
}
}
/* calc offsets of sub tables and whole size of table */
for( i = 0; i < (1 << first_bits); i++ )
{
int b = sub_tables[i].bits;
if( b > 0 )
{
b = 1 << b;
sub_tables[i].offset = size;
size += b + 1;
}
}
if( size > max_size )
{
assert(0);
return false;
}
/* fill first table and subtables with forbidden values */
for( i = 0; i < size; i++ )
{
table[i] = (short)forbidden_entry;
}
/* write header of first table */
table[0] = (short)first_bits;
/* fill first table and sub tables */
for( i = 1, k = 1; src[k] >= 0; i++ )
{
int code_count = src[k++];
for( code_count += k; k < code_count; k++ )
{
int table_bits= first_bits;
int code_bits = i;
int code = src[k] & huff_code_mask;
int val = src[k] >>huff_val_shift;
int j, offset = 0;
if( code_bits > table_bits )
{
int idx = code >> (code_bits -= table_bits);
code &= (1 << code_bits) - 1;
offset = sub_tables[idx].offset;
table_bits= sub_tables[idx].bits;
/* write header of subtable */
table[offset] = (short)table_bits;
/* write jump to subtable */
table[idx + 1]= (short)(offset << 4);
}
table_bits -= code_bits;
assert( table_bits >= 0 );
val = (val << 4) | code_bits;
offset += (code << table_bits) + 1;
for( j = 0; j < (1 << table_bits); j++ )
{
assert( table[offset + j] == forbidden_entry );
table[ offset + j ] = (short)val;
}
}
}
return true;
}
int* bsCreateSourceHuffmanTable( const uchar* src, int* dst,
int max_bits, int first_bits )
{
int i, val_idx, code = 0;
int* table = dst;
*dst++ = first_bits;
for( i = 1, val_idx = max_bits; i <= max_bits; i++ )
{
int code_count = src[i - 1];
dst[0] = code_count;
code <<= 1;
for( int k = 0; k < code_count; k++ )
{
dst[k + 1] = (src[val_idx + k] << huff_val_shift)|(code + k);
}
code += code_count;
dst += code_count + 1;
val_idx += code_count;
}
dst[0] = -1;
return table;
}
/////////////////////////// WBaseStream /////////////////////////////////
// WBaseStream - base class for output streams
WBaseStream::WBaseStream()
{
m_start = m_end = m_current = 0;
m_file = 0;
m_block_size = BS_DEF_BLOCK_SIZE;
m_is_opened = false;
}
WBaseStream::~WBaseStream()
{
Close(); // Close files
Release(); // free buffers
}
bool WBaseStream::IsOpened()
{
return m_is_opened;
}
void WBaseStream::Allocate()
{
if( !m_start )
m_start = new uchar[m_block_size];
m_end = m_start + m_block_size;
m_current = m_start;
}
void WBaseStream::WriteBlock()
{
int size = (int)(m_current - m_start);
assert( m_file != 0 );
//fseek( m_file, m_block_pos, SEEK_SET );
fwrite( m_start, 1, size, m_file );
m_current = m_start;
/*if( written < size ) throw RBS_THROW_EOS;*/
m_block_pos += size;
}
bool WBaseStream::Open( const char* filename )
{
Close();
Allocate();
m_file = fopen( filename, "wb" );
if( m_file )
{
m_is_opened = true;
m_block_pos = 0;
m_current = m_start;
}
return m_file != 0;
}
void WBaseStream::Close()
{
if( m_file )
{
WriteBlock();
fclose( m_file );
m_file = 0;
}
m_is_opened = false;
}
void WBaseStream::Release()
{
if( m_start )
{
delete[] m_start;
}
m_start = m_end = m_current = 0;
}
void WBaseStream::SetBlockSize( int block_size )
{
assert( block_size > 0 && (block_size & (block_size-1)) == 0 );
if( m_start && block_size == m_block_size ) return;
Release();
m_block_size = block_size;
Allocate();
}
int WBaseStream::GetPos()
{
assert( IsOpened() );
return m_block_pos + (int)(m_current - m_start);
}
///////////////////////////// WLByteStream ///////////////////////////////////
WLByteStream::~WLByteStream()
{
}
void WLByteStream::PutByte( int val )
{
*m_current++ = (uchar)val;
if( m_current >= m_end )
WriteBlock();
}
void WLByteStream::PutBytes( const void* buffer, int count )
{
uchar* data = (uchar*)buffer;
assert( data && m_current && count >= 0 );
while( count )
{
int l = (int)(m_end - m_current);
if( l > count )
l = count;
if( l > 0 )
{
memcpy( m_current, data, l );
m_current += l;
data += l;
count -= l;
}
if( m_current == m_end )
WriteBlock();
}
}
void WLByteStream::PutWord( int val )
{
uchar *current = m_current;
if( current+1 < m_end )
{
current[0] = (uchar)val;
current[1] = (uchar)(val >> 8);
m_current = current + 2;
if( m_current == m_end )
WriteBlock();
}
else
{
PutByte(val);
PutByte(val >> 8);
}
}
void WLByteStream::PutDWord( int val )
{
uchar *current = m_current;
if( current+3 < m_end )
{
current[0] = (uchar)val;
current[1] = (uchar)(val >> 8);
current[2] = (uchar)(val >> 16);
current[3] = (uchar)(val >> 24);
m_current = current + 4;
if( m_current == m_end )
WriteBlock();
}
else
{
PutByte(val);
PutByte(val >> 8);
PutByte(val >> 16);
PutByte(val >> 24);
}
}
///////////////////////////// WMByteStream ///////////////////////////////////
WMByteStream::~WMByteStream()
{
}
void WMByteStream::PutWord( int val )
{
uchar *current = m_current;
if( current+1 < m_end )
{
current[0] = (uchar)(val >> 8);
current[1] = (uchar)val;
m_current = current + 2;
if( m_current == m_end )
WriteBlock();
}
else
{
PutByte(val >> 8);
PutByte(val);
}
}
void WMByteStream::PutDWord( int val )
{
uchar *current = m_current;
if( current+3 < m_end )
{
current[0] = (uchar)(val >> 24);
current[1] = (uchar)(val >> 16);
current[2] = (uchar)(val >> 8);
current[3] = (uchar)val;
m_current = current + 4;
if( m_current == m_end )
WriteBlock();
}
else
{
PutByte(val >> 24);
PutByte(val >> 16);
PutByte(val >> 8);
PutByte(val);
}
}
///////////////////////////// WMBitStream ///////////////////////////////////
WMBitStream::WMBitStream()
{
m_pad_val = 0;
ResetBuffer();
}
WMBitStream::~WMBitStream()
{
}
bool WMBitStream::Open( const char* filename )
{
ResetBuffer();
return WBaseStream::Open( filename );
}
void WMBitStream::ResetBuffer()
{
m_val = 0;
m_bit_idx = 32;
m_current = m_start;
}
void WMBitStream::Flush()
{
if( m_bit_idx < 32 )
{
Put( m_pad_val, m_bit_idx & 7 );
*((ulong*&)m_current)++ = m_val;
}
}
void WMBitStream::Close()
{
if( m_is_opened )
{
Flush();
WBaseStream::Close();
}
}
void WMBitStream::WriteBlock()
{
if( !bsIsBigEndian() )
bsBSwapBlock( m_start, m_current );
WBaseStream::WriteBlock();
}
int WMBitStream::GetPos()
{
return WBaseStream::GetPos() + ((32 - m_bit_idx) >> 3);
}
void WMBitStream::Put( int val, int bits )
{
int bit_idx = m_bit_idx - bits;
ulong curval = m_val;
assert( 0 <= bits && bits < 32 );
val &= bs_bit_mask[bits];
if( bit_idx >= 0 )
{
curval |= val << bit_idx;
}
else
{
*((ulong*&)m_current)++ = curval | ((unsigned)val >> -bit_idx);
if( m_current >= m_end )
{
WriteBlock();
}
bit_idx += 32;
curval = val << bit_idx;
}
m_val = curval;
m_bit_idx = bit_idx;
}
void WMBitStream::PutHuff( int val, const ulong* table )
{
int min_val = (int)table[0];
val -= min_val;
assert( (unsigned)val < table[1] );
ulong code = table[val + 2];
assert( code != 0 );
Put( code >> 8, code & 255 );
}
bool bsCreateEncodeHuffmanTable( const int* src, ulong* table, int max_size )
{
int i, k;
int min_val = INT_MAX, max_val = INT_MIN;
int size;
/* calc min and max values in the table */
for( i = 1, k = 1; src[k] >= 0; i++ )
{
int code_count = src[k++];
for( code_count += k; k < code_count; k++ )
{
int val = src[k] >> huff_val_shift;
if( val < min_val )
min_val = val;
if( val > max_val )
max_val = val;
}
}
size = max_val - min_val + 3;
if( size > max_size )
{
assert(0);
return false;
}
memset( table, 0, size*sizeof(table[0]));
table[0] = min_val;
table[1] = size - 2;
for( i = 1, k = 1; src[k] >= 0; i++ )
{
int code_count = src[k++];
for( code_count += k; k < code_count; k++ )
{
int val = src[k] >> huff_val_shift;
int code = src[k] & huff_code_mask;
table[val - min_val + 2] = (code << 8) | i;
}
}
return true;
}