1/*M/////////////////////////////////////////////////////////////////////////////////////// 2// 3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4// 5// By downloading, copying, installing or using the software you agree to this license. 6// If you do not agree to this license, do not download, install, 7// copy or use the software. 8// 9// 10// Intel License Agreement 11// For Open Source Computer Vision Library 12// 13// Copyright (C) 2000, Intel Corporation, all rights reserved. 14// Third party copyrights are property of their respective owners. 15// 16// Redistribution and use in source and binary forms, with or without modification, 17// are permitted provided that the following conditions are met: 18// 19// * Redistribution's of source code must retain the above copyright notice, 20// this list of conditions and the following disclaimer. 21// 22// * Redistribution's in binary form must reproduce the above copyright notice, 23// this list of conditions and the following disclaimer in the documentation 24// and/or other materials provided with the distribution. 25// 26// * The name of Intel Corporation may not be used to endorse or promote products 27// derived from this software without specific prior written permission. 28// 29// This software is provided by the copyright holders and contributors "as is" and 30// any express or implied warranties, including, but not limited to, the implied 31// warranties of merchantability and fitness for a particular purpose are disclaimed. 32// In no event shall the Intel Corporation or contributors be liable for any direct, 33// indirect, incidental, special, exemplary, or consequential damages 34// (including, but not limited to, procurement of substitute goods or services; 35// loss of use, data, or profits; or business interruption) however caused 36// and on any theory of liability, whether in contract, strict liability, 37// or tort (including negligence or otherwise) arising in any way out of 38// the use of this software, even if advised of the possibility of such damage. 39// 40//M*/ 41 42#ifndef _BITSTRM_H_ 43#define _BITSTRM_H_ 44 45#include <stdio.h> 46#include <setjmp.h> 47 48#if _MSC_VER >= 1200 49 #pragma warning( disable: 4711 4324 ) 50#endif 51 52#define RBS_THROW_EOS -123 /* <end of stream> exception code */ 53#define RBS_THROW_FORB -124 /* <forrbidden huffman code> exception code */ 54#define RBS_HUFF_FORB 2047 /* forrbidden huffman code "value" */ 55 56typedef unsigned char uchar; 57typedef unsigned long ulong; 58 59// class RBaseStream - base class for other reading streams. 60class RBaseStream 61{ 62public: 63 //methods 64 RBaseStream(); 65 virtual ~RBaseStream(); 66 67 virtual bool Open( const char* filename ); 68 virtual void Close(); 69 void SetBlockSize( int block_size, int unGetsize = 4 ); 70 bool IsOpened(); 71 void SetPos( int pos ); 72 int GetPos(); 73 void Skip( int bytes ); 74 jmp_buf& JmpBuf(); 75 76protected: 77 78 jmp_buf m_jmp_buf; 79 uchar* m_start; 80 uchar* m_end; 81 uchar* m_current; 82 FILE* m_file; 83 int m_unGetsize; 84 int m_block_size; 85 int m_block_pos; 86 bool m_jmp_set; 87 bool m_is_opened; 88 89 virtual void ReadBlock(); 90 virtual void Release(); 91 virtual void Allocate(); 92}; 93 94 95// class RLByteStream - uchar-oriented stream. 96// l in prefix means that the least significant uchar of a multi-uchar value goes first 97class RLByteStream : public RBaseStream 98{ 99public: 100 virtual ~RLByteStream(); 101 102 int GetByte(); 103 void GetBytes( void* buffer, int count, int* readed = 0 ); 104 int GetWord(); 105 int GetDWord(); 106}; 107 108// class RMBitStream - uchar-oriented stream. 109// m in prefix means that the most significant uchar of a multi-uchar value go first 110class RMByteStream : public RLByteStream 111{ 112public: 113 virtual ~RMByteStream(); 114 115 int GetWord(); 116 int GetDWord(); 117}; 118 119// class RLBitStream - bit-oriented stream. 120// l in prefix means that the least significant bit of a multi-bit value goes first 121class RLBitStream : public RBaseStream 122{ 123public: 124 virtual ~RLBitStream(); 125 126 void SetPos( int pos ); 127 int GetPos(); 128 int Get( int bits ); 129 int Show( int bits ); 130 int GetHuff( const short* table ); 131 void Move( int shift ); 132 void Skip( int bytes ); 133 134protected: 135 int m_bit_idx; 136 virtual void ReadBlock(); 137}; 138 139// class RMBitStream - bit-oriented stream. 140// m in prefix means that the most significant bit of a multi-bit value goes first 141class RMBitStream : public RLBitStream 142{ 143public: 144 virtual ~RMBitStream(); 145 146 void SetPos( int pos ); 147 int GetPos(); 148 int Get( int bits ); 149 int Show( int bits ); 150 int GetHuff( const short* table ); 151 void Move( int shift ); 152 void Skip( int bytes ); 153 154protected: 155 virtual void ReadBlock(); 156}; 157 158 159// WBaseStream - base class for output streams 160class WBaseStream 161{ 162public: 163 //methods 164 WBaseStream(); 165 virtual ~WBaseStream(); 166 167 virtual bool Open( const char* filename ); 168 virtual void Close(); 169 void SetBlockSize( int block_size ); 170 bool IsOpened(); 171 int GetPos(); 172 173protected: 174 175 uchar* m_start; 176 uchar* m_end; 177 uchar* m_current; 178 int m_block_size; 179 int m_block_pos; 180 FILE* m_file; 181 bool m_is_opened; 182 183 virtual void WriteBlock(); 184 virtual void Release(); 185 virtual void Allocate(); 186}; 187 188 189// class WLByteStream - uchar-oriented stream. 190// l in prefix means that the least significant uchar of a multi-byte value goes first 191class WLByteStream : public WBaseStream 192{ 193public: 194 virtual ~WLByteStream(); 195 196 void PutByte( int val ); 197 void PutBytes( const void* buffer, int count ); 198 void PutWord( int val ); 199 void PutDWord( int val ); 200}; 201 202 203// class WLByteStream - uchar-oriented stream. 204// m in prefix means that the least significant uchar of a multi-byte value goes last 205class WMByteStream : public WLByteStream 206{ 207public: 208 virtual ~WMByteStream(); 209 210 void PutWord( int val ); 211 void PutDWord( int val ); 212}; 213 214 215// class WLBitStream - bit-oriented stream. 216// l in prefix means that the least significant bit of a multi-bit value goes first 217class WLBitStream : public WBaseStream 218{ 219public: 220 virtual ~WLBitStream(); 221 222 int GetPos(); 223 void Put( int val, int bits ); 224 void PutHuff( int val, const int* table ); 225 226protected: 227 int m_bit_idx; 228 int m_val; 229 virtual void WriteBlock(); 230}; 231 232 233// class WMBitStream - bit-oriented stream. 234// l in prefix means that the least significant bit of a multi-bit value goes first 235class WMBitStream : public WBaseStream 236{ 237public: 238 WMBitStream(); 239 virtual ~WMBitStream(); 240 241 bool Open( const char* filename ); 242 void Close(); 243 virtual void Flush(); 244 245 int GetPos(); 246 void Put( int val, int bits ); 247 void PutHuff( int val, const ulong* table ); 248 249protected: 250 int m_bit_idx; 251 ulong m_pad_val; 252 ulong m_val; 253 virtual void WriteBlock(); 254 void ResetBuffer(); 255}; 256 257 258 259#define BSWAP(v) (((v)<<24)|(((v)&0xff00)<<8)| \ 260 (((v)>>8)&0xff00)|((unsigned)(v)>>24)) 261 262int* bsCreateSourceHuffmanTable( const uchar* src, int* dst, 263 int max_bits, int first_bits ); 264bool bsCreateDecodeHuffmanTable( const int* src, short* dst, int max_size ); 265bool bsCreateEncodeHuffmanTable( const int* src, ulong* dst, int max_size ); 266 267void bsBSwapBlock( uchar *start, uchar *end ); 268bool bsIsBigEndian( void ); 269 270extern const ulong bs_bit_mask[]; 271 272#endif/*_BITSTRM_H_*/ 273