/src/aom/av1/decoder/decodetxb.c
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 | | #include "av1/decoder/decodetxb.h" |
13 | | |
14 | | #include "aom_ports/mem.h" |
15 | | #include "av1/common/idct.h" |
16 | | #include "av1/common/scan.h" |
17 | | #include "av1/common/txb_common.h" |
18 | | #include "av1/decoder/decodemv.h" |
19 | | |
20 | | #define ACCT_STR __func__ |
21 | | |
22 | 902k | static int read_golomb(MACROBLOCKD *xd, aom_reader *r) { |
23 | 902k | int x = 1; |
24 | 902k | int length = 0; |
25 | 902k | int i = 0; |
26 | | |
27 | 2.83M | while (!i) { |
28 | 1.93M | i = aom_read_bit(r, ACCT_STR); |
29 | 1.93M | ++length; |
30 | 1.93M | if (length > 20) { |
31 | 430 | aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME, |
32 | 430 | "Invalid length in read_golomb"); |
33 | 430 | break; |
34 | 430 | } |
35 | 1.93M | } |
36 | | |
37 | 1.93M | for (i = 0; i < length - 1; ++i) { |
38 | 1.02M | x <<= 1; |
39 | 1.02M | x += aom_read_bit(r, ACCT_STR); |
40 | 1.02M | } |
41 | | |
42 | 902k | return x - 1; |
43 | 902k | } |
44 | | |
45 | 21.7M | static inline int rec_eob_pos(const int eob_token, const int extra) { |
46 | 21.7M | int eob = av1_eob_group_start[eob_token]; |
47 | 21.7M | if (eob > 2) { |
48 | 11.2M | eob += extra; |
49 | 11.2M | } |
50 | 21.7M | return eob; |
51 | 21.7M | } |
52 | | |
53 | | static inline int get_dqv(const int16_t *dequant, int coeff_idx, |
54 | 102M | const qm_val_t *iqmatrix) { |
55 | 102M | int dqv = dequant[!!coeff_idx]; |
56 | 102M | if (iqmatrix != NULL) |
57 | 2.09M | dqv = |
58 | 2.09M | ((iqmatrix[coeff_idx] * dqv) + (1 << (AOM_QM_BITS - 1))) >> AOM_QM_BITS; |
59 | 102M | return dqv; |
60 | 102M | } |
61 | | |
62 | | static inline void read_coeffs_reverse_2d(aom_reader *r, TX_SIZE tx_size, |
63 | | int start_si, int end_si, |
64 | | const int16_t *scan, int bhl, |
65 | | uint8_t *levels, |
66 | | base_cdf_arr base_cdf, |
67 | 10.9M | br_cdf_arr br_cdf) { |
68 | 235M | for (int c = end_si; c >= start_si; --c) { |
69 | 224M | const int pos = scan[c]; |
70 | 224M | const int coeff_ctx = get_lower_levels_ctx_2d(levels, pos, bhl, tx_size); |
71 | 224M | const int nsymbs = 4; |
72 | 224M | int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR); |
73 | 224M | if (level > NUM_BASE_LEVELS) { |
74 | 15.0M | const int br_ctx = get_br_ctx_2d(levels, pos, bhl); |
75 | 15.0M | aom_cdf_prob *cdf = br_cdf[br_ctx]; |
76 | 21.3M | for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { |
77 | 20.8M | const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); |
78 | 20.8M | level += k; |
79 | 20.8M | if (k < BR_CDF_SIZE - 1) break; |
80 | 20.8M | } |
81 | 15.0M | } |
82 | 224M | levels[get_padded_idx(pos, bhl)] = level; |
83 | 224M | } |
84 | 10.9M | } |
85 | | |
86 | | static inline void read_coeffs_reverse(aom_reader *r, TX_SIZE tx_size, |
87 | | TX_CLASS tx_class, int start_si, |
88 | | int end_si, const int16_t *scan, int bhl, |
89 | | uint8_t *levels, base_cdf_arr base_cdf, |
90 | 11.9M | br_cdf_arr br_cdf) { |
91 | 42.4M | for (int c = end_si; c >= start_si; --c) { |
92 | 30.4M | const int pos = scan[c]; |
93 | 30.4M | const int coeff_ctx = |
94 | 30.4M | get_lower_levels_ctx(levels, pos, bhl, tx_size, tx_class); |
95 | 30.4M | const int nsymbs = 4; |
96 | 30.4M | int level = aom_read_symbol(r, base_cdf[coeff_ctx], nsymbs, ACCT_STR); |
97 | 30.4M | if (level > NUM_BASE_LEVELS) { |
98 | 4.94M | const int br_ctx = get_br_ctx(levels, pos, bhl, tx_class); |
99 | 4.94M | aom_cdf_prob *cdf = br_cdf[br_ctx]; |
100 | 8.13M | for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { |
101 | 7.82M | const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); |
102 | 7.82M | level += k; |
103 | 7.82M | if (k < BR_CDF_SIZE - 1) break; |
104 | 7.82M | } |
105 | 4.94M | } |
106 | 30.4M | levels[get_padded_idx(pos, bhl)] = level; |
107 | 30.4M | } |
108 | 11.9M | } |
109 | | |
110 | | static uint8_t read_coeffs_txb(const AV1_COMMON *const cm, |
111 | | DecoderCodingBlock *dcb, aom_reader *const r, |
112 | | const int blk_row, const int blk_col, |
113 | | const int plane, const TXB_CTX *const txb_ctx, |
114 | 36.4M | const TX_SIZE tx_size) { |
115 | 36.4M | MACROBLOCKD *const xd = &dcb->xd; |
116 | 36.4M | FRAME_CONTEXT *const ec_ctx = xd->tile_ctx; |
117 | 36.4M | const int32_t max_value = (1 << (7 + xd->bd)) - 1; |
118 | 36.4M | const int32_t min_value = -(1 << (7 + xd->bd)); |
119 | 36.4M | const TX_SIZE txs_ctx = get_txsize_entropy_ctx(tx_size); |
120 | 36.4M | const PLANE_TYPE plane_type = get_plane_type(plane); |
121 | 36.4M | MB_MODE_INFO *const mbmi = xd->mi[0]; |
122 | 36.4M | struct macroblockd_plane *const pd = &xd->plane[plane]; |
123 | 36.4M | const int16_t *const dequant = pd->seg_dequant_QTX[mbmi->segment_id]; |
124 | 36.4M | tran_low_t *const tcoeffs = dcb->dqcoeff_block[plane] + dcb->cb_offset[plane]; |
125 | 36.4M | const int shift = av1_get_tx_scale(tx_size); |
126 | 36.4M | const int bhl = get_txb_bhl(tx_size); |
127 | 36.4M | const int width = get_txb_wide(tx_size); |
128 | 36.4M | const int height = get_txb_high(tx_size); |
129 | 36.4M | int cul_level = 0; |
130 | 36.4M | int dc_val = 0; |
131 | 36.4M | uint8_t levels_buf[TX_PAD_2D]; |
132 | 36.4M | uint8_t *const levels = set_levels(levels_buf, height); |
133 | 36.4M | const int all_zero = aom_read_symbol( |
134 | 36.4M | r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2, ACCT_STR); |
135 | 36.4M | eob_info *eob_data = dcb->eob_data[plane] + dcb->txb_offset[plane]; |
136 | 36.4M | uint16_t *const eob = &(eob_data->eob); |
137 | 36.4M | uint16_t *const max_scan_line = &(eob_data->max_scan_line); |
138 | 36.4M | *max_scan_line = 0; |
139 | 36.4M | *eob = 0; |
140 | | |
141 | | #if CONFIG_INSPECTION |
142 | | if (plane == 0) { |
143 | | const int txk_type_idx = |
144 | | av1_get_txk_type_index(mbmi->bsize, blk_row, blk_col); |
145 | | mbmi->tx_skip[txk_type_idx] = all_zero; |
146 | | } |
147 | | #endif |
148 | | |
149 | 36.4M | if (all_zero) { |
150 | 14.3M | *max_scan_line = 0; |
151 | 14.3M | if (plane == 0) { |
152 | 3.37M | xd->tx_type_map[blk_row * xd->tx_type_map_stride + blk_col] = DCT_DCT; |
153 | 3.37M | } |
154 | 14.3M | return 0; |
155 | 14.3M | } |
156 | | |
157 | 22.0M | if (plane == AOM_PLANE_Y) { |
158 | | // only y plane's tx_type is transmitted |
159 | 12.0M | av1_read_tx_type(cm, xd, blk_row, blk_col, tx_size, r); |
160 | 12.0M | } |
161 | 22.0M | const TX_TYPE tx_type = |
162 | 22.0M | av1_get_tx_type(xd, plane_type, blk_row, blk_col, tx_size, |
163 | 22.0M | cm->features.reduced_tx_set_used); |
164 | 22.0M | const TX_CLASS tx_class = tx_type_to_class[tx_type]; |
165 | 22.0M | const qm_val_t *iqmatrix = |
166 | 22.0M | av1_get_iqmatrix(&cm->quant_params, xd, plane, tx_size, tx_type); |
167 | 22.0M | const SCAN_ORDER *const scan_order = get_scan(tx_size, tx_type); |
168 | 22.0M | const int16_t *const scan = scan_order->scan; |
169 | 22.0M | int eob_extra = 0; |
170 | 22.0M | int eob_pt = 1; |
171 | | |
172 | 22.0M | const int eob_multi_size = txsize_log2_minus4[tx_size]; |
173 | 22.0M | const int eob_multi_ctx = (tx_class == TX_CLASS_2D) ? 0 : 1; |
174 | 22.0M | switch (eob_multi_size) { |
175 | 7.52M | case 0: |
176 | 7.52M | eob_pt = |
177 | 7.52M | aom_read_symbol(r, ec_ctx->eob_flag_cdf16[plane_type][eob_multi_ctx], |
178 | 7.52M | 5, ACCT_STR) + |
179 | 7.52M | 1; |
180 | 7.52M | break; |
181 | 2.55M | case 1: |
182 | 2.55M | eob_pt = |
183 | 2.55M | aom_read_symbol(r, ec_ctx->eob_flag_cdf32[plane_type][eob_multi_ctx], |
184 | 2.55M | 6, ACCT_STR) + |
185 | 2.55M | 1; |
186 | 2.55M | break; |
187 | 4.83M | case 2: |
188 | 4.83M | eob_pt = |
189 | 4.83M | aom_read_symbol(r, ec_ctx->eob_flag_cdf64[plane_type][eob_multi_ctx], |
190 | 4.83M | 7, ACCT_STR) + |
191 | 4.83M | 1; |
192 | 4.83M | break; |
193 | 1.75M | case 3: |
194 | 1.75M | eob_pt = |
195 | 1.75M | aom_read_symbol(r, ec_ctx->eob_flag_cdf128[plane_type][eob_multi_ctx], |
196 | 1.75M | 8, ACCT_STR) + |
197 | 1.75M | 1; |
198 | 1.75M | break; |
199 | 2.99M | case 4: |
200 | 2.99M | eob_pt = |
201 | 2.99M | aom_read_symbol(r, ec_ctx->eob_flag_cdf256[plane_type][eob_multi_ctx], |
202 | 2.99M | 9, ACCT_STR) + |
203 | 2.99M | 1; |
204 | 2.99M | break; |
205 | 850k | case 5: |
206 | 850k | eob_pt = |
207 | 850k | aom_read_symbol(r, ec_ctx->eob_flag_cdf512[plane_type][eob_multi_ctx], |
208 | 850k | 10, ACCT_STR) + |
209 | 850k | 1; |
210 | 850k | break; |
211 | 1.08M | case 6: |
212 | 1.08M | default: |
213 | 1.08M | eob_pt = aom_read_symbol( |
214 | 1.08M | r, ec_ctx->eob_flag_cdf1024[plane_type][eob_multi_ctx], 11, |
215 | 1.08M | ACCT_STR) + |
216 | 1.08M | 1; |
217 | 1.08M | break; |
218 | 22.0M | } |
219 | | |
220 | 21.6M | const int eob_offset_bits = av1_eob_offset_bits[eob_pt]; |
221 | 21.6M | if (eob_offset_bits > 0) { |
222 | 11.2M | const int eob_ctx = eob_pt - 3; |
223 | 11.2M | int bit = aom_read_symbol( |
224 | 11.2M | r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_ctx], 2, ACCT_STR); |
225 | 11.2M | if (bit) { |
226 | 4.44M | eob_extra += (1 << (eob_offset_bits - 1)); |
227 | 4.44M | } |
228 | | |
229 | 34.6M | for (int i = 1; i < eob_offset_bits; i++) { |
230 | 23.4M | bit = aom_read_bit(r, ACCT_STR); |
231 | 23.4M | if (bit) { |
232 | 11.4M | eob_extra += (1 << (eob_offset_bits - 1 - i)); |
233 | 11.4M | } |
234 | 23.4M | } |
235 | 11.2M | } |
236 | 21.6M | *eob = rec_eob_pos(eob_pt, eob_extra); |
237 | | |
238 | 21.6M | if (*eob > 1) { |
239 | 12.0M | memset(levels_buf, 0, |
240 | 12.0M | sizeof(*levels_buf) * |
241 | 12.0M | ((height + TX_PAD_HOR) * (width + TX_PAD_VER) + TX_PAD_END)); |
242 | 12.0M | } |
243 | | |
244 | 21.6M | { |
245 | | // Read the non-zero coefficient with scan index eob-1 |
246 | | // TODO(angiebird): Put this into a function |
247 | 21.6M | const int c = *eob - 1; |
248 | 21.6M | const int pos = scan[c]; |
249 | 21.6M | const int coeff_ctx = get_lower_levels_ctx_eob(bhl, width, c); |
250 | 21.6M | const int nsymbs = 3; |
251 | 21.6M | aom_cdf_prob *cdf = |
252 | 21.6M | ec_ctx->coeff_base_eob_cdf[txs_ctx][plane_type][coeff_ctx]; |
253 | 21.6M | int level = aom_read_symbol(r, cdf, nsymbs, ACCT_STR) + 1; |
254 | 21.6M | if (level > NUM_BASE_LEVELS) { |
255 | 660k | const int br_ctx = get_br_ctx_eob(pos, bhl, tx_class); |
256 | 660k | cdf = ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type][br_ctx]; |
257 | 912k | for (int idx = 0; idx < COEFF_BASE_RANGE; idx += BR_CDF_SIZE - 1) { |
258 | 896k | const int k = aom_read_symbol(r, cdf, BR_CDF_SIZE, ACCT_STR); |
259 | 896k | level += k; |
260 | 896k | if (k < BR_CDF_SIZE - 1) break; |
261 | 896k | } |
262 | 660k | } |
263 | 21.6M | levels[get_padded_idx(pos, bhl)] = level; |
264 | 21.6M | } |
265 | 21.6M | if (*eob > 1) { |
266 | 12.0M | base_cdf_arr base_cdf = ec_ctx->coeff_base_cdf[txs_ctx][plane_type]; |
267 | 12.0M | br_cdf_arr br_cdf = |
268 | 12.0M | ec_ctx->coeff_br_cdf[AOMMIN(txs_ctx, TX_32X32)][plane_type]; |
269 | 12.0M | if (tx_class == TX_CLASS_2D) { |
270 | 10.9M | read_coeffs_reverse_2d(r, tx_size, 1, *eob - 1 - 1, scan, bhl, levels, |
271 | 10.9M | base_cdf, br_cdf); |
272 | 10.9M | read_coeffs_reverse(r, tx_size, tx_class, 0, 0, scan, bhl, levels, |
273 | 10.9M | base_cdf, br_cdf); |
274 | 10.9M | } else { |
275 | 1.03M | read_coeffs_reverse(r, tx_size, tx_class, 0, *eob - 1 - 1, scan, bhl, |
276 | 1.03M | levels, base_cdf, br_cdf); |
277 | 1.03M | } |
278 | 12.0M | } |
279 | | |
280 | 297M | for (int c = 0; c < *eob; ++c) { |
281 | 275M | const int pos = scan[c]; |
282 | 275M | uint8_t sign; |
283 | 275M | tran_low_t level = levels[get_padded_idx(pos, bhl)]; |
284 | 275M | if (level) { |
285 | 102M | *max_scan_line = AOMMAX(*max_scan_line, pos); |
286 | 102M | if (c == 0) { |
287 | 17.8M | const int dc_sign_ctx = txb_ctx->dc_sign_ctx; |
288 | 17.8M | sign = aom_read_symbol(r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], |
289 | 17.8M | 2, ACCT_STR); |
290 | 84.1M | } else { |
291 | 84.1M | sign = aom_read_bit(r, ACCT_STR); |
292 | 84.1M | } |
293 | 102M | if (level >= MAX_BASE_BR_RANGE) { |
294 | 901k | level += read_golomb(xd, r); |
295 | 901k | } |
296 | | |
297 | 102M | if (c == 0) dc_val = sign ? -level : level; |
298 | | |
299 | | // Bitmasking to clamp level to valid range: |
300 | | // The valid range for 8/10/12 bit vdieo is at most 14/16/18 bit |
301 | 102M | level &= 0xfffff; |
302 | 102M | cul_level += level; |
303 | 102M | tran_low_t dq_coeff; |
304 | | // Bitmasking to clamp dq_coeff to valid range: |
305 | | // The valid range for 8/10/12 bit video is at most 17/19/21 bit |
306 | 102M | dq_coeff = |
307 | 102M | (tran_low_t)((int64_t)level * get_dqv(dequant, scan[c], iqmatrix) & |
308 | 102M | 0xffffff); |
309 | 102M | dq_coeff = dq_coeff >> shift; |
310 | 102M | if (sign) { |
311 | 49.0M | dq_coeff = -dq_coeff; |
312 | 49.0M | } |
313 | 102M | tcoeffs[pos] = clamp(dq_coeff, min_value, max_value); |
314 | 102M | } |
315 | 275M | } |
316 | | |
317 | 21.6M | cul_level = AOMMIN(COEFF_CONTEXT_MASK, cul_level); |
318 | | |
319 | | // DC value |
320 | 21.6M | set_dc_sign(&cul_level, dc_val); |
321 | | |
322 | 21.6M | return cul_level; |
323 | 22.0M | } |
324 | | |
325 | | void av1_read_coeffs_txb(const AV1_COMMON *const cm, DecoderCodingBlock *dcb, |
326 | | aom_reader *const r, const int plane, const int row, |
327 | 36.2M | const int col, const TX_SIZE tx_size) { |
328 | | #if TXCOEFF_TIMER |
329 | | struct aom_usec_timer timer; |
330 | | aom_usec_timer_start(&timer); |
331 | | #endif |
332 | 36.2M | MACROBLOCKD *const xd = &dcb->xd; |
333 | 36.2M | MB_MODE_INFO *const mbmi = xd->mi[0]; |
334 | 36.2M | struct macroblockd_plane *const pd = &xd->plane[plane]; |
335 | | |
336 | 36.2M | const BLOCK_SIZE bsize = mbmi->bsize; |
337 | 36.2M | assert(bsize < BLOCK_SIZES_ALL); |
338 | 36.2M | const BLOCK_SIZE plane_bsize = |
339 | 36.2M | get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y); |
340 | | |
341 | 36.2M | TXB_CTX txb_ctx; |
342 | 36.2M | get_txb_ctx(plane_bsize, tx_size, plane, pd->above_entropy_context + col, |
343 | 36.2M | pd->left_entropy_context + row, &txb_ctx); |
344 | 36.2M | const uint8_t cul_level = |
345 | 36.2M | read_coeffs_txb(cm, dcb, r, row, col, plane, &txb_ctx, tx_size); |
346 | 36.2M | av1_set_entropy_contexts(xd, pd, plane, plane_bsize, tx_size, cul_level, col, |
347 | 36.2M | row); |
348 | | |
349 | 36.2M | if (is_inter_block(mbmi)) { |
350 | 10.7M | const PLANE_TYPE plane_type = get_plane_type(plane); |
351 | | // tx_type will be read out in av1_read_coeffs_txb_facade |
352 | 10.7M | const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size, |
353 | 10.7M | cm->features.reduced_tx_set_used); |
354 | | |
355 | 10.7M | if (plane == 0) { |
356 | 4.54M | const int txw = tx_size_wide_unit[tx_size]; |
357 | 4.54M | const int txh = tx_size_high_unit[tx_size]; |
358 | | // The 16x16 unit is due to the constraint from tx_64x64 which sets the |
359 | | // maximum tx size for chroma as 32x32. Coupled with 4x1 transform block |
360 | | // size, the constraint takes effect in 32x16 / 16x32 size too. To solve |
361 | | // the intricacy, cover all the 16x16 units inside a 64 level transform. |
362 | 4.54M | if (txw == tx_size_wide_unit[TX_64X64] || |
363 | 4.54M | txh == tx_size_high_unit[TX_64X64]) { |
364 | 182k | const int tx_unit = tx_size_wide_unit[TX_16X16]; |
365 | 182k | const int stride = xd->tx_type_map_stride; |
366 | 790k | for (int idy = 0; idy < txh; idy += tx_unit) { |
367 | 2.75M | for (int idx = 0; idx < txw; idx += tx_unit) { |
368 | 2.14M | xd->tx_type_map[(row + idy) * stride + col + idx] = tx_type; |
369 | 2.14M | } |
370 | 607k | } |
371 | 182k | } |
372 | 4.54M | } |
373 | 10.7M | } |
374 | | |
375 | | #if TXCOEFF_TIMER |
376 | | aom_usec_timer_mark(&timer); |
377 | | const int64_t elapsed_time = aom_usec_timer_elapsed(&timer); |
378 | | cm->txcoeff_timer += elapsed_time; |
379 | | ++cm->txb_count; |
380 | | #endif |
381 | 36.2M | } |