otherlibs/highgui/bitstrm.cpp - platform/external/opencv - Git at Google

 /*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;
 }
	/*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;
	}