/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 | } |