Coverage Report

Created: 2022-08-24 06:15

/src/aom/av1/encoder/hash.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
#include "av1/encoder/hash.h"
13
14
static void crc_calculator_process_data(CRC_CALCULATOR *p_crc_calculator,
15
0
                                        uint8_t *pData, uint32_t dataLength) {
16
0
  for (uint32_t i = 0; i < dataLength; i++) {
17
0
    const uint8_t index = (uint8_t)(
18
0
        (p_crc_calculator->remainder >> (p_crc_calculator->bits - 8)) ^
19
0
        pData[i]);
20
0
    p_crc_calculator->remainder <<= 8;
21
0
    p_crc_calculator->remainder ^= p_crc_calculator->table[index];
22
0
  }
23
0
}
24
25
0
static void crc_calculator_reset(CRC_CALCULATOR *p_crc_calculator) {
26
0
  p_crc_calculator->remainder = 0;
27
0
}
28
29
0
static uint32_t crc_calculator_get_crc(CRC_CALCULATOR *p_crc_calculator) {
30
0
  return p_crc_calculator->remainder & p_crc_calculator->final_result_mask;
31
0
}
32
33
0
static void crc_calculator_init_table(CRC_CALCULATOR *p_crc_calculator) {
34
0
  const uint32_t high_bit = 1 << (p_crc_calculator->bits - 1);
35
0
  const uint32_t byte_high_bit = 1 << (8 - 1);
36
37
0
  for (uint32_t value = 0; value < 256; value++) {
38
0
    uint32_t remainder = 0;
39
0
    for (uint8_t mask = byte_high_bit; mask != 0; mask >>= 1) {
40
0
      if (value & mask) {
41
0
        remainder ^= high_bit;
42
0
      }
43
44
0
      if (remainder & high_bit) {
45
0
        remainder <<= 1;
46
0
        remainder ^= p_crc_calculator->trunc_poly;
47
0
      } else {
48
0
        remainder <<= 1;
49
0
      }
50
0
    }
51
0
    p_crc_calculator->table[value] = remainder;
52
0
  }
53
0
}
54
55
void av1_crc_calculator_init(CRC_CALCULATOR *p_crc_calculator, uint32_t bits,
56
0
                             uint32_t truncPoly) {
57
0
  p_crc_calculator->remainder = 0;
58
0
  p_crc_calculator->bits = bits;
59
0
  p_crc_calculator->trunc_poly = truncPoly;
60
0
  p_crc_calculator->final_result_mask = (1 << bits) - 1;
61
0
  crc_calculator_init_table(p_crc_calculator);
62
0
}
63
64
uint32_t av1_get_crc_value(CRC_CALCULATOR *p_crc_calculator, uint8_t *p,
65
0
                           int length) {
66
0
  crc_calculator_reset(p_crc_calculator);
67
0
  crc_calculator_process_data(p_crc_calculator, p, length);
68
0
  return crc_calculator_get_crc(p_crc_calculator);
69
0
}
70
71
/* CRC-32C (iSCSI) polynomial in reversed bit order. */
72
0
#define POLY 0x82f63b78
73
74
/* Construct table for software CRC-32C calculation. */
75
0
void av1_crc32c_calculator_init(CRC32C *p_crc32c) {
76
0
  uint32_t crc;
77
78
0
  for (int n = 0; n < 256; n++) {
79
0
    crc = n;
80
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
81
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
82
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
83
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
84
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
85
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
86
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
87
0
    crc = crc & 1 ? (crc >> 1) ^ POLY : crc >> 1;
88
0
    p_crc32c->table[0][n] = crc;
89
0
  }
90
0
  for (int n = 0; n < 256; n++) {
91
0
    crc = p_crc32c->table[0][n];
92
0
    for (int k = 1; k < 8; k++) {
93
0
      crc = p_crc32c->table[0][crc & 0xff] ^ (crc >> 8);
94
0
      p_crc32c->table[k][n] = crc;
95
0
    }
96
0
  }
97
0
}
98
99
/* Table-driven software version as a fall-back.  This is about 15 times slower
100
 than using the hardware instructions.  This assumes little-endian integers,
101
 as is the case on Intel processors that the assembler code here is for. */
102
0
uint32_t av1_get_crc32c_value_c(void *c, uint8_t *buf, size_t len) {
103
0
  const uint8_t *next = (const uint8_t *)(buf);
104
0
  uint64_t crc;
105
0
  CRC32C *p = (CRC32C *)c;
106
0
  crc = 0 ^ 0xffffffff;
107
0
  while (len && ((uintptr_t)next & 7) != 0) {
108
0
    crc = p->table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
109
0
    len--;
110
0
  }
111
0
  while (len >= 8) {
112
0
    crc ^= *(uint64_t *)next;
113
0
    crc = p->table[7][crc & 0xff] ^ p->table[6][(crc >> 8) & 0xff] ^
114
0
          p->table[5][(crc >> 16) & 0xff] ^ p->table[4][(crc >> 24) & 0xff] ^
115
0
          p->table[3][(crc >> 32) & 0xff] ^ p->table[2][(crc >> 40) & 0xff] ^
116
0
          p->table[1][(crc >> 48) & 0xff] ^ p->table[0][crc >> 56];
117
0
    next += 8;
118
0
    len -= 8;
119
0
  }
120
0
  while (len) {
121
0
    crc = p->table[0][(crc ^ *next++) & 0xff] ^ (crc >> 8);
122
0
    len--;
123
0
  }
124
0
  return (uint32_t)crc ^ 0xffffffff;
125
0
}