"Fossies" - the Fresh Open Source Software Archive

Member "PDFlib-Lite-7.0.5p3/libs/flate/adler32.c" (6 Jun 2012, 4607 Bytes) of package /linux/misc/old/PDFlib-Lite-7.0.5p3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "adler32.c" see the Fossies "Dox" file reference documentation.

    1 /* adler32.c -- compute the Adler-32 checksum of a data stream
    2  * Copyright (C) 1995-2004 Mark Adler
    3  * For conditions of distribution and use, see copyright notice in zlib.h
    4  */
    5 
    6 /* $Id: adler32.c,v 1.5.2.1 2006/12/27 15:03:32 rjs Exp $ */
    7 /* @(#) $Id: adler32.c,v 1.5.2.1 2006/12/27 15:03:32 rjs Exp $ */
    8 
    9 #define ZLIB_INTERNAL
   10 #include "zlib.h"
   11 
   12 #define BASE 65521UL    /* largest prime smaller than 65536 */
   13 #define NMAX 5552
   14 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
   15 
   16 #define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
   17 #define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
   18 #define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
   19 #define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
   20 #define DO16(buf)   DO8(buf,0); DO8(buf,8);
   21 
   22 /* use NO_DIVIDE if your processor does not do division in hardware */
   23 #ifdef NO_DIVIDE
   24 #  define MOD(a) \
   25     do { \
   26         if (a >= (BASE << 16)) a -= (BASE << 16); \
   27         if (a >= (BASE << 15)) a -= (BASE << 15); \
   28         if (a >= (BASE << 14)) a -= (BASE << 14); \
   29         if (a >= (BASE << 13)) a -= (BASE << 13); \
   30         if (a >= (BASE << 12)) a -= (BASE << 12); \
   31         if (a >= (BASE << 11)) a -= (BASE << 11); \
   32         if (a >= (BASE << 10)) a -= (BASE << 10); \
   33         if (a >= (BASE << 9)) a -= (BASE << 9); \
   34         if (a >= (BASE << 8)) a -= (BASE << 8); \
   35         if (a >= (BASE << 7)) a -= (BASE << 7); \
   36         if (a >= (BASE << 6)) a -= (BASE << 6); \
   37         if (a >= (BASE << 5)) a -= (BASE << 5); \
   38         if (a >= (BASE << 4)) a -= (BASE << 4); \
   39         if (a >= (BASE << 3)) a -= (BASE << 3); \
   40         if (a >= (BASE << 2)) a -= (BASE << 2); \
   41         if (a >= (BASE << 1)) a -= (BASE << 1); \
   42         if (a >= BASE) a -= BASE; \
   43     } while (0)
   44 #  define MOD4(a) \
   45     do { \
   46         if (a >= (BASE << 4)) a -= (BASE << 4); \
   47         if (a >= (BASE << 3)) a -= (BASE << 3); \
   48         if (a >= (BASE << 2)) a -= (BASE << 2); \
   49         if (a >= (BASE << 1)) a -= (BASE << 1); \
   50         if (a >= BASE) a -= BASE; \
   51     } while (0)
   52 #else
   53 #  define MOD(a) a %= BASE
   54 #  define MOD4(a) a %= BASE
   55 #endif
   56 
   57 /* ========================================================================= */
   58 uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len)
   59 {
   60     unsigned long sum2;
   61     unsigned n;
   62 
   63     /* split Adler-32 into component sums */
   64     sum2 = (adler >> 16) & 0xffff;
   65     adler &= 0xffff;
   66 
   67     /* in case user likes doing a byte at a time, keep it fast */
   68     if (len == 1) {
   69         adler += buf[0];
   70         if (adler >= BASE)
   71             adler -= BASE;
   72         sum2 += adler;
   73         if (sum2 >= BASE)
   74             sum2 -= BASE;
   75         return adler | (sum2 << 16);
   76     }
   77 
   78     /* initial Adler-32 value (deferred check for len == 1 speed) */
   79     if (buf == Z_NULL)
   80         return 1L;
   81 
   82     /* in case short lengths are provided, keep it somewhat fast */
   83     if (len < 16) {
   84         while (len--) {
   85             adler += *buf++;
   86             sum2 += adler;
   87         }
   88         if (adler >= BASE)
   89             adler -= BASE;
   90         MOD4(sum2);             /* only added so many BASE's */
   91         return adler | (sum2 << 16);
   92     }
   93 
   94     /* do length NMAX blocks -- requires just one modulo operation */
   95     while (len >= NMAX) {
   96         len -= NMAX;
   97         n = NMAX / 16;          /* NMAX is divisible by 16 */
   98         do {
   99             DO16(buf);          /* 16 sums unrolled */
  100             buf += 16;
  101         } while (--n);
  102         MOD(adler);
  103         MOD(sum2);
  104     }
  105 
  106     /* do remaining bytes (less than NMAX, still just one modulo) */
  107     if (len) {                  /* avoid modulos if none remaining */
  108         while (len >= 16) {
  109             len -= 16;
  110             DO16(buf);
  111             buf += 16;
  112         }
  113         while (len--) {
  114             adler += *buf++;
  115             sum2 += adler;
  116         }
  117         MOD(adler);
  118         MOD(sum2);
  119     }
  120 
  121     /* return recombined sums */
  122     return adler | (sum2 << 16);
  123 }
  124 
  125 /* ========================================================================= */
  126 uLong ZEXPORT adler32_combine(uLong adler1, uLong adler2, z_off_t len2)
  127 {
  128     unsigned long sum1;
  129     unsigned long sum2;
  130     unsigned rem;
  131 
  132     /* the derivation of this formula is left as an exercise for the reader */
  133     rem = (unsigned)(len2 % BASE);
  134     sum1 = adler1 & 0xffff;
  135     sum2 = rem * sum1;
  136     MOD(sum2);
  137     sum1 += (adler2 & 0xffff) + BASE - 1;
  138     sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
  139     if (sum1 > BASE) sum1 -= BASE;
  140     if (sum1 > BASE) sum1 -= BASE;
  141     if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
  142     if (sum2 > BASE) sum2 -= BASE;
  143     return sum1 | (sum2 << 16);
  144 }