mi32/membuf.h

Go to the documentation of this file.

/**
 * \file membuf.h <mi32/membuf.h>
 * \brief Functions to handle memory buffers
 *
 * \if NODOC
 * $Id: membuf.h_v 1.18 2006/03/30 15:08:28 mju Exp $
 *
 * $Log: membuf.h_v $
 * Revision 1.18  2006/03/30 15:08:28  mju
 * Add miunicode variant of swapbytes.
 *
 * Revision 1.17  2005/10/19 21:01:45  mju
 * Don't use C linkage for inlines - attempting to fix wierd link error.
 *
 * Revision 1.16  2005/10/19 20:52:18  mju
 * Remove non-inline version of getbit/putbit/memswap.
 *
 * Revision 1.15  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.14  2003/09/08 21:05:08  dwilliss
 * Added doxygen start/end tags for functions groups
 *
 * Revision 1.13  2001/11/07 16:44:22  scowan
 * Bad paran in putbit.
 *
 * Revision 1.12  2001/11/06 18:39:01  dwilliss
 * Made inline versions of getbit/putbit and memswap
 *
 * Revision 1.11  2001/03/01 16:37:39  scowan
 * Change list name to alist for std namespace.
 *
 * Revision 1.10  2000/06/22 21:36:06  mju
 * Improve docs for SwapBytes2/4/8.
 *
 * Revision 1.8  2000/06/20 18:00:30  sparsons
 * Genitor documentation.
 *
 * Revision 1.7  2000/06/08 17:14:39  mju
 * Fix to compile for non-C++.
 *
 * Revision 1.6  2000/05/12 15:26:48  mju
 * Use BUF instead of _B so doesn't conflict with ctype.h
 *
 * Revision 1.5  2000/05/11 16:24:57  mju
 * Must capitalize 'I' in "End Ignore" comment.
 *
 * Revision 1.4  2000/05/10 13:35:25  mju
 * Apparently sometimes Unix compiler doesn't like having ';' after ending brace in inline fn defn.
 * Make bitrev() an inline.
 *
 * Revision 1.3  2000/05/09 15:42:03  scowan
 * Added inline and template spawbytes routines.
 *
 * Revision 1.2  1999/05/12 16:55:54  mju
 * Use const for getbit/n.
 *
 * Revision 1.1  1999/04/19  17:36:54  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_MEMBUF_H
#define  INC_MI32_MEMBUF_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#if defined(__cplusplus)

//!:Associate with "Memory buffer functions"
//!\addtogroup membuf Memory buffer functions
//!@{

//! Swap bytes - character.
inline char SwapBytes (
   char& value
   ) {
   return (value);
   }

//! Swap bytes - 8 bit signed.
inline INT8 SwapBytes (
   INT8& value
   ) {
   return (value);
   }

//! Swap bytes - 8 bit unsigned.
inline UINT8 SwapBytes (
   UINT8& value
   ) {
   return (value);
   }

//! Swap bytes - 16 bit signed.
inline INT16 SwapBytes (
   INT16& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[1]; p[1] = tmp;
   return (value);
   }

//! Swap bytes - 16 bit unsigned.
inline UINT16 SwapBytes (
   UINT16& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[1]; p[1] = tmp;
   return (value);
   }

#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1400)
//! Swap bytes - MIUNICODE
inline UINT16 SwapBytes (
   MIUNICODE& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[1]; p[1] = tmp;
   return (value);
   }
#endif

//! Swap bytes - 32 bit signed.
inline INT32 SwapBytes (
   INT32& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[3]; p[3] = tmp;
   tmp = p[1]; p[1] = p[2]; p[2] = tmp;
   return (value);
   }

//! Swap bytes - 32 bit unsigned.
inline UINT32 SwapBytes (
   UINT32& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[3]; p[3] = tmp;
   tmp = p[1]; p[1] = p[2]; p[2] = tmp;
   return (value);
   }

//! Swap bytes - float.
inline float SwapBytes (
   float& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[3]; p[3] = tmp;
   tmp = p[1]; p[1] = p[2]; p[2] = tmp;
   return (value);
   }

//! Swap bytes - 64 bit signed.
inline INT64 SwapBytes (
   INT64& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[7]; p[7] = tmp;
   tmp = p[1]; p[1] = p[6]; p[6] = tmp;
   tmp = p[2]; p[2] = p[5]; p[5] = tmp;
   tmp = p[3]; p[3] = p[4]; p[4] = tmp;
   return (value);
   }

//! Swap bytes - 64 bit unsigned.
inline UINT64 SwapBytes (
   UINT64& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[7]; p[7] = tmp;
   tmp = p[1]; p[1] = p[6]; p[6] = tmp;
   tmp = p[2]; p[2] = p[5]; p[5] = tmp;
   tmp = p[3]; p[3] = p[4]; p[4] = tmp;
   return (value);
   }

//! Swap bytes - double.
inline double SwapBytes (
   double& value
   ) {
   UINT8 *p = reinterpret_cast<UINT8*>(&value);
   UINT8 tmp = p[0]; p[0] = p[7]; p[7] = tmp;
   tmp = p[1]; p[1] = p[6]; p[6] = tmp;
   tmp = p[2]; p[2] = p[5]; p[5] = tmp;
   tmp = p[3]; p[3] = p[4]; p[4] = tmp;
   return (value);
   }

//! Swap bytes.
template <class _BUF>
inline void SwapBytes (
   _BUF *alist,                        //!< Array of items to swap
   INT32 num                           //!< Number of items in array
   ) {
   for (INT32 _xy_ = 0; (_xy_ < num); ++_xy_) SwapBytes(alist[_xy_]);
   return;
   }

//! Swap bytes in array of 2-byte values (INT16, UINT16).
inline void SwapBytes2 (
   void *data,                         //!< Array of items to swap
   int num                             //!< Number of items
   ) {
   SwapBytes(static_cast<UINT16*>(data), num);
   return;
   }

//! Swap bytes in array of 4-byte values (float, INT32, UINT32).
inline void SwapBytes4 (
   void *data,                         //!< Array of items to swap
   int num                             //!< Number of items
   ) {
   SwapBytes(static_cast<UINT32*>(data), num);
   return;
   }

//! Swap bytes in array of 8-byte values (double, INT64, UINT64).
inline void SwapBytes8 (
   void *data,                         //!< Array of items to swap
   int num                             //!< Number of items
   ) {
   SwapBytes(static_cast<double*>(data), num);
   return;
   }

#endif   //!< C++

#ifndef GENERATING_DOXYGEN_OUTPUT
extern UINT8 _bitrevtable[];
#endif //!< GENERATING_DOXYGEN_OUTPUT

//! Reverse order of bits in a single byte.
#if defined(__cplusplus)
inline UINT8 bitrev (
   UINT8 b
   ) {
   return (_bitrevtable[b]);
   }
#else
#define  bitrev(b)   _bitrevtable[b]
#endif

//!
//! Get a value from a bit array.
//! 
//! @return 0 or 1.
inline int getbit (
   const UINT8 *array,                 //!< Bit array 
   INT32 index                         //!< Index into array
   ) {
   return ((array[index>>3] >> (index & 7)) & 1);
   }

//!   Get a value from a bit array, returns 0 if array is NULL.
//!
//! @return 0 or 1 (0 if array is NULL).
inline int getbitn (
   const UINT8 *array,                 //!< Bit array, can be NULL
   INT32 index                         //!< Index into array
   ) {
   if (array == 0) return (0);
   return ((array[index>>3] >> (index & 7)) & 1);
   }  

//! Swap data in two buffers.
inline void memswap (
   void *vb1, 
   void *vb2, 
   int count
   ) {
   UINT8* b1 = static_cast<UINT8*>(vb1);
   UINT8* b2 = static_cast<UINT8*>(vb2);

   for (int i = 0 ; i < count ; ++i, ++b1, ++b2) {
      UINT8 t = *b1; *b1 = *b2 ; *b2 = t;
      }
   }

//! Set entry in a bit array to a specified value.
inline void putbit (
   UINT8 *array,                       //!< Bit array
   INT32 index,                        //!< Index into array
   int value                           //!< Value to set to (any non-zero value assumed to be 1)
   ) {
   if (value)
      array[index >> 3] |= 1 << (index & 7);
   else
      array[index >> 3] &= ~(1 << (index & 7));
   }


#if defined(__cplusplus)
extern "C" {
#endif

//! Reverse bits for array.
void bitrevlin (
   UINT8 *buf, 
   int numbytes
   );

//! Pack TRUE/FALSE values from 8-bit array into bit array with least-significant bit as first bit.
//!
//! Non-zero values in the 8-bit array will be written as '1', zero values will
//! be written as '0'.
void packbits (
   UINT8 *dest, 
   UINT8 *source, 
   int count
   );

//! Pack TRUE / FALSE values from 8-bit array into bit array with MOST-significannt bit as first bit.
//!
//! Non-zero values in the 8-bit array will be written as '1', zero values will
//! be written as '0'.
void packbitsr (
   UINT8 *dest, 
   UINT8 *source, 
   int count
   );

//! Reverse the order of values in UINT8 array.
void revbuffer (
   void *vbuf, 
   int cols
   );

//! Swap data in a buffer given number of items and size.
void SwapDataInBuffer (
   void *data,                         //!< Array of items to swap
   INT32 NumItems,                     //!< Number of items in the array
   int ItemSize                        //!< Size of item to swap
   );

#if defined(__cplusplus)
}
#endif

//!@}

#endif   //!<  INC_MI32_MEMBUF_H 

---