libFDK/src/FDK_crc.cpp

   1
   2 /* -----------------------------------------------------------------------------------------------------------
   3 Software License for The Fraunhofer FDK AAC Codec Library for Android
   4
   5 © Copyright  1995 - 2013 Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V.
   6   All rights reserved.
   7
   8  1.    INTRODUCTION
   9 The Fraunhofer FDK AAC Codec Library for Android ("FDK AAC Codec") is software that implements
  10 the MPEG Advanced Audio Coding ("AAC") encoding and decoding scheme for digital audio.
  11 This FDK AAC Codec software is intended to be used on a wide variety of Android devices.
  12
  13 AAC's HE-AAC and HE-AAC v2 versions are regarded as today's most efficient general perceptual
  14 audio codecs. AAC-ELD is considered the best-performing full-bandwidth communications codec by
  15 independent studies and is widely deployed. AAC has been standardized by ISO and IEC as part
  16 of the MPEG specifications.
  17
  18 Patent licenses for necessary patent claims for the FDK AAC Codec (including those of Fraunhofer)
  19 may be obtained through Via Licensing (www.vialicensing.com) or through the respective patent owners
  20 individually for the purpose of encoding or decoding bit streams in products that are compliant with
  21 the ISO/IEC MPEG audio standards. Please note that most manufacturers of Android devices already license
  22 these patent claims through Via Licensing or directly from the patent owners, and therefore FDK AAC Codec
  23 software may already be covered under those patent licenses when it is used for those licensed purposes only.
  24
  25 Commercially-licensed AAC software libraries, including floating-point versions with enhanced sound quality,
  26 are also available from Fraunhofer. Users are encouraged to check the Fraunhofer website for additional
  27 applications information and documentation.
  28
  29 2.    COPYRIGHT LICENSE
  30
  31 Redistribution and use in source and binary forms, with or without modification, are permitted without
  32 payment of copyright license fees provided that you satisfy the following conditions:
  33
  34 You must retain the complete text of this software license in redistributions of the FDK AAC Codec or
  35 your modifications thereto in source code form.
  36
  37 You must retain the complete text of this software license in the documentation and/or other materials
  38 provided with redistributions of the FDK AAC Codec or your modifications thereto in binary form.
  39 You must make available free of charge copies of the complete source code of the FDK AAC Codec and your
  40 modifications thereto to recipients of copies in binary form.
  41
  42 The name of Fraunhofer may not be used to endorse or promote products derived from this library without
  43 prior written permission.
  44
  45 You may not charge copyright license fees for anyone to use, copy or distribute the FDK AAC Codec
  46 software or your modifications thereto.
  47
  48 Your modified versions of the FDK AAC Codec must carry prominent notices stating that you changed the software
  49 and the date of any change. For modified versions of the FDK AAC Codec, the term
  50 "Fraunhofer FDK AAC Codec Library for Android" must be replaced by the term
  51 "Third-Party Modified Version of the Fraunhofer FDK AAC Codec Library for Android."
  52
  53 3.    NO PATENT LICENSE
  54
  55 NO EXPRESS OR IMPLIED LICENSES TO ANY PATENT CLAIMS, including without limitation the patents of Fraunhofer,
  56 ARE GRANTED BY THIS SOFTWARE LICENSE. Fraunhofer provides no warranty of patent non-infringement with
  57 respect to this software.
  58
  59 You may use this FDK AAC Codec software or modifications thereto only for purposes that are authorized
  60 by appropriate patent licenses.
  61
  62 4.    DISCLAIMER
  63
  64 This FDK AAC Codec software is provided by Fraunhofer on behalf of the copyright holders and contributors
  65 "AS IS" and WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, including but not limited to the implied warranties
  66 of merchantability and fitness for a particular purpose. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  67 CONTRIBUTORS BE LIABLE for any direct, indirect, incidental, special, exemplary, or consequential damages,
  68 including but not limited to procurement of substitute goods or services; loss of use, data, or profits,
  69 or business interruption, however caused and on any theory of liability, whether in contract, strict
  70 liability, or tort (including negligence), arising in any way out of the use of this software, even if
  71 advised of the possibility of such damage.
  72
  73 5.    CONTACT INFORMATION
  74
  75 Fraunhofer Institute for Integrated Circuits IIS
  76 Attention: Audio and Multimedia Departments - FDK AAC LL
  77 Am Wolfsmantel 33
  78 91058 Erlangen, Germany
  79
  80 www.iis.fraunhofer.de/amm
  81 amm-info@iis.fraunhofer.de
  82 ----------------------------------------------------------------------------------------------------------- */
  83
  84 /******************************** MPEG Audio Encoder **************************
  85
  86    Initial author:
  87    contents/description: CRC calculation
  88
  89 ******************************************************************************/
  90
  91 #include "FDK_crc.h"
  92
  93
  94
  95 /*---------------- constants -----------------------*/
  96
  97 /**
  98  * \brief  This table defines precalculated lookup tables for crc polynom  x^16 + x^15 + x^2 + x^0.
  99  */
 100 static const USHORT crcLookup_16_15_2_0[256] =
 101 {
 102   0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
 103   0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
 104   0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
 105   0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
 106   0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
 107   0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
 108   0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
 109   0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
 110   0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
 111   0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
 112   0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
 113   0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
 114   0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
 115   0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
 116   0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
 117   0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
 118   0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
 119   0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
 120   0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
 121   0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
 122   0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
 123   0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
 124   0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
 125   0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
 126   0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
 127   0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
 128   0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
 129   0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
 130   0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
 131   0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
 132   0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
 133   0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202
 134 };
 135
 136 /**
 137  * \brief  This table defines precalculated lookup tables for crc polynom  x^16 + x^12 + x^5 + x^0.
 138  */
 139 static const USHORT crcLookup_16_12_5_0[256] =
 140 {
 141   0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
 142   0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
 143   0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
 144   0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
 145   0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
 146   0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
 147   0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
 148   0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
 149   0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
 150   0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
 151   0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
 152   0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
 153   0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
 154   0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
 155   0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
 156   0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
 157   0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
 158   0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
 159   0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
 160   0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
 161   0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
 162   0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
 163   0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
 164   0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
 165   0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
 166   0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
 167   0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
 168   0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
 169   0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
 170   0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
 171   0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
 172   0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
 173 };
 174
 175
 176 /*--------------- function declarations --------------------*/
 177
 178 static inline INT calcCrc_Bits(
 179         USHORT * const                  pCrc,
 180         USHORT                          crcMask,
 181         USHORT                          crcPoly,
 182         HANDLE_FDK_BITSTREAM            hBs,
 183         INT                             nBits
 184         );
 185
 186 static inline INT calcCrc_Bytes(
 187         USHORT * const                  pCrc,
 188         const USHORT *                  pCrcLookup,
 189         HANDLE_FDK_BITSTREAM            hBs,
 190         INT                             nBytes
 191         );
 192
 193 static void crcCalc(
 194         HANDLE_FDK_CRCINFO              hCrcInfo,
 195         HANDLE_FDK_BITSTREAM            hBs,
 196         const INT                       reg
 197         );
 198
 199
 200 /*------------- function definitions ----------------*/
 201
 202 void FDKcrcInit(
 203         HANDLE_FDK_CRCINFO              hCrcInfo,
 204         const UINT                      crcPoly,
 205         const UINT                      crcStartValue,
 206         const UINT                      crcLen
 207         )
 208 {
 209   /* crc polynom example:
 210   x^16 + x^15 + x^2 + x^0        (1) 1000 0000 0000 0101 -> 0x8005
 211   x^16 + x^12 + x^5 + x^0        (1) 0001 0000 0010 0001 -> 0x1021
 212   x^8 + x^4 + x^3 + x^2 + x^0              (1) 0001 1101 -> 0x001d */
 213
 214   hCrcInfo->crcLen     = crcLen;
 215   hCrcInfo->crcPoly    = crcPoly;
 216   hCrcInfo->startValue = crcStartValue;
 217   hCrcInfo->crcMask    = (crcLen) ? (1<<(crcLen-1)) : 0;
 218
 219   FDKcrcReset(hCrcInfo);
 220
 221   hCrcInfo->pCrcLookup = 0;
 222
 223   if (hCrcInfo->crcLen==16) {
 224     switch ( crcPoly ) {
 225       case 0x8005:
 226         hCrcInfo->pCrcLookup = crcLookup_16_15_2_0;
 227         break;
 228       case 0x1021:
 229         hCrcInfo->pCrcLookup = crcLookup_16_12_5_0;
 230         break;
 231       case 0x001d:
 232       default:
 233         /* no lookup table */
 234         hCrcInfo->pCrcLookup = 0;
 235     }
 236   }
 237
 238
 239 }
 240
 241 void FDKcrcReset(HANDLE_FDK_CRCINFO hCrcInfo)
 242 {
 243   int i;
 244
 245   hCrcInfo->crcValue = hCrcInfo->startValue;
 246
 247   for(i=0;i<MAX_CRC_REGS;i++) {
 248     hCrcInfo->crcRegData[i].isActive = 0;
 249   }
 250   hCrcInfo->regStart = 0;
 251   hCrcInfo->regStop  = 0;
 252 }
 253
 254 INT FDKcrcStartReg(
 255         HANDLE_FDK_CRCINFO              hCrcInfo,
 256         const HANDLE_FDK_BITSTREAM      hBs,
 257         const INT                       mBits
 258         )
 259 {
 260   int reg = hCrcInfo->regStart;
 261
 262   FDK_ASSERT(hCrcInfo->crcRegData[reg].isActive==0);
 263   hCrcInfo->crcRegData[reg].isActive      = 1;
 264   hCrcInfo->crcRegData[reg].maxBits       = mBits;
 265   hCrcInfo->crcRegData[reg].validBits     = FDKgetValidBits(hBs) ;
 266   hCrcInfo->crcRegData[reg].bitBufCntBits = 0;
 267
 268   hCrcInfo->regStart = (hCrcInfo->regStart+1)%MAX_CRC_REGS;
 269
 270   return (reg);
 271 }
 272
 273 INT FDKcrcEndReg(
 274         HANDLE_FDK_CRCINFO              hCrcInfo,
 275         const HANDLE_FDK_BITSTREAM      hBs,
 276         const INT                       reg
 277         )
 278 {
 279   FDK_ASSERT((reg==(INT)hCrcInfo->regStop)&&(hCrcInfo->crcRegData[reg].isActive==1));
 280
 281   if (hBs->ConfigCache==BS_WRITER) {
 282     hCrcInfo->crcRegData[reg].bitBufCntBits = FDKgetValidBits(hBs) - hCrcInfo->crcRegData[reg].validBits;
 283   }
 284   else {
 285     hCrcInfo->crcRegData[reg].bitBufCntBits = hCrcInfo->crcRegData[reg].validBits - FDKgetValidBits(hBs);
 286   }
 287
 288   if (hCrcInfo->crcRegData[reg].maxBits == 0) {
 289     hCrcInfo->crcRegData[reg].maxBits = hCrcInfo->crcRegData[reg].bitBufCntBits;
 290   }
 291
 292   crcCalc( hCrcInfo, hBs, reg);
 293
 294   hCrcInfo->crcRegData[reg].isActive = 0;
 295   hCrcInfo->regStop = (hCrcInfo->regStop+1)%MAX_CRC_REGS;
 296
 297   return 0;
 298 }
 299
 300 USHORT FDKcrcGetCRC(
 301         const HANDLE_FDK_CRCINFO        hCrcInfo
 302         )
 303 {
 304   return ( hCrcInfo->crcValue & (((hCrcInfo->crcMask-1)<<1)+1) );
 305 }
 306
 307 /**
 308  * \brief  Calculate crc bits.
 309  *
 310  * Calculate crc starting at current bitstream postion over nBits.
 311  *
 312  * \param pCrc                  Pointer to an outlying allocated crc info structure.
 313  * \param crcMask               CrcMask in use.
 314  * \param crcPoly               Crc polynom in use.
 315  * \param hBs                   Handle to current bit buffer structure.
 316  * \param nBits                 Number of processing bits.
 317  *
 318  * \return  Number of processed bits.
 319  */
 320 static inline INT calcCrc_Bits(
 321         USHORT * const                  pCrc,
 322         USHORT                          crcMask,
 323         USHORT                          crcPoly,
 324         HANDLE_FDK_BITSTREAM            hBs,
 325         INT                             nBits
 326         )
 327 {
 328   int i;
 329   USHORT crc = *pCrc; /* get crc value */
 330
 331   if (hBs!=NULL) {
 332     for (i = 0; (i < nBits); i++) {
 333       USHORT tmp = FDKreadBits(hBs,1);     // process single bit
 334       tmp ^= ( (crc & crcMask) ? 1 : 0 );
 335       tmp *= crcPoly;
 336       crc <<= 1;
 337       crc ^= tmp;
 338     }
 339   }
 340   else {
 341     for (i = 0; (i < nBits); i++) {
 342       USHORT tmp = 0;     // process single bit
 343       tmp ^= ( (crc & crcMask) ? 1 : 0 );
 344       tmp *= crcPoly;
 345       crc <<= 1;
 346       crc ^= tmp;
 347     }
 348   }
 349   *pCrc = crc; /* update crc value */
 350
 351   return nBits;
 352 }
 353
 354 /**
 355  * \brief  Calculate crc bytes.
 356  *
 357  * Calculate crc starting at current bitstream postion over nBytes.
 358  *
 359  * \param pCrc                  Pointer to an outlying allocated crc info structure.
 360  * \param pCrcLookup            Pointer to lookup table used for fast crc calculation.
 361  * \param hBs                   Handle to current bit buffer structure.
 362  * \param nBits                 Number of processing bytes.
 363  *
 364  * \return  Number of processed bits.
 365  */
 366 static inline INT calcCrc_Bytes(
 367         USHORT * const                  pCrc,
 368         const USHORT *                  pCrcLookup,
 369         HANDLE_FDK_BITSTREAM            hBs,
 370         INT                             nBytes
 371         )
 372 {
 373   int i;
 374   USHORT crc = *pCrc; /* get crc value */
 375
 376   if (hBs!=NULL) {
 377     for (i=0; i<nBytes; i++) {
 378       crc = (crc<<8)^pCrcLookup[((crc>>8)^((UCHAR)FDKreadBits(hBs,8)))&0xFF];
 379     }
 380   }
 381   else {
 382     for (i=0; i<nBytes; i++) {
 383       crc = (crc<<8)^pCrcLookup[((crc>>8)^((UCHAR)0))&0xFF];
 384     }
 385   }
 386
 387   *pCrc = crc; /* update crc value */
 388
 389   return (i);
 390 }
 391
 392 /**
 393  * \brief  Calculate crc.
 394  *
 395  * Calculate crc. Lenght depends on mBits parameter in FDKcrcStartReg() configuration.
 396  *
 397  * \param hCrcInfo              Pointer to an outlying allocated crc info structure.
 398  * \param hBs                   Pointer to current bit buffer structure.
 399  * \param reg                   Crc region ID.
 400  *
 401  * \return  Number of processed bits.
 402  */
 403 static void crcCalc(
 404         HANDLE_FDK_CRCINFO              hCrcInfo,
 405         HANDLE_FDK_BITSTREAM            hBs,
 406         const INT                       reg
 407         )
 408 {
 409   USHORT crc = hCrcInfo->crcValue;
 410   CCrcRegData *rD = &hCrcInfo->crcRegData[reg];
 411   FDK_BITSTREAM bsReader;
 412
 413   if (hBs->ConfigCache==BS_READER) {
 414     bsReader = *hBs;
 415     FDKpushBiDirectional(&bsReader, -(INT)(rD->validBits-FDKgetValidBits(&bsReader)));
 416   }
 417   else {
 418     FDKinitBitStream(&bsReader, hBs->hBitBuf.Buffer, hBs->hBitBuf.bufSize, hBs->hBitBuf.ValidBits, BS_READER);
 419     FDKpushBiDirectional(&bsReader, rD->validBits);
 420   }
 421
 422   int bits, rBits;
 423   rBits = (rD->maxBits>=0) ? rD->maxBits : -rD->maxBits; /* ramaining bits */
 424   if ((rD->maxBits>0) && (((INT)rD->bitBufCntBits>>3<<3)<rBits) ) {
 425     bits = rD->bitBufCntBits;
 426   }
 427   else {
 428     bits = rBits;
 429   }
 430
 431   int words = bits >> 3;  /* processing bytes */
 432   int mBits = bits & 0x7; /* modulo bits */
 433
 434   if(hCrcInfo->pCrcLookup) {
 435     rBits -= (calcCrc_Bytes(&crc, hCrcInfo->pCrcLookup, &bsReader, words)<<3);
 436   }
 437   else {
 438     rBits -= calcCrc_Bits(&crc, hCrcInfo->crcMask, hCrcInfo->crcPoly, &bsReader, words<<3 );
 439   }
 440
 441   /* remaining valid bits*/
 442   if(mBits!=0) {
 443     rBits -= calcCrc_Bits(&crc, hCrcInfo->crcMask, hCrcInfo->crcPoly, &bsReader, mBits );
 444   }
 445
 446   if (rBits!=0) {
 447     /* zero bytes */
 448     if ( (hCrcInfo->pCrcLookup) && (rBits>8) ) {
 449       rBits -= (calcCrc_Bytes(&crc, hCrcInfo->pCrcLookup, NULL, rBits>>3)<<3);
 450     }
 451     /* remaining zero bits */
 452     if (rBits!=0) {
 453       rBits -= calcCrc_Bits(&crc, hCrcInfo->crcMask, hCrcInfo->crcPoly, NULL, rBits );
 454     }
 455   }
 456
 457   hCrcInfo->crcValue = crc;
 458 }
 459