misc/libtremor/bitwise.c
changeset 5170 f7e49eff3708
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/misc/libtremor/bitwise.c	Sun Apr 24 22:57:57 2011 +0200
@@ -0,0 +1,265 @@
+/********************************************************************
+ *                                                                  *
+ * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE.   *
+ *                                                                  *
+ * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
+ * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
+ * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
+ *                                                                  *
+ * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002    *
+ * BY THE Xiph.Org FOUNDATION http://www.xiph.org/                  *
+ *                                                                  *
+ ********************************************************************
+
+  function: packing variable sized words into an octet stream
+
+ ********************************************************************/
+
+/* We're 'LSb' endian; if we write a word but read individual bits,
+   then we'll read the lsb first */
+
+#include <string.h>
+#include <stdlib.h>
+#include "ogg.h"
+
+static unsigned long mask[]=
+{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
+ 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
+ 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
+ 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
+ 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
+ 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
+ 0x3fffffff,0x7fffffff,0xffffffff };
+
+/* mark read process as having run off the end */
+static void _adv_halt(oggpack_buffer *b){
+  b->headptr=b->head->buffer->data+b->head->begin+b->head->length;
+  b->headend=-1;
+  b->headbit=0;
+}
+
+/* spans forward, skipping as many bytes as headend is negative; if
+   headend is zero, simply finds next byte.  If we're up to the end
+   of the buffer, leaves headend at zero.  If we've read past the end,
+   halt the decode process. */
+static void _span(oggpack_buffer *b){
+  while(b->headend<1){
+    if(b->head->next){
+      b->count+=b->head->length;
+      b->head=b->head->next;
+      b->headptr=b->head->buffer->data+b->head->begin-b->headend;
+      b->headend+=b->head->length;
+    }else{
+      /* we've either met the end of decode, or gone past it. halt
+         only if we're past */
+      if(b->headend<0 || b->headbit)
+        /* read has fallen off the end */
+        _adv_halt(b);
+
+      break;
+    }
+  }
+}
+
+void oggpack_readinit(oggpack_buffer *b,ogg_reference *r){
+  memset(b,0,sizeof(*b));
+
+  b->tail=b->head=r;
+  b->count=0;
+  b->headptr=b->head->buffer->data+b->head->begin;
+  b->headend=b->head->length;
+  _span(b);
+}
+
+#define _lookspan()   while(!end){\
+                        head=head->next;\
+                        if(!head) return -1;\
+                        ptr=head->buffer->data + head->begin;\
+                        end=head->length;\
+                      }
+
+/* Read in bits without advancing the bitptr; bits <= 32 */
+long oggpack_look(oggpack_buffer *b,int bits){
+  unsigned long m=mask[bits];
+  unsigned long ret=-1;
+
+  bits+=b->headbit;
+
+  if(bits >= b->headend<<3){
+    int            end=b->headend;
+    unsigned char *ptr=b->headptr;
+    ogg_reference *head=b->head;
+
+    if(end<0)return -1;
+
+    if(bits){
+      _lookspan();
+      ret=*ptr++>>b->headbit;
+      if(bits>8){
+        --end;
+        _lookspan();
+        ret|=*ptr++<<(8-b->headbit);
+        if(bits>16){
+          --end;
+          _lookspan();
+          ret|=*ptr++<<(16-b->headbit);
+          if(bits>24){
+            --end;
+            _lookspan();
+            ret|=*ptr++<<(24-b->headbit);
+            if(bits>32 && b->headbit){
+              --end;
+              _lookspan();
+              ret|=*ptr<<(32-b->headbit);
+            }
+          }
+        }
+      }
+    }
+
+  }else{
+
+    /* make this a switch jump-table */
+    ret=b->headptr[0]>>b->headbit;
+    if(bits>8){
+      ret|=b->headptr[1]<<(8-b->headbit);  
+      if(bits>16){
+        ret|=b->headptr[2]<<(16-b->headbit);  
+        if(bits>24){
+          ret|=b->headptr[3]<<(24-b->headbit);  
+          if(bits>32 && b->headbit)
+            ret|=b->headptr[4]<<(32-b->headbit);
+        }
+      }
+    }
+  }
+
+  ret&=m;
+  return ret;
+}
+
+/* limited to 32 at a time */
+void oggpack_adv(oggpack_buffer *b,int bits){
+  bits+=b->headbit;
+  b->headbit=bits&7;
+  b->headptr+=bits/8;
+  if((b->headend-=bits/8)<1)_span(b);
+}
+
+/* spans forward and finds next byte.  Never halts */
+static void _span_one(oggpack_buffer *b){
+  while(b->headend<1){
+    if(b->head->next){
+      b->count+=b->head->length;
+      b->head=b->head->next;
+      b->headptr=b->head->buffer->data+b->head->begin;
+      b->headend=b->head->length;
+    }else
+      break;
+  }
+}
+
+static int _halt_one(oggpack_buffer *b){
+  if(b->headend<1){
+    _adv_halt(b);
+    return -1;
+  }
+  return 0;
+}
+
+int oggpack_eop(oggpack_buffer *b){
+  if(b->headend<0)return -1;
+  return 0;
+}
+
+/* bits <= 32 */
+long oggpack_read(oggpack_buffer *b,int bits){
+  unsigned long m=mask[bits];
+  ogg_uint32_t ret=-1;
+
+  bits+=b->headbit;
+
+  if(bits >= b->headend<<3){
+
+    if(b->headend<0)return -1;
+
+    if(bits){
+      if (_halt_one(b)) return -1;
+      ret=*b->headptr>>b->headbit;
+
+      if(bits>=8){
+        ++b->headptr;
+        --b->headend;
+        _span_one(b);
+        if(bits>8){
+          if (_halt_one(b)) return -1;
+          ret|=*b->headptr<<(8-b->headbit);
+
+          if(bits>=16){
+            ++b->headptr;
+            --b->headend;
+            _span_one(b);
+            if(bits>16){
+              if (_halt_one(b)) return -1;
+              ret|=*b->headptr<<(16-b->headbit);
+
+              if(bits>=24){
+                ++b->headptr;
+                --b->headend;
+                _span_one(b);
+                if(bits>24){
+                  if (_halt_one(b)) return -1;
+                  ret|=*b->headptr<<(24-b->headbit);
+
+                  if(bits>=32){
+                    ++b->headptr;
+                    --b->headend;
+                    _span_one(b);
+                    if(bits>32){
+                      if (_halt_one(b)) return -1;
+                      if(b->headbit)ret|=*b->headptr<<(32-b->headbit);
+
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }else{
+
+    ret=b->headptr[0]>>b->headbit;
+    if(bits>8){
+      ret|=b->headptr[1]<<(8-b->headbit);
+      if(bits>16){
+        ret|=b->headptr[2]<<(16-b->headbit);
+        if(bits>24){
+          ret|=b->headptr[3]<<(24-b->headbit);
+          if(bits>32 && b->headbit){
+            ret|=b->headptr[4]<<(32-b->headbit);
+          }
+        }
+      }
+    }
+
+    b->headptr+=bits/8;
+    b->headend-=bits/8;
+  }
+
+  ret&=m;
+  b->headbit=bits&7;
+  return ret;
+}
+
+long oggpack_bytes(oggpack_buffer *b){
+  return(b->count+b->headptr-b->head->buffer->data-b->head->begin+
+         (b->headbit+7)/8);
+}
+
+long oggpack_bits(oggpack_buffer *b){
+  return((b->count+b->headptr-b->head->buffer->data-b->head->begin)*8+
+         b->headbit);
+}
+