src/TS/utils.h

   1 #pragma once
   2
   3 #include <inttypes.h>
   4 #include <string.h>
   5 #include <assert.h>
   6 #include <list>
   7
   8 namespace TS {
   9
  10 class SectionBuffer
  11 {
  12 private:
  13         static const uint32_t MAX_SECTION_SIZE = 4096;
  14         uint8_t         *_data;
  15         uint32_t        _current;
  16         uint32_t        _set_size;
  17         uint32_t        _max_size;
  18
  19
  20 public:
  21         SectionBuffer() {
  22                 _data = NULL;
  23                 _current = 0;
  24                 _set_size = 0;
  25                 _max_size = 0;
  26         };
  27
  28         SectionBuffer( SectionBuffer &src) {
  29                 copy( &src);
  30         }
  31
  32         ~SectionBuffer() {
  33                 clear();
  34         }
  35
  36         bool            create( uint32_t size = MAX_SECTION_SIZE) {
  37                 clear();
  38                 if( size == 0) {
  39                         return true;
  40                 }
  41                 _data = new uint8_t[ size];
  42                 if( _data) {
  43                         _max_size = size;
  44                         wipe();
  45                         return true;
  46                 }
  47                 else {
  48                         return false;
  49                 }
  50         }
  51
  52         void            clear() {
  53                 if( _data) {
  54                         delete[] _data;
  55                 }
  56                 _data = NULL;
  57                 _current = 0;
  58                 _max_size = 0;
  59                 _set_size = 0;
  60         }
  61
  62         bool            append( const uint8_t *val, const uint32_t len) {
  63                 if( _set_size + len > _max_size) {
  64                         return false;
  65                 }
  66                 if( len > 0) {
  67                         memcpy( &_data[ _set_size], val, len);
  68                         _set_size += len;
  69                 }
  70                 return true;
  71         }
  72
  73         bool            append( uint8_t val) {
  74                 return append( &val, 1);
  75         }
  76
  77         bool            reserve( const uint32_t len) {
  78                 if( _set_size + len > _max_size) {
  79                         return false;
  80                 }
  81                 if( len > 0) {
  82                         _set_size += len;
  83                 }
  84                 return true;
  85         }
  86
  87         void            wipe() {
  88                 if( _data) {
  89                         memset( _data, 0x00, _max_size);
  90                         _current = 0;
  91                         _set_size = 0;
  92                 }
  93         }
  94
  95         uint8_t*        begin() const {
  96                 return _data;
  97         }
  98
  99         uint32_t        size() const {
 100                 return _set_size;
 101         }
 102
 103         uint32_t        length() const {
 104                 return _set_size - _current;
 105         }
 106
 107         void            reset() {
 108                 _current = 0;
 109         }
 110
 111         void            set_current( const uint32_t index) {
 112                 assert( index <= _set_size);
 113                 _current = index;
 114         }
 115
 116         uint8_t&        operator[]( uint32_t index) {
 117                 uint32_t i = _current + index;
 118                 assert( i < _set_size);
 119                 return _data[ i];
 120         }
 121
 122         const uint8_t&  operator[]( uint32_t index) const {
 123                 uint32_t i = _current + index;
 124                 assert( i < _set_size);
 125                 return _data[ i];
 126         }
 127
 128         operator uint8_t*() {
 129                 assert( _current < _set_size);
 130                 return &_data[ _current];
 131         }
 132
 133         operator const uint8_t*() const {
 134                 assert( _current < _set_size);
 135                 return &_data[ _current];
 136         }
 137
 138         uint8_t*        operator+( const uint32_t a) {
 139                 uint32_t i = _current + a;
 140                 assert( i < _set_size);
 141                 return _data + i;
 142         }
 143
 144         uint8_t*        operator-( const uint32_t a) {
 145                 uint32_t i = _current - a;
 146                 assert( i < _set_size);
 147                 return _data + i;
 148         }
 149
 150         const uint8_t*  operator+( const uint32_t a) const {
 151                 uint32_t i = _current + a;
 152                 assert( i < _set_size);
 153                 return _data + i;
 154         }
 155
 156         const uint8_t*  operator-( const uint32_t a) const {
 157                 uint32_t i = _current - a;
 158                 assert( i < _set_size);
 159                 return _data + i;
 160         }
 161
 162         SectionBuffer& operator+=( const uint32_t a) {
 163                 set_current( _current + a);
 164                 return *this;
 165         }
 166
 167         SectionBuffer& operator++() {
 168                 set_current( _current + 1);
 169                 return *this;
 170         }
 171
 172         SectionBuffer& operator-=( const uint32_t a) {
 173                 set_current( _current - a);
 174                 return *this;
 175         }
 176
 177         SectionBuffer& operator--() {
 178                 set_current( _current - 1);
 179                 return *this;
 180         }
 181
 182         SectionBuffer& operator=( SectionBuffer& src) {
 183                 copy( &src);
 184                 return *this;
 185         }
 186
 187 private:
 188         void            copy( SectionBuffer *p) {
 189                 create( p->_max_size);
 190                 append( p->_data, p->_set_size);
 191                 _current = 0;
 192         }
 193 };
 194
 195
 196 template< class T>
 197 class List
 198 {
 199 public:
 200         typedef T                               LIST_TYPE;
 201 private:
 202         typedef std::list< T>   __LIST;
 203
 204         __LIST          list;
 205
 206 public:
 207         List() {
 208                 clear();
 209         }
 210
 211         ~List() {
 212                 clear();
 213         }
 214
 215         void            clear() {
 216                 list.clear();
 217         }
 218
 219         int                     size() {
 220                 return (int)list.size();
 221         }
 222
 223         void            add( LIST_TYPE &val) {
 224                 list.push_back( val);
 225         }
 226
 227         void            insert( int index, LIST_TYPE &val) {
 228                 typename __LIST::iterator i;
 229                 if( index < 0) {
 230                         i = list.end();
 231                 }
 232                 else {
 233                         i = list.begin();
 234                         std::advance( i, index);
 235                 }
 236                 list.insert( i, val);
 237         }
 238
 239         void            erase( int index) {
 240                 assert( index < list.size());
 241                 typename __LIST::iterator i = list.begin();
 242                 std::advance( i, index);
 243                 list.erase( i);
 244         }
 245
 246         LIST_TYPE&      at( int index) {
 247                 assert( index < list.size());
 248                 typename __LIST::iterator i = list.begin();
 249                 std::advance( i, index);
 250                 return *i;
 251         }
 252 };
 253
 254 class CRC {
 255 public:
 256         uint32_t operator()( uint8_t *p, uint32_t len) {
 257                 const uint32_t t[ 256] = {
 258                         0x00000000, 0x04C11DB7, 0x09823B6E, 0x0D4326D9, 0x130476DC, 0x17C56B6B, 0x1A864DB2, 0x1E475005,
 259                         0x2608EDB8, 0x22C9F00F, 0x2F8AD6D6, 0x2B4BCB61, 0x350C9B64, 0x31CD86D3, 0x3C8EA00A, 0x384FBDBD,
 260                         0x4C11DB70, 0x48D0C6C7, 0x4593E01E, 0x4152FDA9, 0x5F15ADAC, 0x5BD4B01B, 0x569796C2, 0x52568B75,
 261                         0x6A1936C8, 0x6ED82B7F, 0x639B0DA6, 0x675A1011, 0x791D4014, 0x7DDC5DA3, 0x709F7B7A, 0x745E66CD,
 262                         0x9823B6E0, 0x9CE2AB57, 0x91A18D8E, 0x95609039, 0x8B27C03C, 0x8FE6DD8B, 0x82A5FB52, 0x8664E6E5,
 263                         0xBE2B5B58, 0xBAEA46EF, 0xB7A96036, 0xB3687D81, 0xAD2F2D84, 0xA9EE3033, 0xA4AD16EA, 0xA06C0B5D,
 264                         0xD4326D90, 0xD0F37027, 0xDDB056FE, 0xD9714B49, 0xC7361B4C, 0xC3F706FB, 0xCEB42022, 0xCA753D95,
 265                         0xF23A8028, 0xF6FB9D9F, 0xFBB8BB46, 0xFF79A6F1, 0xE13EF6F4, 0xE5FFEB43, 0xE8BCCD9A, 0xEC7DD02D,
 266                         0x34867077, 0x30476DC0, 0x3D044B19, 0x39C556AE, 0x278206AB, 0x23431B1C, 0x2E003DC5, 0x2AC12072,
 267                         0x128E9DCF, 0x164F8078, 0x1B0CA6A1, 0x1FCDBB16, 0x018AEB13, 0x054BF6A4, 0x0808D07D, 0x0CC9CDCA,
 268                         0x7897AB07, 0x7C56B6B0, 0x71159069, 0x75D48DDE, 0x6B93DDDB, 0x6F52C06C, 0x6211E6B5, 0x66D0FB02,
 269                         0x5E9F46BF, 0x5A5E5B08, 0x571D7DD1, 0x53DC6066, 0x4D9B3063, 0x495A2DD4, 0x44190B0D, 0x40D816BA,
 270                         0xACA5C697, 0xA864DB20, 0xA527FDF9, 0xA1E6E04E, 0xBFA1B04B, 0xBB60ADFC, 0xB6238B25, 0xB2E29692,
 271                         0x8AAD2B2F, 0x8E6C3698, 0x832F1041, 0x87EE0DF6, 0x99A95DF3, 0x9D684044, 0x902B669D, 0x94EA7B2A,
 272                         0xE0B41DE7, 0xE4750050, 0xE9362689, 0xEDF73B3E, 0xF3B06B3B, 0xF771768C, 0xFA325055, 0xFEF34DE2,
 273                         0xC6BCF05F, 0xC27DEDE8, 0xCF3ECB31, 0xCBFFD686, 0xD5B88683, 0xD1799B34, 0xDC3ABDED, 0xD8FBA05A,
 274                         0x690CE0EE, 0x6DCDFD59, 0x608EDB80, 0x644FC637, 0x7A089632, 0x7EC98B85, 0x738AAD5C, 0x774BB0EB,
 275                         0x4F040D56, 0x4BC510E1, 0x46863638, 0x42472B8F, 0x5C007B8A, 0x58C1663D, 0x558240E4, 0x51435D53,
 276                         0x251D3B9E, 0x21DC2629, 0x2C9F00F0, 0x285E1D47, 0x36194D42, 0x32D850F5, 0x3F9B762C, 0x3B5A6B9B,
 277                         0x0315D626, 0x07D4CB91, 0x0A97ED48, 0x0E56F0FF, 0x1011A0FA, 0x14D0BD4D, 0x19939B94, 0x1D528623,
 278                         0xF12F560E, 0xF5EE4BB9, 0xF8AD6D60, 0xFC6C70D7, 0xE22B20D2, 0xE6EA3D65, 0xEBA91BBC, 0xEF68060B,
 279                         0xD727BBB6, 0xD3E6A601, 0xDEA580D8, 0xDA649D6F, 0xC423CD6A, 0xC0E2D0DD, 0xCDA1F604, 0xC960EBB3,
 280                         0xBD3E8D7E, 0xB9FF90C9, 0xB4BCB610, 0xB07DABA7, 0xAE3AFBA2, 0xAAFBE615, 0xA7B8C0CC, 0xA379DD7B,
 281                         0x9B3660C6, 0x9FF77D71, 0x92B45BA8, 0x9675461F, 0x8832161A, 0x8CF30BAD, 0x81B02D74, 0x857130C3,
 282                         0x5D8A9099, 0x594B8D2E, 0x5408ABF7, 0x50C9B640, 0x4E8EE645, 0x4A4FFBF2, 0x470CDD2B, 0x43CDC09C,
 283                         0x7B827D21, 0x7F436096, 0x7200464F, 0x76C15BF8, 0x68860BFD, 0x6C47164A, 0x61043093, 0x65C52D24,
 284                         0x119B4BE9, 0x155A565E, 0x18197087, 0x1CD86D30, 0x029F3D35, 0x065E2082, 0x0B1D065B, 0x0FDC1BEC,
 285                         0x3793A651, 0x3352BBE6, 0x3E119D3F, 0x3AD08088, 0x2497D08D, 0x2056CD3A, 0x2D15EBE3, 0x29D4F654,
 286                         0xC5A92679, 0xC1683BCE, 0xCC2B1D17, 0xC8EA00A0, 0xD6AD50A5, 0xD26C4D12, 0xDF2F6BCB, 0xDBEE767C,
 287                         0xE3A1CBC1, 0xE760D676, 0xEA23F0AF, 0xEEE2ED18, 0xF0A5BD1D, 0xF464A0AA, 0xF9278673, 0xFDE69BC4,
 288                         0x89B8FD09, 0x8D79E0BE, 0x803AC667, 0x84FBDBD0, 0x9ABC8BD5, 0x9E7D9662, 0x933EB0BB, 0x97FFAD0C,
 289                         0xAFB010B1, 0xAB710D06, 0xA6322BDF, 0xA2F33668, 0xBCB4666D, 0xB8757BDA, 0xB5365D03, 0xB1F740B4,
 290                 };
 291                 uint32_t i;
 292                 uint32_t c = 0xffffffff;
 293                 for( i = 0; i < len; i++) {
 294                         c = t[ ((c >> 24) ^ p[ i]) & 0xff] ^ (c << 8);
 295                 }
 296                 return c;
 297         }
 298 };
 299
 300
 301 class Bits {
 302 public:
 303         static uint8_t get( uint8_t val, uint8_t offset, uint8_t mask) {
 304                 return (val >> offset) & mask;
 305         }
 306
 307         static void set( uint8_t *addr, uint8_t val, uint8_t offset, uint8_t mask) {
 308                 uint8_t e = ~(mask << offset);
 309                 uint8_t tmp = (val & mask) << offset;
 310
 311                 *addr &= e;
 312                 *addr |= tmp;
 313         }
 314 };
 315
 316
 317 }
 318