/src/aom/av1/common/txb_common.h
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) 2017, 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 | | #ifndef AOM_AV1_COMMON_TXB_COMMON_H_ |
13 | | #define AOM_AV1_COMMON_TXB_COMMON_H_ |
14 | | |
15 | | #include "av1/common/av1_common_int.h" |
16 | | |
17 | | extern const int16_t av1_eob_group_start[12]; |
18 | | extern const int16_t av1_eob_offset_bits[12]; |
19 | | |
20 | | extern const int8_t *av1_nz_map_ctx_offset[TX_SIZES_ALL]; |
21 | | |
22 | | typedef struct txb_ctx { |
23 | | int txb_skip_ctx; |
24 | | int dc_sign_ctx; |
25 | | } TXB_CTX; |
26 | | |
27 | | static const int base_level_count_to_index[13] = { |
28 | | 0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, |
29 | | }; |
30 | | |
31 | | static const TX_CLASS tx_type_to_class[TX_TYPES] = { |
32 | | TX_CLASS_2D, // DCT_DCT |
33 | | TX_CLASS_2D, // ADST_DCT |
34 | | TX_CLASS_2D, // DCT_ADST |
35 | | TX_CLASS_2D, // ADST_ADST |
36 | | TX_CLASS_2D, // FLIPADST_DCT |
37 | | TX_CLASS_2D, // DCT_FLIPADST |
38 | | TX_CLASS_2D, // FLIPADST_FLIPADST |
39 | | TX_CLASS_2D, // ADST_FLIPADST |
40 | | TX_CLASS_2D, // FLIPADST_ADST |
41 | | TX_CLASS_2D, // IDTX |
42 | | TX_CLASS_VERT, // V_DCT |
43 | | TX_CLASS_HORIZ, // H_DCT |
44 | | TX_CLASS_VERT, // V_ADST |
45 | | TX_CLASS_HORIZ, // H_ADST |
46 | | TX_CLASS_VERT, // V_FLIPADST |
47 | | TX_CLASS_HORIZ, // H_FLIPADST |
48 | | }; |
49 | | |
50 | 36.1M | static inline int get_txb_bhl(TX_SIZE tx_size) { |
51 | 36.1M | tx_size = av1_get_adjusted_tx_size(tx_size); |
52 | 36.1M | return tx_size_high_log2[tx_size]; |
53 | 36.1M | } Line | Count | Source | 50 | 36.1M | static inline int get_txb_bhl(TX_SIZE tx_size) { | 51 | 36.1M | tx_size = av1_get_adjusted_tx_size(tx_size); | 52 | 36.1M | return tx_size_high_log2[tx_size]; | 53 | 36.1M | } |
Unexecuted instantiation: entropy.c:get_txb_bhl Unexecuted instantiation: entropymode.c:get_txb_bhl Unexecuted instantiation: txb_common.c:get_txb_bhl |
54 | | |
55 | 36.9M | static inline int get_txb_wide(TX_SIZE tx_size) { |
56 | 36.9M | tx_size = av1_get_adjusted_tx_size(tx_size); |
57 | 36.9M | return tx_size_wide[tx_size]; |
58 | 36.9M | } Line | Count | Source | 55 | 36.9M | static inline int get_txb_wide(TX_SIZE tx_size) { | 56 | 36.9M | tx_size = av1_get_adjusted_tx_size(tx_size); | 57 | 36.9M | return tx_size_wide[tx_size]; | 58 | 36.9M | } |
Unexecuted instantiation: entropy.c:get_txb_wide Unexecuted instantiation: entropymode.c:get_txb_wide Unexecuted instantiation: txb_common.c:get_txb_wide |
59 | | |
60 | 35.3M | static inline int get_txb_high(TX_SIZE tx_size) { |
61 | 35.3M | tx_size = av1_get_adjusted_tx_size(tx_size); |
62 | 35.3M | return tx_size_high[tx_size]; |
63 | 35.3M | } Line | Count | Source | 60 | 35.3M | static inline int get_txb_high(TX_SIZE tx_size) { | 61 | 35.3M | tx_size = av1_get_adjusted_tx_size(tx_size); | 62 | 35.3M | return tx_size_high[tx_size]; | 63 | 35.3M | } |
Unexecuted instantiation: entropy.c:get_txb_high Unexecuted instantiation: entropymode.c:get_txb_high Unexecuted instantiation: txb_common.c:get_txb_high |
64 | | |
65 | 34.5M | static inline uint8_t *set_levels(uint8_t *const levels_buf, const int height) { |
66 | 34.5M | return levels_buf + TX_PAD_TOP * (height + TX_PAD_HOR); |
67 | 34.5M | } Line | Count | Source | 65 | 34.5M | static inline uint8_t *set_levels(uint8_t *const levels_buf, const int height) { | 66 | 34.5M | return levels_buf + TX_PAD_TOP * (height + TX_PAD_HOR); | 67 | 34.5M | } |
Unexecuted instantiation: entropy.c:set_levels Unexecuted instantiation: entropymode.c:set_levels Unexecuted instantiation: txb_common.c:set_levels |
68 | | |
69 | 786M | static inline int get_padded_idx(const int idx, const int bhl) { |
70 | 786M | return idx + ((idx >> bhl) << TX_PAD_HOR_LOG2); |
71 | 786M | } decodetxb.c:get_padded_idx Line | Count | Source | 69 | 786M | static inline int get_padded_idx(const int idx, const int bhl) { | 70 | 786M | return idx + ((idx >> bhl) << TX_PAD_HOR_LOG2); | 71 | 786M | } |
Unexecuted instantiation: entropy.c:get_padded_idx Unexecuted instantiation: entropymode.c:get_padded_idx Unexecuted instantiation: txb_common.c:get_padded_idx |
72 | | |
73 | | static inline int get_br_ctx_2d(const uint8_t *const levels, |
74 | | const int c, // raster order |
75 | 15.0M | const int bhl) { |
76 | 15.0M | assert(c > 0); |
77 | 15.0M | const int col = c >> bhl; |
78 | 15.0M | const int row = c - (col << bhl); |
79 | 15.0M | const int stride = (1 << bhl) + TX_PAD_HOR; |
80 | 15.0M | const int pos = col * stride + row; |
81 | 15.0M | int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE) + |
82 | 15.0M | AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE) + |
83 | 15.0M | AOMMIN(levels[pos + 1 + stride], MAX_BASE_BR_RANGE); |
84 | 15.0M | mag = AOMMIN((mag + 1) >> 1, 6); |
85 | | //((row | col) < 2) is equivalent to ((row < 2) && (col < 2)) |
86 | 15.0M | if ((row | col) < 2) return mag + 7; |
87 | 11.6M | return mag + 14; |
88 | 15.0M | } decodetxb.c:get_br_ctx_2d Line | Count | Source | 75 | 15.0M | const int bhl) { | 76 | 15.0M | assert(c > 0); | 77 | 15.0M | const int col = c >> bhl; | 78 | 15.0M | const int row = c - (col << bhl); | 79 | 15.0M | const int stride = (1 << bhl) + TX_PAD_HOR; | 80 | 15.0M | const int pos = col * stride + row; | 81 | 15.0M | int mag = AOMMIN(levels[pos + 1], MAX_BASE_BR_RANGE) + | 82 | 15.0M | AOMMIN(levels[pos + stride], MAX_BASE_BR_RANGE) + | 83 | 15.0M | AOMMIN(levels[pos + 1 + stride], MAX_BASE_BR_RANGE); | 84 | 15.0M | mag = AOMMIN((mag + 1) >> 1, 6); | 85 | | //((row | col) < 2) is equivalent to ((row < 2) && (col < 2)) | 86 | 15.0M | if ((row | col) < 2) return mag + 7; | 87 | 11.6M | return mag + 14; | 88 | 15.0M | } |
Unexecuted instantiation: entropy.c:get_br_ctx_2d Unexecuted instantiation: entropymode.c:get_br_ctx_2d Unexecuted instantiation: txb_common.c:get_br_ctx_2d |
89 | | |
90 | | static AOM_FORCE_INLINE int get_br_ctx_eob(const int c, // raster order |
91 | | const int bhl, |
92 | 660k | const TX_CLASS tx_class) { |
93 | 660k | const int col = c >> bhl; |
94 | 660k | const int row = c - (col << bhl); |
95 | 660k | if (c == 0) return 0; |
96 | 263k | if ((tx_class == TX_CLASS_2D && row < 2 && col < 2) || |
97 | 263k | (tx_class == TX_CLASS_HORIZ && col == 0) || |
98 | 263k | (tx_class == TX_CLASS_VERT && row == 0)) |
99 | 19.8k | return 7; |
100 | 243k | return 14; |
101 | 263k | } decodetxb.c:get_br_ctx_eob Line | Count | Source | 92 | 660k | const TX_CLASS tx_class) { | 93 | 660k | const int col = c >> bhl; | 94 | 660k | const int row = c - (col << bhl); | 95 | 660k | if (c == 0) return 0; | 96 | 263k | if ((tx_class == TX_CLASS_2D && row < 2 && col < 2) || | 97 | 263k | (tx_class == TX_CLASS_HORIZ && col == 0) || | 98 | 263k | (tx_class == TX_CLASS_VERT && row == 0)) | 99 | 19.8k | return 7; | 100 | 243k | return 14; | 101 | 263k | } |
Unexecuted instantiation: entropy.c:get_br_ctx_eob Unexecuted instantiation: entropymode.c:get_br_ctx_eob Unexecuted instantiation: txb_common.c:get_br_ctx_eob |
102 | | |
103 | | static AOM_FORCE_INLINE int get_br_ctx(const uint8_t *const levels, |
104 | | const int c, // raster order |
105 | 4.94M | const int bhl, const TX_CLASS tx_class) { |
106 | 4.94M | const int col = c >> bhl; |
107 | 4.94M | const int row = c - (col << bhl); |
108 | 4.94M | const int stride = (1 << bhl) + TX_PAD_HOR; |
109 | 4.94M | const int pos = col * stride + row; |
110 | 4.94M | int mag = levels[pos + 1]; |
111 | 4.94M | mag += levels[pos + stride]; |
112 | 4.94M | switch (tx_class) { |
113 | 3.94M | case TX_CLASS_2D: |
114 | 3.94M | mag += levels[pos + stride + 1]; |
115 | 3.94M | mag = AOMMIN((mag + 1) >> 1, 6); |
116 | 3.94M | if (c == 0) return mag; |
117 | 18.4E | if ((row < 2) && (col < 2)) return mag + 7; |
118 | 18.4E | break; |
119 | 18.4E | case TX_CLASS_HORIZ: |
120 | 698k | mag += levels[pos + (stride << 1)]; |
121 | 698k | mag = AOMMIN((mag + 1) >> 1, 6); |
122 | 698k | if (c == 0) return mag; |
123 | 629k | if (col == 0) return mag + 7; |
124 | 338k | break; |
125 | 338k | case TX_CLASS_VERT: |
126 | 309k | mag += levels[pos + 2]; |
127 | 309k | mag = AOMMIN((mag + 1) >> 1, 6); |
128 | 309k | if (c == 0) return mag; |
129 | 277k | if (row == 0) return mag + 7; |
130 | 138k | break; |
131 | 138k | default: break; |
132 | 4.94M | } |
133 | | |
134 | 477k | return mag + 14; |
135 | 4.94M | } Line | Count | Source | 105 | 4.94M | const int bhl, const TX_CLASS tx_class) { | 106 | 4.94M | const int col = c >> bhl; | 107 | 4.94M | const int row = c - (col << bhl); | 108 | 4.94M | const int stride = (1 << bhl) + TX_PAD_HOR; | 109 | 4.94M | const int pos = col * stride + row; | 110 | 4.94M | int mag = levels[pos + 1]; | 111 | 4.94M | mag += levels[pos + stride]; | 112 | 4.94M | switch (tx_class) { | 113 | 3.94M | case TX_CLASS_2D: | 114 | 3.94M | mag += levels[pos + stride + 1]; | 115 | 3.94M | mag = AOMMIN((mag + 1) >> 1, 6); | 116 | 3.94M | if (c == 0) return mag; | 117 | 18.4E | if ((row < 2) && (col < 2)) return mag + 7; | 118 | 18.4E | break; | 119 | 18.4E | case TX_CLASS_HORIZ: | 120 | 698k | mag += levels[pos + (stride << 1)]; | 121 | 698k | mag = AOMMIN((mag + 1) >> 1, 6); | 122 | 698k | if (c == 0) return mag; | 123 | 629k | if (col == 0) return mag + 7; | 124 | 338k | break; | 125 | 338k | case TX_CLASS_VERT: | 126 | 309k | mag += levels[pos + 2]; | 127 | 309k | mag = AOMMIN((mag + 1) >> 1, 6); | 128 | 309k | if (c == 0) return mag; | 129 | 277k | if (row == 0) return mag + 7; | 130 | 138k | break; | 131 | 138k | default: break; | 132 | 4.94M | } | 133 | | | 134 | 477k | return mag + 14; | 135 | 4.94M | } |
Unexecuted instantiation: entropy.c:get_br_ctx Unexecuted instantiation: entropymode.c:get_br_ctx Unexecuted instantiation: txb_common.c:get_br_ctx |
136 | | |
137 | | static const uint8_t clip_max3[256] = { |
138 | | 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
139 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
140 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
141 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
142 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
143 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
144 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
145 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
146 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, |
147 | | 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 |
148 | | }; |
149 | | |
150 | | static AOM_FORCE_INLINE int get_nz_mag(const uint8_t *const levels, |
151 | 30.4M | const int bhl, const TX_CLASS tx_class) { |
152 | 30.4M | int mag; |
153 | | |
154 | | // Note: AOMMIN(level, 3) is useless for decoder since level < 3. |
155 | 30.4M | mag = clip_max3[levels[(1 << bhl) + TX_PAD_HOR]]; // { 0, 1 } |
156 | 30.4M | mag += clip_max3[levels[1]]; // { 1, 0 } |
157 | | |
158 | 30.4M | if (tx_class == TX_CLASS_2D) { |
159 | 10.9M | mag += clip_max3[levels[(1 << bhl) + TX_PAD_HOR + 1]]; // { 1, 1 } |
160 | 10.9M | mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 } |
161 | 10.9M | mag += clip_max3[levels[2]]; // { 2, 0 } |
162 | 19.4M | } else if (tx_class == TX_CLASS_VERT) { |
163 | 6.19M | mag += clip_max3[levels[2]]; // { 2, 0 } |
164 | 6.19M | mag += clip_max3[levels[3]]; // { 3, 0 } |
165 | 6.19M | mag += clip_max3[levels[4]]; // { 4, 0 } |
166 | 13.3M | } else { |
167 | 13.3M | mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 } |
168 | 13.3M | mag += clip_max3[levels[(3 << bhl) + (3 << TX_PAD_HOR_LOG2)]]; // { 0, 3 } |
169 | 13.3M | mag += clip_max3[levels[(4 << bhl) + (4 << TX_PAD_HOR_LOG2)]]; // { 0, 4 } |
170 | 13.3M | } |
171 | | |
172 | 30.4M | return mag; |
173 | 30.4M | } Line | Count | Source | 151 | 30.4M | const int bhl, const TX_CLASS tx_class) { | 152 | 30.4M | int mag; | 153 | | | 154 | | // Note: AOMMIN(level, 3) is useless for decoder since level < 3. | 155 | 30.4M | mag = clip_max3[levels[(1 << bhl) + TX_PAD_HOR]]; // { 0, 1 } | 156 | 30.4M | mag += clip_max3[levels[1]]; // { 1, 0 } | 157 | | | 158 | 30.4M | if (tx_class == TX_CLASS_2D) { | 159 | 10.9M | mag += clip_max3[levels[(1 << bhl) + TX_PAD_HOR + 1]]; // { 1, 1 } | 160 | 10.9M | mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 } | 161 | 10.9M | mag += clip_max3[levels[2]]; // { 2, 0 } | 162 | 19.4M | } else if (tx_class == TX_CLASS_VERT) { | 163 | 6.19M | mag += clip_max3[levels[2]]; // { 2, 0 } | 164 | 6.19M | mag += clip_max3[levels[3]]; // { 3, 0 } | 165 | 6.19M | mag += clip_max3[levels[4]]; // { 4, 0 } | 166 | 13.3M | } else { | 167 | 13.3M | mag += clip_max3[levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)]]; // { 0, 2 } | 168 | 13.3M | mag += clip_max3[levels[(3 << bhl) + (3 << TX_PAD_HOR_LOG2)]]; // { 0, 3 } | 169 | 13.3M | mag += clip_max3[levels[(4 << bhl) + (4 << TX_PAD_HOR_LOG2)]]; // { 0, 4 } | 170 | 13.3M | } | 171 | | | 172 | 30.4M | return mag; | 173 | 30.4M | } |
Unexecuted instantiation: entropy.c:get_nz_mag Unexecuted instantiation: entropymode.c:get_nz_mag Unexecuted instantiation: txb_common.c:get_nz_mag |
174 | | |
175 | | #define NZ_MAP_CTX_0 SIG_COEF_CONTEXTS_2D |
176 | | #define NZ_MAP_CTX_5 (NZ_MAP_CTX_0 + 5) |
177 | | #define NZ_MAP_CTX_10 (NZ_MAP_CTX_0 + 10) |
178 | | |
179 | | static const int nz_map_ctx_offset_1d[32] = { |
180 | | NZ_MAP_CTX_0, NZ_MAP_CTX_5, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
181 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
182 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
183 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
184 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
185 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
186 | | NZ_MAP_CTX_10, NZ_MAP_CTX_10, |
187 | | }; |
188 | | |
189 | | static AOM_FORCE_INLINE int get_nz_map_ctx_from_stats( |
190 | | const int stats, |
191 | | const int coeff_idx, // raster order |
192 | 30.4M | const int bhl, const TX_SIZE tx_size, const TX_CLASS tx_class) { |
193 | | // tx_class == 0(TX_CLASS_2D) |
194 | 30.4M | if ((tx_class | coeff_idx) == 0) return 0; |
195 | 19.5M | int ctx = (stats + 1) >> 1; |
196 | 19.5M | ctx = AOMMIN(ctx, 4); |
197 | 19.5M | switch (tx_class) { |
198 | 0 | case TX_CLASS_2D: { |
199 | | // This is the algorithm to generate av1_nz_map_ctx_offset[][] |
200 | | // const int width = tx_size_wide[tx_size]; |
201 | | // const int height = tx_size_high[tx_size]; |
202 | | // if (width < height) { |
203 | | // if (row < 2) return 11 + ctx; |
204 | | // } else if (width > height) { |
205 | | // if (col < 2) return 16 + ctx; |
206 | | // } |
207 | | // if (row + col < 2) return ctx + 1; |
208 | | // if (row + col < 4) return 5 + ctx + 1; |
209 | | // return 21 + ctx; |
210 | 0 | return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx]; |
211 | 0 | } |
212 | 13.3M | case TX_CLASS_HORIZ: { |
213 | 13.3M | const int col = coeff_idx >> bhl; |
214 | 13.3M | return ctx + nz_map_ctx_offset_1d[col]; |
215 | 0 | } |
216 | 6.19M | case TX_CLASS_VERT: { |
217 | 6.19M | const int col = coeff_idx >> bhl; |
218 | 6.19M | const int row = coeff_idx - (col << bhl); |
219 | 6.19M | return ctx + nz_map_ctx_offset_1d[row]; |
220 | 0 | } |
221 | 0 | default: break; |
222 | 19.5M | } |
223 | 0 | return 0; |
224 | 19.5M | } decodetxb.c:get_nz_map_ctx_from_stats Line | Count | Source | 192 | 30.4M | const int bhl, const TX_SIZE tx_size, const TX_CLASS tx_class) { | 193 | | // tx_class == 0(TX_CLASS_2D) | 194 | 30.4M | if ((tx_class | coeff_idx) == 0) return 0; | 195 | 19.5M | int ctx = (stats + 1) >> 1; | 196 | 19.5M | ctx = AOMMIN(ctx, 4); | 197 | 19.5M | switch (tx_class) { | 198 | 0 | case TX_CLASS_2D: { | 199 | | // This is the algorithm to generate av1_nz_map_ctx_offset[][] | 200 | | // const int width = tx_size_wide[tx_size]; | 201 | | // const int height = tx_size_high[tx_size]; | 202 | | // if (width < height) { | 203 | | // if (row < 2) return 11 + ctx; | 204 | | // } else if (width > height) { | 205 | | // if (col < 2) return 16 + ctx; | 206 | | // } | 207 | | // if (row + col < 2) return ctx + 1; | 208 | | // if (row + col < 4) return 5 + ctx + 1; | 209 | | // return 21 + ctx; | 210 | 0 | return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx]; | 211 | 0 | } | 212 | 13.3M | case TX_CLASS_HORIZ: { | 213 | 13.3M | const int col = coeff_idx >> bhl; | 214 | 13.3M | return ctx + nz_map_ctx_offset_1d[col]; | 215 | 0 | } | 216 | 6.19M | case TX_CLASS_VERT: { | 217 | 6.19M | const int col = coeff_idx >> bhl; | 218 | 6.19M | const int row = coeff_idx - (col << bhl); | 219 | 6.19M | return ctx + nz_map_ctx_offset_1d[row]; | 220 | 0 | } | 221 | 0 | default: break; | 222 | 19.5M | } | 223 | 0 | return 0; | 224 | 19.5M | } |
Unexecuted instantiation: entropy.c:get_nz_map_ctx_from_stats Unexecuted instantiation: entropymode.c:get_nz_map_ctx_from_stats Unexecuted instantiation: txb_common.c:get_nz_map_ctx_from_stats |
225 | | |
226 | | typedef aom_cdf_prob (*base_cdf_arr)[CDF_SIZE(4)]; |
227 | | typedef aom_cdf_prob (*br_cdf_arr)[CDF_SIZE(BR_CDF_SIZE)]; |
228 | | |
229 | 21.7M | static inline int get_lower_levels_ctx_eob(int bhl, int width, int scan_idx) { |
230 | 21.7M | if (scan_idx == 0) return 0; |
231 | 11.9M | if (scan_idx <= (width << bhl) / 8) return 1; |
232 | 6.49M | if (scan_idx <= (width << bhl) / 4) return 2; |
233 | 4.74M | return 3; |
234 | 6.49M | } decodetxb.c:get_lower_levels_ctx_eob Line | Count | Source | 229 | 21.7M | static inline int get_lower_levels_ctx_eob(int bhl, int width, int scan_idx) { | 230 | 21.7M | if (scan_idx == 0) return 0; | 231 | 11.9M | if (scan_idx <= (width << bhl) / 8) return 1; | 232 | 6.49M | if (scan_idx <= (width << bhl) / 4) return 2; | 233 | 4.74M | return 3; | 234 | 6.49M | } |
Unexecuted instantiation: entropy.c:get_lower_levels_ctx_eob Unexecuted instantiation: entropymode.c:get_lower_levels_ctx_eob Unexecuted instantiation: txb_common.c:get_lower_levels_ctx_eob |
235 | | |
236 | | static inline int get_lower_levels_ctx_2d(const uint8_t *levels, int coeff_idx, |
237 | 224M | int bhl, TX_SIZE tx_size) { |
238 | 224M | assert(coeff_idx > 0); |
239 | 224M | int mag; |
240 | | // Note: AOMMIN(level, 3) is useless for decoder since level < 3. |
241 | 224M | levels = levels + get_padded_idx(coeff_idx, bhl); |
242 | 224M | mag = AOMMIN(levels[(1 << bhl) + TX_PAD_HOR], 3); // { 0, 1 } |
243 | 224M | mag += AOMMIN(levels[1], 3); // { 1, 0 } |
244 | 224M | mag += AOMMIN(levels[(1 << bhl) + TX_PAD_HOR + 1], 3); // { 1, 1 } |
245 | 224M | mag += AOMMIN(levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)], 3); // { 0, 2 } |
246 | 224M | mag += AOMMIN(levels[2], 3); // { 2, 0 } |
247 | | |
248 | 224M | const int ctx = AOMMIN((mag + 1) >> 1, 4); |
249 | 224M | return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx]; |
250 | 224M | } decodetxb.c:get_lower_levels_ctx_2d Line | Count | Source | 237 | 224M | int bhl, TX_SIZE tx_size) { | 238 | 224M | assert(coeff_idx > 0); | 239 | 224M | int mag; | 240 | | // Note: AOMMIN(level, 3) is useless for decoder since level < 3. | 241 | 224M | levels = levels + get_padded_idx(coeff_idx, bhl); | 242 | 224M | mag = AOMMIN(levels[(1 << bhl) + TX_PAD_HOR], 3); // { 0, 1 } | 243 | 224M | mag += AOMMIN(levels[1], 3); // { 1, 0 } | 244 | 224M | mag += AOMMIN(levels[(1 << bhl) + TX_PAD_HOR + 1], 3); // { 1, 1 } | 245 | 224M | mag += AOMMIN(levels[(2 << bhl) + (2 << TX_PAD_HOR_LOG2)], 3); // { 0, 2 } | 246 | 224M | mag += AOMMIN(levels[2], 3); // { 2, 0 } | 247 | | | 248 | 224M | const int ctx = AOMMIN((mag + 1) >> 1, 4); | 249 | 224M | return ctx + av1_nz_map_ctx_offset[tx_size][coeff_idx]; | 250 | 224M | } |
Unexecuted instantiation: entropy.c:get_lower_levels_ctx_2d Unexecuted instantiation: entropymode.c:get_lower_levels_ctx_2d Unexecuted instantiation: txb_common.c:get_lower_levels_ctx_2d |
251 | | static AOM_FORCE_INLINE int get_lower_levels_ctx(const uint8_t *levels, |
252 | | int coeff_idx, int bhl, |
253 | | TX_SIZE tx_size, |
254 | 30.4M | TX_CLASS tx_class) { |
255 | 30.4M | const int stats = |
256 | 30.4M | get_nz_mag(levels + get_padded_idx(coeff_idx, bhl), bhl, tx_class); |
257 | 30.4M | return get_nz_map_ctx_from_stats(stats, coeff_idx, bhl, tx_size, tx_class); |
258 | 30.4M | } decodetxb.c:get_lower_levels_ctx Line | Count | Source | 254 | 30.4M | TX_CLASS tx_class) { | 255 | 30.4M | const int stats = | 256 | 30.4M | get_nz_mag(levels + get_padded_idx(coeff_idx, bhl), bhl, tx_class); | 257 | 30.4M | return get_nz_map_ctx_from_stats(stats, coeff_idx, bhl, tx_size, tx_class); | 258 | 30.4M | } |
Unexecuted instantiation: entropy.c:get_lower_levels_ctx Unexecuted instantiation: entropymode.c:get_lower_levels_ctx Unexecuted instantiation: txb_common.c:get_lower_levels_ctx |
259 | | |
260 | | static inline int get_lower_levels_ctx_general(int is_last, int scan_idx, |
261 | | int bhl, int width, |
262 | | const uint8_t *levels, |
263 | | int coeff_idx, TX_SIZE tx_size, |
264 | 0 | TX_CLASS tx_class) { |
265 | 0 | if (is_last) { |
266 | 0 | if (scan_idx == 0) return 0; |
267 | 0 | if (scan_idx <= (width << bhl) >> 3) return 1; |
268 | 0 | if (scan_idx <= (width << bhl) >> 2) return 2; |
269 | 0 | return 3; |
270 | 0 | } |
271 | 0 | return get_lower_levels_ctx(levels, coeff_idx, bhl, tx_size, tx_class); |
272 | 0 | } Unexecuted instantiation: decodetxb.c:get_lower_levels_ctx_general Unexecuted instantiation: entropy.c:get_lower_levels_ctx_general Unexecuted instantiation: entropymode.c:get_lower_levels_ctx_general Unexecuted instantiation: txb_common.c:get_lower_levels_ctx_general |
273 | | |
274 | 21.6M | static inline void set_dc_sign(int *cul_level, int dc_val) { |
275 | 21.6M | if (dc_val < 0) |
276 | 5.65M | *cul_level |= 1 << COEFF_CONTEXT_BITS; |
277 | 16.0M | else if (dc_val > 0) |
278 | 12.7M | *cul_level += 2 << COEFF_CONTEXT_BITS; |
279 | 21.6M | } Line | Count | Source | 274 | 21.6M | static inline void set_dc_sign(int *cul_level, int dc_val) { | 275 | 21.6M | if (dc_val < 0) | 276 | 5.65M | *cul_level |= 1 << COEFF_CONTEXT_BITS; | 277 | 16.0M | else if (dc_val > 0) | 278 | 12.7M | *cul_level += 2 << COEFF_CONTEXT_BITS; | 279 | 21.6M | } |
Unexecuted instantiation: entropy.c:set_dc_sign Unexecuted instantiation: entropymode.c:set_dc_sign Unexecuted instantiation: txb_common.c:set_dc_sign |
280 | | |
281 | | static void get_txb_ctx_general(const BLOCK_SIZE plane_bsize, |
282 | | const TX_SIZE tx_size, const int plane, |
283 | | const ENTROPY_CONTEXT *const a, |
284 | | const ENTROPY_CONTEXT *const l, |
285 | 15.2M | TXB_CTX *const txb_ctx) { |
286 | 36.3M | #define MAX_TX_SIZE_UNIT 16 |
287 | 15.2M | static const int8_t signs[3] = { 0, -1, 1 }; |
288 | 15.2M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { |
289 | 15.2M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
290 | 15.2M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
291 | 15.2M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 |
292 | 15.2M | }; |
293 | 15.2M | const int txb_w_unit = tx_size_wide_unit[tx_size]; |
294 | 15.2M | const int txb_h_unit = tx_size_high_unit[tx_size]; |
295 | 15.2M | int dc_sign = 0; |
296 | 15.2M | int k = 0; |
297 | | |
298 | 68.4M | do { |
299 | 68.4M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; |
300 | 68.4M | assert(sign <= 2); |
301 | 68.4M | dc_sign += signs[sign]; |
302 | 68.4M | } while (++k < txb_w_unit); |
303 | | |
304 | 15.2M | k = 0; |
305 | 45.1M | do { |
306 | 45.1M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; |
307 | 45.1M | assert(sign <= 2); |
308 | 45.1M | dc_sign += signs[sign]; |
309 | 45.1M | } while (++k < txb_h_unit); |
310 | | |
311 | 15.2M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; |
312 | | |
313 | 15.2M | if (plane == 0) { |
314 | 6.12M | if (plane_bsize == txsize_to_bsize[tx_size]) { |
315 | 5.23M | txb_ctx->txb_skip_ctx = 0; |
316 | 5.23M | } else { |
317 | | // This is the algorithm to generate table skip_contexts[top][left]. |
318 | | // const int max = AOMMIN(top | left, 4); |
319 | | // const int min = AOMMIN(AOMMIN(top, left), 4); |
320 | | // if (!max) |
321 | | // txb_skip_ctx = 1; |
322 | | // else if (!min) |
323 | | // txb_skip_ctx = 2 + (max > 3); |
324 | | // else if (max <= 3) |
325 | | // txb_skip_ctx = 4; |
326 | | // else if (min <= 3) |
327 | | // txb_skip_ctx = 5; |
328 | | // else |
329 | | // txb_skip_ctx = 6; |
330 | 888k | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, |
331 | 888k | { 2, 4, 4, 4, 5 }, |
332 | 888k | { 2, 4, 4, 4, 5 }, |
333 | 888k | { 2, 4, 4, 4, 5 }, |
334 | 888k | { 3, 5, 5, 5, 6 } }; |
335 | | // For top and left, we only care about which of the following three |
336 | | // categories they belong to: { 0 }, { 1, 2, 3 }, or { 4, 5, ... }. The |
337 | | // spec calculates top and left with the Max() function. We can calculate |
338 | | // an approximate max with bitwise OR because the real max and the |
339 | | // approximate max belong to the same category. |
340 | 888k | int top = 0; |
341 | 888k | int left = 0; |
342 | | |
343 | 888k | k = 0; |
344 | 8.44M | do { |
345 | 8.44M | top |= a[k]; |
346 | 8.44M | } while (++k < txb_w_unit); |
347 | 888k | top &= COEFF_CONTEXT_MASK; |
348 | 888k | top = AOMMIN(top, 4); |
349 | | |
350 | 888k | k = 0; |
351 | 8.33M | do { |
352 | 8.33M | left |= l[k]; |
353 | 8.33M | } while (++k < txb_h_unit); |
354 | 888k | left &= COEFF_CONTEXT_MASK; |
355 | 888k | left = AOMMIN(left, 4); |
356 | | |
357 | 888k | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; |
358 | 888k | } |
359 | 9.13M | } else { |
360 | 9.13M | const int ctx_base = get_entropy_context(tx_size, a, l); |
361 | 9.13M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > |
362 | 9.13M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) |
363 | 9.13M | ? 10 |
364 | 9.13M | : 7; |
365 | 9.13M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; |
366 | 9.13M | } |
367 | 15.2M | } decodetxb.c:get_txb_ctx_general Line | Count | Source | 285 | 15.2M | TXB_CTX *const txb_ctx) { | 286 | 15.2M | #define MAX_TX_SIZE_UNIT 16 | 287 | 15.2M | static const int8_t signs[3] = { 0, -1, 1 }; | 288 | 15.2M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { | 289 | 15.2M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | 290 | 15.2M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 291 | 15.2M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 | 292 | 15.2M | }; | 293 | 15.2M | const int txb_w_unit = tx_size_wide_unit[tx_size]; | 294 | 15.2M | const int txb_h_unit = tx_size_high_unit[tx_size]; | 295 | 15.2M | int dc_sign = 0; | 296 | 15.2M | int k = 0; | 297 | | | 298 | 68.4M | do { | 299 | 68.4M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; | 300 | 68.4M | assert(sign <= 2); | 301 | 68.4M | dc_sign += signs[sign]; | 302 | 68.4M | } while (++k < txb_w_unit); | 303 | | | 304 | 15.2M | k = 0; | 305 | 45.1M | do { | 306 | 45.1M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; | 307 | 45.1M | assert(sign <= 2); | 308 | 45.1M | dc_sign += signs[sign]; | 309 | 45.1M | } while (++k < txb_h_unit); | 310 | | | 311 | 15.2M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; | 312 | | | 313 | 15.2M | if (plane == 0) { | 314 | 6.12M | if (plane_bsize == txsize_to_bsize[tx_size]) { | 315 | 5.23M | txb_ctx->txb_skip_ctx = 0; | 316 | 5.23M | } else { | 317 | | // This is the algorithm to generate table skip_contexts[top][left]. | 318 | | // const int max = AOMMIN(top | left, 4); | 319 | | // const int min = AOMMIN(AOMMIN(top, left), 4); | 320 | | // if (!max) | 321 | | // txb_skip_ctx = 1; | 322 | | // else if (!min) | 323 | | // txb_skip_ctx = 2 + (max > 3); | 324 | | // else if (max <= 3) | 325 | | // txb_skip_ctx = 4; | 326 | | // else if (min <= 3) | 327 | | // txb_skip_ctx = 5; | 328 | | // else | 329 | | // txb_skip_ctx = 6; | 330 | 888k | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, | 331 | 888k | { 2, 4, 4, 4, 5 }, | 332 | 888k | { 2, 4, 4, 4, 5 }, | 333 | 888k | { 2, 4, 4, 4, 5 }, | 334 | 888k | { 3, 5, 5, 5, 6 } }; | 335 | | // For top and left, we only care about which of the following three | 336 | | // categories they belong to: { 0 }, { 1, 2, 3 }, or { 4, 5, ... }. The | 337 | | // spec calculates top and left with the Max() function. We can calculate | 338 | | // an approximate max with bitwise OR because the real max and the | 339 | | // approximate max belong to the same category. | 340 | 888k | int top = 0; | 341 | 888k | int left = 0; | 342 | | | 343 | 888k | k = 0; | 344 | 8.44M | do { | 345 | 8.44M | top |= a[k]; | 346 | 8.44M | } while (++k < txb_w_unit); | 347 | 888k | top &= COEFF_CONTEXT_MASK; | 348 | 888k | top = AOMMIN(top, 4); | 349 | | | 350 | 888k | k = 0; | 351 | 8.33M | do { | 352 | 8.33M | left |= l[k]; | 353 | 8.33M | } while (++k < txb_h_unit); | 354 | 888k | left &= COEFF_CONTEXT_MASK; | 355 | 888k | left = AOMMIN(left, 4); | 356 | | | 357 | 888k | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; | 358 | 888k | } | 359 | 9.13M | } else { | 360 | 9.13M | const int ctx_base = get_entropy_context(tx_size, a, l); | 361 | 9.13M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > | 362 | 9.13M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) | 363 | 9.13M | ? 10 | 364 | 9.13M | : 7; | 365 | 9.13M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; | 366 | 9.13M | } | 367 | 15.2M | } |
Unexecuted instantiation: entropy.c:get_txb_ctx_general Unexecuted instantiation: entropymode.c:get_txb_ctx_general Unexecuted instantiation: txb_common.c:get_txb_ctx_general |
368 | | |
369 | | #define SPECIALIZE_GET_TXB_CTX(w, h) \ |
370 | | static void get_txb_ctx_##w##x##h( \ |
371 | | const BLOCK_SIZE plane_bsize, const int plane, \ |
372 | | const ENTROPY_CONTEXT *const a, const ENTROPY_CONTEXT *const l, \ |
373 | 20.9M | TXB_CTX *const txb_ctx) { \ |
374 | 20.9M | static const int8_t signs[3] = { 0, -1, 1 }; \ |
375 | 20.9M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \ |
376 | 20.9M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ |
377 | 20.9M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ |
378 | 20.9M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \ |
379 | 20.9M | }; \ |
380 | 20.9M | const TX_SIZE tx_size = TX_##w##X##h; \ |
381 | 20.9M | const int txb_w_unit = tx_size_wide_unit[tx_size]; \ |
382 | 20.9M | const int txb_h_unit = tx_size_high_unit[tx_size]; \ |
383 | 20.9M | int dc_sign = 0; \ |
384 | 20.9M | int k = 0; \ |
385 | 20.9M | \ |
386 | 50.7M | do { \ |
387 | 50.7M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \ |
388 | 50.7M | assert(sign <= 2); \ |
389 | 50.8M | dc_sign += signs[sign]; \ |
390 | 50.8M | } while (++k < txb_w_unit); \ |
391 | 20.9M | \ |
392 | 20.9M | k = 0; \ |
393 | 50.8M | do { \ |
394 | 50.8M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \ |
395 | 50.8M | assert(sign <= 2); \ |
396 | 50.8M | dc_sign += signs[sign]; \ |
397 | 50.8M | } while (++k < txb_h_unit); \ |
398 | 20.9M | \ |
399 | 21.0M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \ |
400 | 21.0M | \ |
401 | 21.0M | if (plane == 0) { \ |
402 | 9.69M | if (plane_bsize == txsize_to_bsize[tx_size]) { \ |
403 | 3.13M | txb_ctx->txb_skip_ctx = 0; \ |
404 | 6.55M | } else { \ |
405 | 6.55M | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \ |
406 | 6.55M | { 2, 4, 4, 4, 5 }, \ |
407 | 6.55M | { 2, 4, 4, 4, 5 }, \ |
408 | 6.55M | { 2, 4, 4, 4, 5 }, \ |
409 | 6.55M | { 3, 5, 5, 5, 6 } }; \ |
410 | 6.55M | int top = 0; \ |
411 | 6.55M | int left = 0; \ |
412 | 6.55M | \ |
413 | 6.55M | k = 0; \ |
414 | 9.80M | do { \ |
415 | 9.80M | top |= a[k]; \ |
416 | 9.80M | } while (++k < txb_w_unit); \ |
417 | 6.55M | top &= COEFF_CONTEXT_MASK; \ |
418 | 6.55M | top = AOMMIN(top, 4); \ |
419 | 6.55M | \ |
420 | 6.55M | k = 0; \ |
421 | 9.80M | do { \ |
422 | 9.80M | left |= l[k]; \ |
423 | 9.80M | } while (++k < txb_h_unit); \ |
424 | 6.55M | left &= COEFF_CONTEXT_MASK; \ |
425 | 6.55M | left = AOMMIN(left, 4); \ |
426 | 6.55M | \ |
427 | 6.55M | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \ |
428 | 6.55M | } \ |
429 | 11.3M | } else { \ |
430 | 11.3M | const int ctx_base = get_entropy_context(tx_size, a, l); \ |
431 | 11.3M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \ |
432 | 11.3M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \ |
433 | 11.3M | ? 10 \ |
434 | 11.3M | : 7; \ |
435 | 11.3M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \ |
436 | 11.3M | } \ |
437 | 21.0M | } decodetxb.c:get_txb_ctx_4x4 Line | Count | Source | 373 | 10.4M | TXB_CTX *const txb_ctx) { \ | 374 | 10.4M | static const int8_t signs[3] = { 0, -1, 1 }; \ | 375 | 10.4M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \ | 376 | 10.4M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ | 377 | 10.4M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ | 378 | 10.4M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \ | 379 | 10.4M | }; \ | 380 | 10.4M | const TX_SIZE tx_size = TX_##w##X##h; \ | 381 | 10.4M | const int txb_w_unit = tx_size_wide_unit[tx_size]; \ | 382 | 10.4M | const int txb_h_unit = tx_size_high_unit[tx_size]; \ | 383 | 10.4M | int dc_sign = 0; \ | 384 | 10.4M | int k = 0; \ | 385 | 10.4M | \ | 386 | 10.4M | do { \ | 387 | 10.4M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \ | 388 | 10.4M | assert(sign <= 2); \ | 389 | 10.4M | dc_sign += signs[sign]; \ | 390 | 10.4M | } while (++k < txb_w_unit); \ | 391 | 10.4M | \ | 392 | 10.4M | k = 0; \ | 393 | 10.4M | do { \ | 394 | 10.4M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \ | 395 | 10.4M | assert(sign <= 2); \ | 396 | 10.5M | dc_sign += signs[sign]; \ | 397 | 10.5M | } while (++k < txb_h_unit); \ | 398 | 10.4M | \ | 399 | 10.5M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \ | 400 | 10.5M | \ | 401 | 10.5M | if (plane == 0) { \ | 402 | 4.93M | if (plane_bsize == txsize_to_bsize[tx_size]) { \ | 403 | 365k | txb_ctx->txb_skip_ctx = 0; \ | 404 | 4.56M | } else { \ | 405 | 4.56M | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \ | 406 | 4.56M | { 2, 4, 4, 4, 5 }, \ | 407 | 4.56M | { 2, 4, 4, 4, 5 }, \ | 408 | 4.56M | { 2, 4, 4, 4, 5 }, \ | 409 | 4.56M | { 3, 5, 5, 5, 6 } }; \ | 410 | 4.56M | int top = 0; \ | 411 | 4.56M | int left = 0; \ | 412 | 4.56M | \ | 413 | 4.56M | k = 0; \ | 414 | 4.56M | do { \ | 415 | 4.56M | top |= a[k]; \ | 416 | 4.56M | } while (++k < txb_w_unit); \ | 417 | 4.56M | top &= COEFF_CONTEXT_MASK; \ | 418 | 4.56M | top = AOMMIN(top, 4); \ | 419 | 4.56M | \ | 420 | 4.56M | k = 0; \ | 421 | 4.56M | do { \ | 422 | 4.56M | left |= l[k]; \ | 423 | 4.56M | } while (++k < txb_h_unit); \ | 424 | 4.56M | left &= COEFF_CONTEXT_MASK; \ | 425 | 4.56M | left = AOMMIN(left, 4); \ | 426 | 4.56M | \ | 427 | 4.56M | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \ | 428 | 4.56M | } \ | 429 | 5.60M | } else { \ | 430 | 5.60M | const int ctx_base = get_entropy_context(tx_size, a, l); \ | 431 | 5.60M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \ | 432 | 5.60M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \ | 433 | 5.60M | ? 10 \ | 434 | 5.60M | : 7; \ | 435 | 5.60M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \ | 436 | 5.60M | } \ | 437 | 10.5M | } |
decodetxb.c:get_txb_ctx_8x8 Line | Count | Source | 373 | 5.22M | TXB_CTX *const txb_ctx) { \ | 374 | 5.22M | static const int8_t signs[3] = { 0, -1, 1 }; \ | 375 | 5.22M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \ | 376 | 5.22M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ | 377 | 5.22M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ | 378 | 5.22M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \ | 379 | 5.22M | }; \ | 380 | 5.22M | const TX_SIZE tx_size = TX_##w##X##h; \ | 381 | 5.22M | const int txb_w_unit = tx_size_wide_unit[tx_size]; \ | 382 | 5.22M | const int txb_h_unit = tx_size_high_unit[tx_size]; \ | 383 | 5.22M | int dc_sign = 0; \ | 384 | 5.22M | int k = 0; \ | 385 | 5.22M | \ | 386 | 10.4M | do { \ | 387 | 10.4M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \ | 388 | 10.4M | assert(sign <= 2); \ | 389 | 10.4M | dc_sign += signs[sign]; \ | 390 | 10.4M | } while (++k < txb_w_unit); \ | 391 | 5.22M | \ | 392 | 5.22M | k = 0; \ | 393 | 10.4M | do { \ | 394 | 10.4M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \ | 395 | 10.4M | assert(sign <= 2); \ | 396 | 10.4M | dc_sign += signs[sign]; \ | 397 | 10.4M | } while (++k < txb_h_unit); \ | 398 | 5.22M | \ | 399 | 5.22M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \ | 400 | 5.22M | \ | 401 | 5.22M | if (plane == 0) { \ | 402 | 2.61M | if (plane_bsize == txsize_to_bsize[tx_size]) { \ | 403 | 1.08M | txb_ctx->txb_skip_ctx = 0; \ | 404 | 1.53M | } else { \ | 405 | 1.53M | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \ | 406 | 1.53M | { 2, 4, 4, 4, 5 }, \ | 407 | 1.53M | { 2, 4, 4, 4, 5 }, \ | 408 | 1.53M | { 2, 4, 4, 4, 5 }, \ | 409 | 1.53M | { 3, 5, 5, 5, 6 } }; \ | 410 | 1.53M | int top = 0; \ | 411 | 1.53M | int left = 0; \ | 412 | 1.53M | \ | 413 | 1.53M | k = 0; \ | 414 | 3.06M | do { \ | 415 | 3.06M | top |= a[k]; \ | 416 | 3.06M | } while (++k < txb_w_unit); \ | 417 | 1.53M | top &= COEFF_CONTEXT_MASK; \ | 418 | 1.53M | top = AOMMIN(top, 4); \ | 419 | 1.53M | \ | 420 | 1.53M | k = 0; \ | 421 | 3.06M | do { \ | 422 | 3.06M | left |= l[k]; \ | 423 | 3.06M | } while (++k < txb_h_unit); \ | 424 | 1.53M | left &= COEFF_CONTEXT_MASK; \ | 425 | 1.53M | left = AOMMIN(left, 4); \ | 426 | 1.53M | \ | 427 | 1.53M | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \ | 428 | 1.53M | } \ | 429 | 2.61M | } else { \ | 430 | 2.61M | const int ctx_base = get_entropy_context(tx_size, a, l); \ | 431 | 2.61M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \ | 432 | 2.61M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \ | 433 | 2.61M | ? 10 \ | 434 | 2.61M | : 7; \ | 435 | 2.61M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \ | 436 | 2.61M | } \ | 437 | 5.22M | } |
decodetxb.c:get_txb_ctx_16x16 Line | Count | Source | 373 | 3.08M | TXB_CTX *const txb_ctx) { \ | 374 | 3.08M | static const int8_t signs[3] = { 0, -1, 1 }; \ | 375 | 3.08M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \ | 376 | 3.08M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ | 377 | 3.08M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ | 378 | 3.08M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \ | 379 | 3.08M | }; \ | 380 | 3.08M | const TX_SIZE tx_size = TX_##w##X##h; \ | 381 | 3.08M | const int txb_w_unit = tx_size_wide_unit[tx_size]; \ | 382 | 3.08M | const int txb_h_unit = tx_size_high_unit[tx_size]; \ | 383 | 3.08M | int dc_sign = 0; \ | 384 | 3.08M | int k = 0; \ | 385 | 3.08M | \ | 386 | 12.3M | do { \ | 387 | 12.3M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \ | 388 | 12.3M | assert(sign <= 2); \ | 389 | 12.3M | dc_sign += signs[sign]; \ | 390 | 12.3M | } while (++k < txb_w_unit); \ | 391 | 3.08M | \ | 392 | 3.08M | k = 0; \ | 393 | 12.3M | do { \ | 394 | 12.3M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \ | 395 | 12.3M | assert(sign <= 2); \ | 396 | 12.3M | dc_sign += signs[sign]; \ | 397 | 12.3M | } while (++k < txb_h_unit); \ | 398 | 3.08M | \ | 399 | 3.08M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \ | 400 | 3.08M | \ | 401 | 3.08M | if (plane == 0) { \ | 402 | 1.38M | if (plane_bsize == txsize_to_bsize[tx_size]) { \ | 403 | 1.01M | txb_ctx->txb_skip_ctx = 0; \ | 404 | 1.01M | } else { \ | 405 | 365k | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \ | 406 | 365k | { 2, 4, 4, 4, 5 }, \ | 407 | 365k | { 2, 4, 4, 4, 5 }, \ | 408 | 365k | { 2, 4, 4, 4, 5 }, \ | 409 | 365k | { 3, 5, 5, 5, 6 } }; \ | 410 | 365k | int top = 0; \ | 411 | 365k | int left = 0; \ | 412 | 365k | \ | 413 | 365k | k = 0; \ | 414 | 1.46M | do { \ | 415 | 1.46M | top |= a[k]; \ | 416 | 1.46M | } while (++k < txb_w_unit); \ | 417 | 365k | top &= COEFF_CONTEXT_MASK; \ | 418 | 365k | top = AOMMIN(top, 4); \ | 419 | 365k | \ | 420 | 365k | k = 0; \ | 421 | 1.46M | do { \ | 422 | 1.46M | left |= l[k]; \ | 423 | 1.46M | } while (++k < txb_h_unit); \ | 424 | 365k | left &= COEFF_CONTEXT_MASK; \ | 425 | 365k | left = AOMMIN(left, 4); \ | 426 | 365k | \ | 427 | 365k | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \ | 428 | 365k | } \ | 429 | 1.70M | } else { \ | 430 | 1.70M | const int ctx_base = get_entropy_context(tx_size, a, l); \ | 431 | 1.70M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \ | 432 | 1.70M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \ | 433 | 1.70M | ? 10 \ | 434 | 1.70M | : 7; \ | 435 | 1.70M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \ | 436 | 1.70M | } \ | 437 | 3.08M | } |
decodetxb.c:get_txb_ctx_32x32 Line | Count | Source | 373 | 2.18M | TXB_CTX *const txb_ctx) { \ | 374 | 2.18M | static const int8_t signs[3] = { 0, -1, 1 }; \ | 375 | 2.18M | static const int8_t dc_sign_contexts[4 * MAX_TX_SIZE_UNIT + 1] = { \ | 376 | 2.18M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ | 377 | 2.18M | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ | 378 | 2.18M | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 \ | 379 | 2.18M | }; \ | 380 | 2.18M | const TX_SIZE tx_size = TX_##w##X##h; \ | 381 | 2.18M | const int txb_w_unit = tx_size_wide_unit[tx_size]; \ | 382 | 2.18M | const int txb_h_unit = tx_size_high_unit[tx_size]; \ | 383 | 2.18M | int dc_sign = 0; \ | 384 | 2.18M | int k = 0; \ | 385 | 2.18M | \ | 386 | 17.5M | do { \ | 387 | 17.5M | const unsigned int sign = ((uint8_t)a[k]) >> COEFF_CONTEXT_BITS; \ | 388 | 17.5M | assert(sign <= 2); \ | 389 | 17.5M | dc_sign += signs[sign]; \ | 390 | 17.5M | } while (++k < txb_w_unit); \ | 391 | 2.18M | \ | 392 | 2.18M | k = 0; \ | 393 | 17.5M | do { \ | 394 | 17.5M | const unsigned int sign = ((uint8_t)l[k]) >> COEFF_CONTEXT_BITS; \ | 395 | 17.5M | assert(sign <= 2); \ | 396 | 17.5M | dc_sign += signs[sign]; \ | 397 | 17.5M | } while (++k < txb_h_unit); \ | 398 | 2.18M | \ | 399 | 2.18M | txb_ctx->dc_sign_ctx = dc_sign_contexts[dc_sign + 2 * MAX_TX_SIZE_UNIT]; \ | 400 | 2.18M | \ | 401 | 2.18M | if (plane == 0) { \ | 402 | 756k | if (plane_bsize == txsize_to_bsize[tx_size]) { \ | 403 | 667k | txb_ctx->txb_skip_ctx = 0; \ | 404 | 667k | } else { \ | 405 | 88.9k | static const uint8_t skip_contexts[5][5] = { { 1, 2, 2, 2, 3 }, \ | 406 | 88.9k | { 2, 4, 4, 4, 5 }, \ | 407 | 88.9k | { 2, 4, 4, 4, 5 }, \ | 408 | 88.9k | { 2, 4, 4, 4, 5 }, \ | 409 | 88.9k | { 3, 5, 5, 5, 6 } }; \ | 410 | 88.9k | int top = 0; \ | 411 | 88.9k | int left = 0; \ | 412 | 88.9k | \ | 413 | 88.9k | k = 0; \ | 414 | 711k | do { \ | 415 | 711k | top |= a[k]; \ | 416 | 711k | } while (++k < txb_w_unit); \ | 417 | 88.9k | top &= COEFF_CONTEXT_MASK; \ | 418 | 88.9k | top = AOMMIN(top, 4); \ | 419 | 88.9k | \ | 420 | 88.9k | k = 0; \ | 421 | 711k | do { \ | 422 | 711k | left |= l[k]; \ | 423 | 711k | } while (++k < txb_h_unit); \ | 424 | 88.9k | left &= COEFF_CONTEXT_MASK; \ | 425 | 88.9k | left = AOMMIN(left, 4); \ | 426 | 88.9k | \ | 427 | 88.9k | txb_ctx->txb_skip_ctx = skip_contexts[top][left]; \ | 428 | 88.9k | } \ | 429 | 1.43M | } else { \ | 430 | 1.43M | const int ctx_base = get_entropy_context(tx_size, a, l); \ | 431 | 1.43M | const int ctx_offset = (num_pels_log2_lookup[plane_bsize] > \ | 432 | 1.43M | num_pels_log2_lookup[txsize_to_bsize[tx_size]]) \ | 433 | 1.43M | ? 10 \ | 434 | 1.43M | : 7; \ | 435 | 1.43M | txb_ctx->txb_skip_ctx = ctx_base + ctx_offset; \ | 436 | 1.43M | } \ | 437 | 2.18M | } |
Unexecuted instantiation: entropy.c:get_txb_ctx_4x4 Unexecuted instantiation: entropy.c:get_txb_ctx_8x8 Unexecuted instantiation: entropy.c:get_txb_ctx_16x16 Unexecuted instantiation: entropy.c:get_txb_ctx_32x32 Unexecuted instantiation: entropymode.c:get_txb_ctx_4x4 Unexecuted instantiation: entropymode.c:get_txb_ctx_8x8 Unexecuted instantiation: entropymode.c:get_txb_ctx_16x16 Unexecuted instantiation: entropymode.c:get_txb_ctx_32x32 Unexecuted instantiation: txb_common.c:get_txb_ctx_4x4 Unexecuted instantiation: txb_common.c:get_txb_ctx_8x8 Unexecuted instantiation: txb_common.c:get_txb_ctx_16x16 Unexecuted instantiation: txb_common.c:get_txb_ctx_32x32 |
438 | | |
439 | | SPECIALIZE_GET_TXB_CTX(4, 4) |
440 | | SPECIALIZE_GET_TXB_CTX(8, 8) |
441 | | SPECIALIZE_GET_TXB_CTX(16, 16) |
442 | | SPECIALIZE_GET_TXB_CTX(32, 32) |
443 | | |
444 | | // Wrapper for get_txb_ctx that calls the specialized version of get_txb_ctc_* |
445 | | // so that the compiler can compile away the while loops. |
446 | | static inline void get_txb_ctx(const BLOCK_SIZE plane_bsize, |
447 | | const TX_SIZE tx_size, const int plane, |
448 | | const ENTROPY_CONTEXT *const a, |
449 | | const ENTROPY_CONTEXT *const l, |
450 | 36.1M | TXB_CTX *const txb_ctx) { |
451 | 36.1M | switch (tx_size) { |
452 | 10.4M | case TX_4X4: get_txb_ctx_4x4(plane_bsize, plane, a, l, txb_ctx); break; |
453 | 5.22M | case TX_8X8: get_txb_ctx_8x8(plane_bsize, plane, a, l, txb_ctx); break; |
454 | 3.08M | case TX_16X16: get_txb_ctx_16x16(plane_bsize, plane, a, l, txb_ctx); break; |
455 | 2.18M | case TX_32X32: get_txb_ctx_32x32(plane_bsize, plane, a, l, txb_ctx); break; |
456 | 15.2M | default: |
457 | 15.2M | get_txb_ctx_general(plane_bsize, tx_size, plane, a, l, txb_ctx); |
458 | 15.2M | break; |
459 | 36.1M | } |
460 | 36.1M | } Line | Count | Source | 450 | 36.1M | TXB_CTX *const txb_ctx) { | 451 | 36.1M | switch (tx_size) { | 452 | 10.4M | case TX_4X4: get_txb_ctx_4x4(plane_bsize, plane, a, l, txb_ctx); break; | 453 | 5.22M | case TX_8X8: get_txb_ctx_8x8(plane_bsize, plane, a, l, txb_ctx); break; | 454 | 3.08M | case TX_16X16: get_txb_ctx_16x16(plane_bsize, plane, a, l, txb_ctx); break; | 455 | 2.18M | case TX_32X32: get_txb_ctx_32x32(plane_bsize, plane, a, l, txb_ctx); break; | 456 | 15.2M | default: | 457 | 15.2M | get_txb_ctx_general(plane_bsize, tx_size, plane, a, l, txb_ctx); | 458 | 15.2M | break; | 459 | 36.1M | } | 460 | 36.1M | } |
Unexecuted instantiation: entropy.c:get_txb_ctx Unexecuted instantiation: entropymode.c:get_txb_ctx Unexecuted instantiation: txb_common.c:get_txb_ctx |
461 | | #undef MAX_TX_SIZE_UNIT |
462 | | |
463 | | #endif // AOM_AV1_COMMON_TXB_COMMON_H_ |