misc/libtremor/tremor/bitwise.c
branchhedgeroid
changeset 6045 9a7cc0f29430
parent 6043 9bd2d6b1ba52
child 7697 767d3c4153a1
equal deleted inserted replaced
6043:9bd2d6b1ba52 6045:9a7cc0f29430
       
     1 /********************************************************************
       
     2  *                                                                  *
       
     3  * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
       
     4  *                                                                  *
       
     5  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
       
     6  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
       
     7  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
       
     8  *                                                                  *
       
     9  * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
       
    10  * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
       
    11  *                                                                  *
       
    12  ********************************************************************
       
    13 
       
    14   function: packing variable sized words into an octet stream
       
    15 
       
    16  ********************************************************************/
       
    17 
       
    18 /* We're 'LSb' endian; if we write a word but read individual bits,
       
    19    then we'll read the lsb first */
       
    20 
       
    21 #include <string.h>
       
    22 #include <stdlib.h>
       
    23 #include "ogg.h"
       
    24 
       
    25 static unsigned long mask[]=
       
    26 {0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
       
    27  0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
       
    28  0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
       
    29  0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
       
    30  0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
       
    31  0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
       
    32  0x3fffffff,0x7fffffff,0xffffffff };
       
    33 
       
    34 /* mark read process as having run off the end */
       
    35 static void _adv_halt(oggpack_buffer *b){
       
    36   b->headptr=b->head->buffer->data+b->head->begin+b->head->length;
       
    37   b->headend=-1;
       
    38   b->headbit=0;
       
    39 }
       
    40 
       
    41 /* spans forward, skipping as many bytes as headend is negative; if
       
    42    headend is zero, simply finds next byte.  If we're up to the end
       
    43    of the buffer, leaves headend at zero.  If we've read past the end,
       
    44    halt the decode process. */
       
    45 static void _span(oggpack_buffer *b){
       
    46   while(b->headend<1){
       
    47     if(b->head->next){
       
    48       b->count+=b->head->length;
       
    49       b->head=b->head->next;
       
    50       b->headptr=b->head->buffer->data+b->head->begin-b->headend;
       
    51       b->headend+=b->head->length;
       
    52     }else{
       
    53       /* we've either met the end of decode, or gone past it. halt
       
    54          only if we're past */
       
    55       if(b->headend<0 || b->headbit)
       
    56         /* read has fallen off the end */
       
    57         _adv_halt(b);
       
    58 
       
    59       break;
       
    60     }
       
    61   }
       
    62 }
       
    63 
       
    64 void oggpack_readinit(oggpack_buffer *b,ogg_reference *r){
       
    65   memset(b,0,sizeof(*b));
       
    66 
       
    67   b->tail=b->head=r;
       
    68   b->count=0;
       
    69   b->headptr=b->head->buffer->data+b->head->begin;
       
    70   b->headend=b->head->length;
       
    71   _span(b);
       
    72 }
       
    73 
       
    74 #define _lookspan()   while(!end){\
       
    75                         head=head->next;\
       
    76                         if(!head) return -1;\
       
    77                         ptr=head->buffer->data + head->begin;\
       
    78                         end=head->length;\
       
    79                       }
       
    80 
       
    81 /* Read in bits without advancing the bitptr; bits <= 32 */
       
    82 long oggpack_look(oggpack_buffer *b,int bits){
       
    83   unsigned long m=mask[bits];
       
    84   unsigned long ret=-1;
       
    85 
       
    86   bits+=b->headbit;
       
    87 
       
    88   if(bits >= b->headend<<3){
       
    89     int            end=b->headend;
       
    90     unsigned char *ptr=b->headptr;
       
    91     ogg_reference *head=b->head;
       
    92 
       
    93     if(end<0)return -1;
       
    94 
       
    95     if(bits){
       
    96       _lookspan();
       
    97       ret=*ptr++>>b->headbit;
       
    98       if(bits>8){
       
    99         --end;
       
   100         _lookspan();
       
   101         ret|=*ptr++<<(8-b->headbit);
       
   102         if(bits>16){
       
   103           --end;
       
   104           _lookspan();
       
   105           ret|=*ptr++<<(16-b->headbit);
       
   106           if(bits>24){
       
   107             --end;
       
   108             _lookspan();
       
   109             ret|=*ptr++<<(24-b->headbit);
       
   110             if(bits>32 && b->headbit){
       
   111               --end;
       
   112               _lookspan();
       
   113               ret|=*ptr<<(32-b->headbit);
       
   114             }
       
   115           }
       
   116         }
       
   117       }
       
   118     }
       
   119 
       
   120   }else{
       
   121 
       
   122     /* make this a switch jump-table */
       
   123     ret=b->headptr[0]>>b->headbit;
       
   124     if(bits>8){
       
   125       ret|=b->headptr[1]<<(8-b->headbit);  
       
   126       if(bits>16){
       
   127         ret|=b->headptr[2]<<(16-b->headbit);  
       
   128         if(bits>24){
       
   129           ret|=b->headptr[3]<<(24-b->headbit);  
       
   130           if(bits>32 && b->headbit)
       
   131             ret|=b->headptr[4]<<(32-b->headbit);
       
   132         }
       
   133       }
       
   134     }
       
   135   }
       
   136 
       
   137   ret&=m;
       
   138   return ret;
       
   139 }
       
   140 
       
   141 /* limited to 32 at a time */
       
   142 void oggpack_adv(oggpack_buffer *b,int bits){
       
   143   bits+=b->headbit;
       
   144   b->headbit=bits&7;
       
   145   b->headptr+=bits/8;
       
   146   if((b->headend-=bits/8)<1)_span(b);
       
   147 }
       
   148 
       
   149 /* spans forward and finds next byte.  Never halts */
       
   150 static void _span_one(oggpack_buffer *b){
       
   151   while(b->headend<1){
       
   152     if(b->head->next){
       
   153       b->count+=b->head->length;
       
   154       b->head=b->head->next;
       
   155       b->headptr=b->head->buffer->data+b->head->begin;
       
   156       b->headend=b->head->length;
       
   157     }else
       
   158       break;
       
   159   }
       
   160 }
       
   161 
       
   162 static int _halt_one(oggpack_buffer *b){
       
   163   if(b->headend<1){
       
   164     _adv_halt(b);
       
   165     return -1;
       
   166   }
       
   167   return 0;
       
   168 }
       
   169 
       
   170 int oggpack_eop(oggpack_buffer *b){
       
   171   if(b->headend<0)return -1;
       
   172   return 0;
       
   173 }
       
   174 
       
   175 /* bits <= 32 */
       
   176 long oggpack_read(oggpack_buffer *b,int bits){
       
   177   unsigned long m=mask[bits];
       
   178   ogg_uint32_t ret=-1;
       
   179 
       
   180   bits+=b->headbit;
       
   181 
       
   182   if(bits >= b->headend<<3){
       
   183 
       
   184     if(b->headend<0)return -1;
       
   185 
       
   186     if(bits){
       
   187       if (_halt_one(b)) return -1;
       
   188       ret=*b->headptr>>b->headbit;
       
   189 
       
   190       if(bits>=8){
       
   191         ++b->headptr;
       
   192         --b->headend;
       
   193         _span_one(b);
       
   194         if(bits>8){
       
   195           if (_halt_one(b)) return -1;
       
   196           ret|=*b->headptr<<(8-b->headbit);
       
   197 
       
   198           if(bits>=16){
       
   199             ++b->headptr;
       
   200             --b->headend;
       
   201             _span_one(b);
       
   202             if(bits>16){
       
   203               if (_halt_one(b)) return -1;
       
   204               ret|=*b->headptr<<(16-b->headbit);
       
   205 
       
   206               if(bits>=24){
       
   207                 ++b->headptr;
       
   208                 --b->headend;
       
   209                 _span_one(b);
       
   210                 if(bits>24){
       
   211                   if (_halt_one(b)) return -1;
       
   212                   ret|=*b->headptr<<(24-b->headbit);
       
   213 
       
   214                   if(bits>=32){
       
   215                     ++b->headptr;
       
   216                     --b->headend;
       
   217                     _span_one(b);
       
   218                     if(bits>32){
       
   219                       if (_halt_one(b)) return -1;
       
   220                       if(b->headbit)ret|=*b->headptr<<(32-b->headbit);
       
   221 
       
   222                     }
       
   223                   }
       
   224                 }
       
   225               }
       
   226             }
       
   227           }
       
   228         }
       
   229       }
       
   230     }
       
   231   }else{
       
   232 
       
   233     ret=b->headptr[0]>>b->headbit;
       
   234     if(bits>8){
       
   235       ret|=b->headptr[1]<<(8-b->headbit);
       
   236       if(bits>16){
       
   237         ret|=b->headptr[2]<<(16-b->headbit);
       
   238         if(bits>24){
       
   239           ret|=b->headptr[3]<<(24-b->headbit);
       
   240           if(bits>32 && b->headbit){
       
   241             ret|=b->headptr[4]<<(32-b->headbit);
       
   242           }
       
   243         }
       
   244       }
       
   245     }
       
   246 
       
   247     b->headptr+=bits/8;
       
   248     b->headend-=bits/8;
       
   249   }
       
   250 
       
   251   ret&=m;
       
   252   b->headbit=bits&7;
       
   253   return ret;
       
   254 }
       
   255 
       
   256 long oggpack_bytes(oggpack_buffer *b){
       
   257   return(b->count+b->headptr-b->head->buffer->data-b->head->begin+
       
   258          (b->headbit+7)/8);
       
   259 }
       
   260 
       
   261 long oggpack_bits(oggpack_buffer *b){
       
   262   return((b->count+b->headptr-b->head->buffer->data-b->head->begin)*8+
       
   263          b->headbit);
       
   264 }
       
   265