LCOV - code coverage report
Current view: top level - libavutil - adler32.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 29 29 100.0 %
Date: 2017-12-15 02:19:58 Functions: 1 1 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Compute the Adler-32 checksum of a data stream.
       3             :  * This is a modified version based on adler32.c from the zlib library.
       4             :  *
       5             :  * Copyright (C) 1995 Mark Adler
       6             :  *
       7             :  * This software is provided 'as-is', without any express or implied
       8             :  * warranty.  In no event will the authors be held liable for any damages
       9             :  * arising from the use of this software.
      10             :  *
      11             :  * Permission is granted to anyone to use this software for any purpose,
      12             :  * including commercial applications, and to alter it and redistribute it
      13             :  * freely, subject to the following restrictions:
      14             :  *
      15             :  * 1. The origin of this software must not be misrepresented; you must not
      16             :  *    claim that you wrote the original software. If you use this software
      17             :  *    in a product, an acknowledgment in the product documentation would be
      18             :  *    appreciated but is not required.
      19             :  * 2. Altered source versions must be plainly marked as such, and must not be
      20             :  *    misrepresented as being the original software.
      21             :  * 3. This notice may not be removed or altered from any source distribution.
      22             :  */
      23             : 
      24             : /**
      25             :  * @file
      26             :  * Computes the Adler-32 checksum of a data stream
      27             :  *
      28             :  * This is a modified version based on adler32.c from the zlib library.
      29             :  * @author Mark Adler
      30             :  * @ingroup lavu_adler32
      31             :  */
      32             : 
      33             : #include "config.h"
      34             : #include "adler32.h"
      35             : #include "common.h"
      36             : #include "intreadwrite.h"
      37             : 
      38             : #define BASE 65521L /* largest prime smaller than 65536 */
      39             : 
      40             : #define DO1(buf)  { s1 += *buf++; s2 += s1; }
      41             : #define DO4(buf)  DO1(buf); DO1(buf); DO1(buf); DO1(buf);
      42             : #define DO16(buf) DO4(buf); DO4(buf); DO4(buf); DO4(buf);
      43             : 
      44       86254 : unsigned long av_adler32_update(unsigned long adler, const uint8_t * buf,
      45             :                                 unsigned int len)
      46             : {
      47       86254 :     unsigned long s1 = adler & 0xffff;
      48       86254 :     unsigned long s2 = adler >> 16;
      49             : 
      50   123639311 :     while (len > 0) {
      51             : #if HAVE_FAST_64BIT && HAVE_FAST_UNALIGNED && !CONFIG_SMALL
      52   123466803 :         unsigned len2 = FFMIN((len-1) & ~7, 23*8);
      53   123466803 :         if (len2) {
      54   123187732 :             uint64_t a1= 0;
      55   123187732 :             uint64_t a2= 0;
      56   123187732 :             uint64_t b1= 0;
      57   123187732 :             uint64_t b2= 0;
      58   123187732 :             len -= len2;
      59   123187732 :             s2 += s1*len2;
      60  3078737384 :             while (len2 >= 8) {
      61  2832361920 :                 uint64_t v = AV_RN64(buf);
      62  2832361920 :                 a2 += a1;
      63  2832361920 :                 b2 += b1;
      64  2832361920 :                 a1 +=  v    &0x00FF00FF00FF00FF;
      65  2832361920 :                 b1 += (v>>8)&0x00FF00FF00FF00FF;
      66  2832361920 :                 len2 -= 8;
      67  2832361920 :                 buf+=8;
      68             :             }
      69             : 
      70             :             //We combine the 8 interleaved adler32 checksums without overflows
      71             :             //Decreasing the number of iterations would allow below code to be
      72             :             //simplified but would likely be slower due to the fewer iterations
      73             :             //of the inner loop
      74   123187732 :             s1 += ((a1+b1)*0x1000100010001)>>48;
      75   246375464 :             s2 += ((((a2&0xFFFF0000FFFF)+(b2&0xFFFF0000FFFF)+((a2>>16)&0xFFFF0000FFFF)+((b2>>16)&0xFFFF0000FFFF))*0x800000008)>>32)
      76             : #if HAVE_BIGENDIAN
      77             :                  + 2*((b1*0x1000200030004)>>48)
      78             :                  +   ((a1*0x1000100010001)>>48)
      79             :                  + 2*((a1*0x0000100020003)>>48);
      80             : #else
      81   123187732 :                  + 2*((a1*0x4000300020001)>>48)
      82   123187732 :                  +   ((b1*0x1000100010001)>>48)
      83   123187732 :                  + 2*((b1*0x3000200010000)>>48);
      84             : #endif
      85             :         }
      86             : #else
      87             :         while (len > 4  && s2 < (1U << 31)) {
      88             :             DO4(buf);
      89             :             len -= 4;
      90             :         }
      91             : #endif
      92   123466803 :         DO1(buf); len--;
      93   123466803 :         s1 %= BASE;
      94   123466803 :         s2 %= BASE;
      95             :     }
      96       86254 :     return (s2 << 16) | s1;
      97             : }

Generated by: LCOV version 1.13