Robust/src/Tests/ssJava/mp3decoder/BitReserve.java

   1 /*\r
   2  * 11/19/04                     1.0 moved to LGPL.\r
   3  * \r
   4  * 12/12/99 0.0.7       Implementation stores single bits \r
   5  *                                      as ints for better performance. mdm@techie.com.\r
   6  *\r
   7  * 02/28/99 0.0     Java Conversion by E.B, javalayer@javazoom.net\r
   8  *\r
   9  *                  Adapted from the public c code by Jeff Tsay.\r
  10  *\r
  11  *-----------------------------------------------------------------------\r
  12  *   This program is free software; you can redistribute it and/or modify\r
  13  *   it under the terms of the GNU Library General Public License as published\r
  14  *   by the Free Software Foundation; either version 2 of the License, or\r
  15  *   (at your option) any later version.\r
  16  *\r
  17  *   This program is distributed in the hope that it will be useful,\r
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  20  *   GNU Library General Public License for more details.\r
  21  *\r
  22  *   You should have received a copy of the GNU Library General Public\r
  23  *   License along with this program; if not, write to the Free Software\r
  24  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\r
  25  *----------------------------------------------------------------------\r
  26  */\r
  27         \r
  28 /**\r
  29  * Implementation of Bit Reservoir for Layer III.\r
  30  * <p>\r
  31  * The implementation stores single bits as a word in the buffer. If\r
  32  * a bit is set, the corresponding word in the buffer will be non-zero.\r
  33  * If a bit is clear, the corresponding word is zero. Although this\r
  34  * may seem waseful, this can be a factor of two quicker than \r
  35  * packing 8 bits to a byte and extracting. \r
  36  * <p> \r
  37  */\r
  38 \r
  39 // REVIEW: there is no range checking, so buffer underflow or overflow\r
  40 // can silently occur.\r
  41 final class BitReserve\r
  42 {\r
  43    /**\r
  44     * Size of the internal buffer to store the reserved bits.\r
  45     * Must be a power of 2. And x8, as each bit is stored as a single\r
  46     * entry.\r
  47     */\r
  48         private static final int                BUFSIZE = 4096*8;\r
  49         \r
  50         /**\r
  51          * Mask that can be used to quickly implement the\r
  52          * modulus operation on BUFSIZE.\r
  53          */\r
  54         private static final int                BUFSIZE_MASK = BUFSIZE-1;\r
  55         \r
  56         private int                                     offset, totbit, buf_byte_idx;\r
  57         private final int[]                     buf = new int[BUFSIZE];\r
  58         private int                                     buf_bit_idx;\r
  59         \r
  60    BitReserve()\r
  61    {\r
  62           \r
  63           offset = 0;\r
  64       totbit = 0;\r
  65       buf_byte_idx = 0;   \r
  66    }\r
  67       \r
  68    \r
  69    /**\r
  70     * Return totbit Field.\r
  71         */\r
  72    public int hsstell() \r
  73    { \r
  74            return(totbit); \r
  75    }\r
  76 \r
  77    /**\r
  78     * Read a number bits from the bit stream.\r
  79     * @param N the number of\r
  80         */\r
  81    public int hgetbits(int N)\r
  82    {\r
  83          totbit += N;\r
  84          \r
  85          int val = 0;\r
  86          \r
  87          int pos = buf_byte_idx;\r
  88          if (pos+N < BUFSIZE)\r
  89          {\r
  90                 while (N-- > 0)\r
  91                 {\r
  92                         val <<= 1;\r
  93                         val |= ((buf[pos++]!=0) ? 1 : 0);                \r
  94                 }\r
  95         }\r
  96          else\r
  97          {       \r
  98                  while (N-- > 0)\r
  99                 {\r
 100                          val <<= 1;                      \r
 101                          val |= ((buf[pos]!=0) ? 1 : 0);\r
 102                          pos = (pos+1) & BUFSIZE_MASK;\r
 103                 }                \r
 104          }      \r
 105          buf_byte_idx = pos;\r
 106          return val;\r
 107    }\r
 108    \r
 109          \r
 110    \r
 111    /**\r
 112     * Read 1 bit from the bit stream.\r
 113         */\r
 114 /*\r
 115    public int hget1bit_old()\r
 116    {\r
 117           int val;\r
 118           totbit++;\r
 119           if (buf_bit_idx == 0)\r
 120           {\r
 121          buf_bit_idx = 8;\r
 122              buf_byte_idx++;             \r
 123           }\r
 124       // BUFSIZE = 4096 = 2^12, so\r
 125       // buf_byte_idx%BUFSIZE == buf_byte_idx & 0xfff\r
 126       val = buf[buf_byte_idx & BUFSIZE_MASK] & putmask[buf_bit_idx];\r
 127       buf_bit_idx--;\r
 128           val = val >>> buf_bit_idx;\r
 129       return val;   \r
 130    }\r
 131  */\r
 132    /**\r
 133     * Returns next bit from reserve.\r
 134     * @returns 0 if next bit is reset, or 1 if next bit is set.\r
 135     */\r
 136    public int hget1bit()\r
 137    {      \r
 138           totbit++;       \r
 139           int val = buf[buf_byte_idx];\r
 140           buf_byte_idx = (buf_byte_idx+1) & BUFSIZE_MASK;\r
 141       return val;\r
 142    }\r
 143    \r
 144    /**\r
 145     * Retrieves bits from the reserve.     \r
 146     */\r
 147 /*   \r
 148    public int readBits(int[] out, int len)\r
 149    {\r
 150                 if (buf_bit_idx == 0)\r
 151                 {\r
 152                    buf_bit_idx = 8;\r
 153                    buf_byte_idx++;\r
 154                    current = buf[buf_byte_idx & BUFSIZE_MASK];\r
 155                 }      \r
 156                 \r
 157                 \r
 158                 \r
 159                 // save total number of bits returned\r
 160                 len = buf_bit_idx;\r
 161                 buf_bit_idx = 0;\r
 162                   \r
 163                 int b = current;\r
 164                 int count = len-1;\r
 165                   \r
 166                 while (count >= 0)\r
 167                 {\r
 168                     out[count--] = (b & 0x1);\r
 169                     b >>>= 1;\r
 170                 }\r
 171           \r
 172                 totbit += len;\r
 173                 return len;\r
 174    }\r
 175   */\r
 176    \r
 177    /**\r
 178     * Write 8 bits into the bit stream.\r
 179         */\r
 180    public void hputbuf(int val)\r
 181    {      \r
 182            int ofs = offset;\r
 183            buf[ofs++] = val & 0x80;\r
 184            buf[ofs++] = val & 0x40;\r
 185            buf[ofs++] = val & 0x20;\r
 186            buf[ofs++] = val & 0x10;\r
 187            buf[ofs++] = val & 0x08;\r
 188            buf[ofs++] = val & 0x04;\r
 189            buf[ofs++] = val & 0x02;\r
 190            buf[ofs++] = val & 0x01;\r
 191            \r
 192            if (ofs==BUFSIZE)\r
 193                         offset = 0;\r
 194            else\r
 195                         offset = ofs;\r
 196            \r
 197    }\r
 198  \r
 199    /**\r
 200     * Rewind N bits in Stream.\r
 201         */\r
 202    public void rewindNbits(int N)\r
 203    {\r
 204           totbit -= N;            \r
 205           buf_byte_idx -= N;\r
 206           if (buf_byte_idx<0)\r
 207                   buf_byte_idx += BUFSIZE;\r
 208    }\r
 209         \r
 210    /**\r
 211     * Rewind N bytes in Stream.\r
 212         */\r
 213    public void rewindNbytes(int N)\r
 214    {\r
 215       int bits = (N << 3);\r
 216           totbit -= bits;\r
 217           buf_byte_idx -= bits;   \r
 218           if (buf_byte_idx<0)\r
 219                   buf_byte_idx += BUFSIZE;\r
 220    }\r
 221 }\r