Main Page | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members

BByteStream.h

00001 //
00002 // Copyright (c) 2000 by Tech Soft America, LLC.
00003 // The information contained herein is confidential and proprietary to
00004 // Tech Soft America, LLC., and considered a trade secret as defined under
00005 // civil and criminal statutes.  Tech Soft America shall pursue its civil
00006 // and criminal remedies in the event of unauthorized use or misappropriation
00007 // of its trade secrets.  Use of this information by anyone other than
00008 // authorized employees of Tech Soft America, LLC. is granted only under a
00009 // written non-disclosure agreement, expressly prescribing the scope and
00010 // manner of such use.
00011 //
00012 // $Header: /NewRoot/DWF Toolkit/v6/develop/global/src/dwf/w3dtk/BByteStream.h 1     9/12/04 8:46p Evansg $
00013 //
00014 // This header file is a completely self-contained class that defines all of the
00015 // member functions that it needs inside the declaration.  It is just a utility class
00016 // to stuff unaligned data values into bytes.
00017 //
00018 
00019 #ifndef _B_BYTE_STREAM_H_
00020 #define _B_BYTE_STREAM_H_
00021 
00022 
00023 #ifndef STATUS_ERROR
00024 #  define STATUS_ERROR 0
00025 #endif
00026 #ifndef STATUS_NORMAL
00027 #  define STATUS_NORMAL 1
00028 #endif
00029 
00030 
00031 
00032 
00033 class BByteStream {
00034   private:
00035     int byteplace;          
00036     int bitplace;           
00037     int bitsperval;         
00038     int allocated;          
00039     unsigned char *data;    
00040     unsigned short mask;    
00041   public:
00042     BByteStream(int size, unsigned char *cptr, int bpv) {
00043         if( bpv == 9 || bpv == 10 || bpv == 12 ) {
00044             allocated = size;
00045             data = cptr; 
00046             bitsperval = bpv;
00047             byteplace = 0;
00048             bitplace = 16 - bitsperval; 
00049             mask = ((1<<bitsperval)-1);
00050         }
00051         else {
00052             
00053             data = 0;
00054         }
00055     };
00056     BByteStream() { data = NULL; };
00057     
00058     void put(unsigned short value) alter {
00059         data[byteplace] |= (value >> (8 - bitplace));
00060         data[byteplace+1] |= (value << bitplace);
00061         bitplace -= bitsperval - 8;
00062         if( bitplace < 0 ) {
00063             byteplace += 2; 
00064             bitplace += 8;
00065         }
00066         else
00067             byteplace++; 
00068     };      
00069     
00070     void get(unsigned short alter &value) {
00071         value = (data[byteplace] << 8) | (data[byteplace + 1]);
00072         value = ((value >> bitplace) & mask );
00073         bitplace -= bitsperval - 8;
00074         if( bitplace < 0 ) {
00075             byteplace += 2; 
00076             bitplace += 8;
00077         }
00078         else
00079             byteplace++; 
00080     }; 
00081 
00082 }; 
00083 
00084 
00085 
00086 
00087 class BVarStream {
00088   private:
00089     unsigned int *m_data;   
00090     int m_allocated;        
00091     int m_used;             
00092     int m_bit;              
00093     int m_rused;            
00094     int m_rbit;             
00095     int m_can_reallocate;   
00096     int m_status;           
00097     unsigned int m_mask[33];  
00098     unsigned int m_range[33]; 
00099 
00100 
00101     
00102     void Reset() {
00103         int i;
00104         m_data = 0;
00105         m_allocated = 0;
00106         m_used = 0;
00107         m_bit = 0;
00108         m_rused = 0;
00109         m_rbit = 0;
00110         m_can_reallocate = 0;
00111         m_status = STATUS_NORMAL;
00112         m_mask[0] = 0;
00113         m_range[0] = 0;
00114         for( i = 1 ; i <= 32 ; i++ ) {
00115             m_mask[i] = ((unsigned int)(-1)) >> (32-i);
00116             m_range[i] = (0x1 << (i-1)) - 1;
00117         }
00118     };
00119 
00120     
00121     #ifdef STREAM_BIGENDIAN
00122         #ifndef SWAP32
00123             #define SWAP32(i) (\
00124                 (((i) >> 24) & 0x000000ff) |\
00125                 (((i) & 0x00ff0000) >> 8) |\
00126                 (((i) & 0x0000ff00) << 8) |\
00127                 ((i) << 24) \
00128                 )
00129             #endif
00130     void SwapBytes( ) 
00131     {
00132         int i;
00133         for( i = 0 ; i < m_allocated ; i++ )
00134             m_data[i] = SWAP32( m_data[i] );
00135     };
00136 #   else
00137     inline void SwapBytes() {};
00138 #   endif
00139 
00140     
00141     void Reallocate( )
00142     {
00143 
00144         if( m_can_reallocate ) {
00145             unsigned int *temp;
00146             m_allocated *= 2;
00147             temp = new unsigned int[ m_allocated ];
00148             if( temp == NULL ) {
00149                 
00150                 m_status = STATUS_ERROR;
00151                 m_used = 0; 
00152             }
00153             else {
00154                 memcpy( temp, m_data, (m_used+1) * sizeof( unsigned int ) );
00155                 delete [] m_data;
00156                 m_data = temp;
00157             }
00158         }
00159         else {
00160             
00161             m_status = STATUS_ERROR;
00162             m_used = 0;
00163         }
00164     };
00165 
00166     
00167     void Put2( int numbits, int val ) 
00168     {
00169         if( m_bit + numbits <= 32 ) {
00170             m_data[m_used] |= val << (32 - m_bit - numbits);
00171             m_bit += numbits;
00172         }
00173         else {
00174             int shift = (numbits + m_bit - 32);
00175 
00176             if( m_used + 1 >= m_allocated )
00177                 Reallocate( );
00178             m_data[m_used++] |= val >> shift;
00179             m_data[m_used] = val << (32-shift);
00180             m_bit += numbits - 32;
00181         }
00182     };
00183 
00184     
00185     void Get2( int numbits, int *val ) 
00186     {
00187         if( m_rbit + numbits <= 32 ) {
00188             *val = (m_data[m_rused] >> (32 - m_rbit - numbits)) & m_mask[numbits];
00189             m_rbit += numbits;
00190         }
00191         else {
00192             int shift = (numbits + m_rbit - 32);
00193             *val = (m_data[m_rused++] << shift) & m_mask[numbits];
00194             *val |= m_data[m_rused] >> (32-shift);
00195             m_rbit += numbits - 32;
00196         }
00197     };
00198 
00199 
00200   public:
00201 
00202     BVarStream() {
00203         m_can_reallocate = 0;
00204         m_data = NULL;
00205     };
00206 
00207     ~BVarStream( )
00208     {
00209         if( m_data != NULL ) {
00210             if( m_can_reallocate )
00211                 delete [] m_data;
00212             m_data = NULL;
00213         }
00214     };
00215 
00216     
00217     void InitWrite( int size, void *pointer ) {
00218         Reset();
00219         m_allocated = size/4;
00220         m_data = (unsigned int *) pointer;
00221         m_data[0] = 0;
00222         m_can_reallocate = 1;
00223     };
00224 
00225     
00226     void InitRead( int size, const void *pointer )
00227     {
00228         Reset();
00229         m_allocated = size/4;
00230         m_data = (unsigned int *) pointer;
00231         m_can_reallocate = 0;
00232     };
00233 
00234     
00235     int Put( int *numbits_array, int val )
00236     {
00237         int temprange = 0, i;
00238 
00239         i = 0;
00240         for(;;){
00241             temprange = m_range[ numbits_array[i] ];
00242             if( val < -temprange || val > temprange ) {
00243                 
00244                 Put2( numbits_array[i], m_mask[ numbits_array[i] ] );
00245                 i++;
00246             }
00247             else {
00248                 
00249                 Put2( numbits_array[i], val+temprange );
00250                 break;
00251             }
00252         }
00253         return m_status;
00254     };
00255 
00256     
00257     int Get( int *numbits_array ) 
00258     {
00259         int i = 0;
00260         int val;
00261 
00262         for(;;) {
00263             Get2( numbits_array[i], &val );
00264             if( val == (int)m_mask[ numbits_array[i] ] )
00265                 i++;
00266             else
00267                 break;
00268         }
00269         val -= m_range[ numbits_array[i] ];
00270         return val;
00271     };
00272 
00273 }; 
00274 
00275 
00276 
00277 
00278 
00279 class BPack {
00280   private:
00281     unsigned int *m_data; 
00282     int m_allocated;    
00283     int m_used;         
00284     int m_bit;          
00285     int m_rused;                
00286     int m_rbit;         
00287     int m_can_reallocate; 
00288     int m_status;               
00289     unsigned int m_mask[33]; 
00290     unsigned int m_range[33]; 
00291 
00292 
00293     
00294     void Reset() {
00295         int i;
00296         m_data = 0;
00297         m_allocated = 0;
00298         m_used = 0;
00299         m_bit = 0;
00300         m_rused = 0;
00301         m_rbit = 0;
00302         m_can_reallocate = 0;
00303         m_status = STATUS_NORMAL;
00304         m_mask[0] = 0;
00305         m_range[0] = 0;
00306         for( i = 1 ; i <= 32 ; i++ ) {
00307             m_mask[i] = ((unsigned int)(-1)) >> (32-i);
00308             m_range[i] = (0x1 << (i-1)) - 1;
00309         }
00310     };
00311 
00312     
00313     void Reallocate( )
00314     {
00315 
00316         if( m_can_reallocate ) {
00317             unsigned int *temp;
00318             m_allocated *= 2;
00319             temp = new unsigned int[ m_allocated ];
00320             if( temp == NULL ) {
00321                 
00322                 m_status = STATUS_ERROR;
00323                 m_used = 0; 
00324             }
00325             else {
00326                 memcpy( temp, m_data, (m_used+1) * sizeof( unsigned int ) );
00327                 delete [] m_data;
00328                 m_data = temp;
00329             }
00330         }
00331         else {
00332             
00333             m_status = STATUS_ERROR;
00334             m_used = 0;
00335         }
00336     };
00337 
00338 
00339 
00340   public:
00341 
00342     BPack() { 
00343         m_can_reallocate = 0;
00344         m_data = NULL;
00345     };
00346 
00347     ~BPack( ) {
00348         if( m_data != NULL ) {
00349             if( m_can_reallocate )
00350                 delete [] m_data;
00351             m_data = NULL;
00352         }
00353     };
00354 
00355     
00356     void InitWrite( int size, void *pointer ) {
00357         Reset();
00358         m_allocated = size/4;
00359         m_data = (unsigned int *) pointer;
00360         m_data[0] = 0;
00361         m_can_reallocate = 0;
00362     };
00363 
00364     
00365     void InitRead( int size, const void *pointer )
00366     {
00367         Reset();
00368         m_allocated = size/4;
00369         m_data = (unsigned int *) pointer;
00370         m_can_reallocate = 0;
00371     };
00372 
00373     void Put( int numbits, int val ) 
00374     {
00375         if( m_bit + numbits <= 32 ) {
00376             m_data[m_used] |= val << (32 - m_bit - numbits);
00377             m_bit += numbits;
00378         }
00379         else {
00380             int shift = (numbits + m_bit - 32);
00381 
00382             if( m_used + 1 >= m_allocated )
00383                 Reallocate( );
00384             m_data[m_used++] |= val >> shift;
00385             m_data[m_used] = val << (32-shift);
00386             m_bit += numbits - 32;
00387         }
00388     };
00389 
00390     int Get( int numbits ) 
00391     {
00392         int return_val;
00393 
00394         if( m_rbit + numbits <= 32 ) {
00395             return_val = (m_data[m_rused] >> (32 - m_rbit - numbits)) & m_mask[numbits];
00396             m_rbit += numbits;
00397         }
00398         else {
00399             int shift = (numbits + m_rbit - 32);
00400             return_val = (m_data[m_rused++] << shift) & m_mask[numbits];
00401             return_val |= m_data[m_rused] >> (32-shift);
00402             m_rbit += numbits - 32;
00403         }
00404         return return_val;
00405     };
00406 
00407     int NumBytes() const { return (m_used+1) * 4; };
00408     void SetCanReallocate(int val) alter { m_can_reallocate = val; };
00409     int GetStatus() const { return m_status; };
00410 
00411     
00412     #ifdef STREAM_BIGENDIAN
00413         void SwapBytes( ) 
00414         {
00415             int i;
00416             for( i = 0 ; i < m_allocated ; i++ )
00417                 m_data[i] = SWAP32( m_data[i] );
00418         };
00419     #else
00420         inline void SwapBytes() {};
00421     #endif
00422 
00423 }; 
00424 
00425 
00426 #endif 
00427 

Generated on Tue May 17 12:05:59 2005 for Autodesk DWF 3D Toolkit by  doxygen 1.4.1