decodetxb.c 17.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
/*
 * Copyright (c) 2017, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "av1/common/scan.h"
Angie Chiang's avatar
Angie Chiang committed
13
#include "av1/common/idct.h"
14
#include "av1/common/txb_common.h"
15
#include "av1/decoder/decodemv.h"
16
#include "av1/decoder/decodetxb.h"
17
#include "av1/decoder/dsubexp.h"
18
#include "av1/decoder/symbolrate.h"
19
20
21

#define ACCT_STR __func__

22
23
24
25
static int read_golomb(MACROBLOCKD *xd, aom_reader *r, FRAME_COUNTS *counts) {
#if !CONFIG_SYMBOLRATE
  (void)counts;
#endif
26
27
28
29
30
  int x = 1;
  int length = 0;
  int i = 0;

  while (!i) {
31
    i = av1_read_record_bit(counts, r, ACCT_STR);
32
    ++length;
33
34
35
36
37
    if (length >= 32) {
      aom_internal_error(xd->error_info, AOM_CODEC_CORRUPT_FRAME,
                         "Invalid length in read_golomb");
      break;
    }
38
39
40
41
  }

  for (i = 0; i < length - 1; ++i) {
    x <<= 1;
42
    x += av1_read_record_bit(counts, r, ACCT_STR);
43
44
45
46
47
  }

  return x - 1;
}

Linfeng Zhang's avatar
Linfeng Zhang committed
48
49
50
51
52
53
static INLINE int read_nz_map(aom_reader *const r, uint8_t *const levels,
                              const int plane, const int16_t *const scan,
                              const TX_SIZE tx_size, const TX_TYPE tx_type,
                              FRAME_CONTEXT *const fc,
                              FRAME_COUNTS *const counts) {
  const TX_SIZE txs_ctx = get_txsize_context(tx_size);
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
  const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2;
  const int height = tx_size_high[tx_size];
#if CONFIG_CTX1D
  const int width = tx_size_wide[tx_size];
  const int eob_offset = width + height;
  const TX_CLASS tx_class = get_tx_class(tx_type);
  const int seg_eob =
      (tx_class == TX_CLASS_2D) ? tx_size_2d[tx_size] : eob_offset;
#else
  const int seg_eob = tx_size_2d[tx_size];
#endif
  const PLANE_TYPE plane_type = get_plane_type(plane);
  unsigned int(*nz_map_count)[SIG_COEF_CONTEXTS][2] =
      (counts) ? &counts->nz_map[txs_ctx][plane_type] : NULL;
  int c;
  for (c = 0; c < seg_eob; ++c) {
    int is_nz;
Linfeng Zhang's avatar
Linfeng Zhang committed
71
    int coeff_ctx = get_nz_map_ctx(levels, c, scan, bwl, height, tx_type, 1);
Linfeng Zhang's avatar
Linfeng Zhang committed
72
    int eob_ctx = get_eob_ctx(scan[c], txs_ctx, tx_type);
73
74

    if (c < seg_eob - 1) {
75
      is_nz = av1_read_record_bin(
76
77
          counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2,
          ACCT_STR);
78
79
80
81
82
    } else {
      is_nz = 1;
    }

    // set non-zero coefficient map.
Linfeng Zhang's avatar
Linfeng Zhang committed
83
    levels[scan[c]] = is_nz;
84
85
86
87
88
89
90
91
92

    if (c == seg_eob - 1) {
      ++c;
      break;
    }

    if (counts) ++(*nz_map_count)[coeff_ctx][is_nz];

    if (is_nz) {
93
      int is_eob = av1_read_record_bin(
94
95
          counts, r, fc->eob_flag_cdf[txs_ctx][plane_type][eob_ctx], 2,
          ACCT_STR);
96
97
98
99
100
101
102
103
      if (counts) ++counts->eob_flag[txs_ctx][plane_type][eob_ctx][is_eob];
      if (is_eob) break;
    }
  }
  return AOMMIN(seg_eob, c + 1);
}

#if CONFIG_CTX1D
Linfeng Zhang's avatar
Linfeng Zhang committed
104
105
106
107
static INLINE int read_nz_map_vert(aom_reader *r, uint8_t *levels, int plane,
                                   const int16_t *scan, const int16_t *iscan,
                                   TX_SIZE tx_size, TX_TYPE tx_type,
                                   FRAME_CONTEXT *fc, FRAME_COUNTS *counts) {
108
109
110
111
112
113
114
115
116
117
118
119
120
121
  const TX_SIZE txs_ctx = get_txsize_context(tx_size);
  const PLANE_TYPE plane_type = get_plane_type(plane);
  const TX_CLASS tx_class = get_tx_class(tx_type);
  const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2;
  const int width = tx_size_wide[tx_size];
  const int height = tx_size_high[tx_size];
  int16_t eob_ls[MAX_HVTX_SIZE];
  int eob = 0;
#if !LV_MAP_PROB
  aom_prob *nz_map = fc->nz_map[txs_ctx][plane_type];
#endif
  for (int col = 0; col < width; ++col) {
    int el_ctx = get_empty_line_ctx(col, eob_ls);
#if LV_MAP_PROB
122
    int empty_line = av1_read_record_bin(
123
        counts, r, fc->empty_line_cdf[txs_ctx][plane_type][tx_class][el_ctx], 2,
124
125
126
127
128
129
130
131
132
133
134
        ACCT_STR);
#else
    int empty_line = aom_read(
        r, fc->empty_line[txs_ctx][plane_type][tx_class][el_ctx], ACCT_STR);
#endif
    if (counts)
      ++counts->empty_line[txs_ctx][plane_type][tx_class][el_ctx][empty_line];
    if (!empty_line) {
      int row;
      for (row = 0; row < height; ++row) {
        if (row + 1 != height) {
135
136
137
          int coeff_idx = row * width + col;
          int scan_idx = iscan[coeff_idx];
          int coeff_ctx =
Linfeng Zhang's avatar
Linfeng Zhang committed
138
              get_nz_map_ctx(levels, scan_idx, scan, bwl, height, tx_type, 1);
139
#if LV_MAP_PROB
140
          int is_nz = av1_read_record_bin(
141
142
              counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2,
              ACCT_STR);
143
144
145
146
#else
          int is_nz = aom_read(r, nz_map[coeff_ctx], ACCT_STR);
#endif
          if (counts) ++counts->nz_map[txs_ctx][plane_type][coeff_ctx][is_nz];
Linfeng Zhang's avatar
Linfeng Zhang committed
147
          levels[coeff_idx] = is_nz;
148
149
150
151
152
          if (is_nz) {
            eob = AOMMAX(eob, iscan[coeff_idx] + 1);
            if (row + 1 != height) {
              int eob_ctx = get_hv_eob_ctx(col, row, eob_ls);
#if LV_MAP_PROB
153
              int is_eob = av1_read_record_bin(
154
155
                  counts, r,
                  fc->hv_eob_cdf[txs_ctx][plane_type][tx_class][eob_ctx], 2,
156
157
158
159
160
161
162
163
164
165
166
167
168
                  ACCT_STR);
#else
              int is_eob = aom_read(
                  r, fc->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx],
                  ACCT_STR);
#endif
              if (counts)
                ++counts
                      ->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx][is_eob];
              if (is_eob) break;
            }
          }
        } else {
169
          int coeff_idx = row * width + col;
Linfeng Zhang's avatar
Linfeng Zhang committed
170
          levels[coeff_idx] = 1;
171
172
173
174
175
176
177
178
179
180
181
          eob = AOMMAX(eob, iscan[coeff_idx] + 1);
        }
      }
      eob_ls[col] = AOMMIN(height, row + 1);
    } else {
      eob_ls[col] = 0;
    }
  }
  return eob;
}

Linfeng Zhang's avatar
Linfeng Zhang committed
182
183
184
185
static INLINE int read_nz_map_horiz(aom_reader *r, uint8_t *levels, int plane,
                                    const int16_t *scan, const int16_t *iscan,
                                    TX_SIZE tx_size, TX_TYPE tx_type,
                                    FRAME_CONTEXT *fc, FRAME_COUNTS *counts) {
186
187
188
189
190
191
192
193
194
195
196
197
198
199
  const TX_SIZE txs_ctx = get_txsize_context(tx_size);
  const PLANE_TYPE plane_type = get_plane_type(plane);
  const TX_CLASS tx_class = get_tx_class(tx_type);
  const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2;
  const int width = tx_size_wide[tx_size];
  const int height = tx_size_high[tx_size];
  int16_t eob_ls[MAX_HVTX_SIZE];
  int eob = 0;
#if !LV_MAP_PROB
  aom_prob *nz_map = fc->nz_map[txs_ctx][plane_type];
#endif
  for (int row = 0; row < height; ++row) {
    int el_ctx = get_empty_line_ctx(row, eob_ls);
#if LV_MAP_PROB
200
    int empty_line = av1_read_record_bin(
201
        counts, r, fc->empty_line_cdf[txs_ctx][plane_type][tx_class][el_ctx], 2,
202
203
204
205
206
207
208
209
210
211
212
        ACCT_STR);
#else
    int empty_line = aom_read(
        r, fc->empty_line[txs_ctx][plane_type][tx_class][el_ctx], ACCT_STR);
#endif
    if (counts)
      ++counts->empty_line[txs_ctx][plane_type][tx_class][el_ctx][empty_line];
    if (!empty_line) {
      int col;
      for (col = 0; col < width; ++col) {
        if (col + 1 != width) {
213
214
215
          int coeff_idx = row * width + col;
          int scan_idx = iscan[coeff_idx];
          int coeff_ctx =
Linfeng Zhang's avatar
Linfeng Zhang committed
216
              get_nz_map_ctx(levels, scan_idx, scan, bwl, height, tx_type, 1);
217
#if LV_MAP_PROB
218
          int is_nz = av1_read_record_bin(
219
220
              counts, r, fc->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2,
              ACCT_STR);
221
222
223
224
#else
          int is_nz = aom_read(r, nz_map[coeff_ctx], ACCT_STR);
#endif
          if (counts) ++counts->nz_map[txs_ctx][plane_type][coeff_ctx][is_nz];
Linfeng Zhang's avatar
Linfeng Zhang committed
225
          levels[coeff_idx] = is_nz;
226
227
228
229
          if (is_nz) {
            eob = AOMMAX(eob, iscan[coeff_idx] + 1);
            int eob_ctx = get_hv_eob_ctx(row, col, eob_ls);
#if LV_MAP_PROB
230
            int is_eob = av1_read_record_bin(
231
232
                counts, r,
                fc->hv_eob_cdf[txs_ctx][plane_type][tx_class][eob_ctx], 2,
233
234
235
236
237
238
239
240
241
242
243
                ACCT_STR);
#else
            int is_eob =
                aom_read(r, fc->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx],
                         ACCT_STR);
#endif
            if (counts)
              ++counts->hv_eob[txs_ctx][plane_type][tx_class][eob_ctx][is_eob];
            if (is_eob) break;
          }
        } else {
244
          int coeff_idx = row * width + col;
Linfeng Zhang's avatar
Linfeng Zhang committed
245
          levels[coeff_idx] = 1;
246
247
248
249
250
251
252
253
254
255
256
257
          eob = AOMMAX(eob, iscan[coeff_idx] + 1);
        }
      }
      eob_ls[row] = AOMMIN(width, col + 1);
    } else {
      eob_ls[row] = 0;
    }
  }
  return eob;
}
#endif

Dake He's avatar
Dake He committed
258
259
260
261
262
263
264
265
static INLINE int rec_eob_pos(int16_t eob_token, int16_t extra) {
  int eob = k_eob_group_start[eob_token];
  if (eob > 2) {
    eob += extra;
  }
  return eob;
}

266
uint8_t av1_read_coeffs_txb(const AV1_COMMON *const cm, MACROBLOCKD *xd,
Jingning Han's avatar
Jingning Han committed
267
268
                            aom_reader *r, int blk_row, int blk_col, int block,
                            int plane, tran_low_t *tcoeffs, TXB_CTX *txb_ctx,
Jingning Han's avatar
Jingning Han committed
269
                            TX_SIZE tx_size, int16_t *max_scan_line, int *eob) {
270
  FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
271
  FRAME_COUNTS *counts = xd->counts;
272
  TX_SIZE txs_ctx = get_txsize_context(tx_size);
273
274
  PLANE_TYPE plane_type = get_plane_type(plane);
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
275
  const int seg_eob = tx_size_2d[tx_size];
276
  int c = 0;
277
  int update_eob = -1;
278
  const int16_t *const dequant = xd->plane[plane].seg_dequant[mbmi->segment_id];
279
  const int shift = av1_get_tx_scale(tx_size);
280
  const int bwl = b_width_log2_lookup[txsize_to_bsize[tx_size]] + 2;
281
  const int height = tx_size_high[tx_size];
282
  int cul_level = 0;
283
284
285
  uint8_t levels[64 * 64];
  int8_t signs[64 * 64];

286
287
  memset(tcoeffs, 0, sizeof(*tcoeffs) * seg_eob);

288
  int all_zero = av1_read_record_bin(
289
290
      counts, r, ec_ctx->txb_skip_cdf[txs_ctx][txb_ctx->txb_skip_ctx], 2,
      ACCT_STR);
Angie Chiang's avatar
Angie Chiang committed
291
  if (xd->counts)
292
    ++xd->counts->txb_skip[txs_ctx][txb_ctx->txb_skip_ctx][all_zero];
Angie Chiang's avatar
Angie Chiang committed
293

294
  *eob = 0;
Angie Chiang's avatar
Angie Chiang committed
295
296
  if (all_zero) {
    *max_scan_line = 0;
297
298
299
#if CONFIG_TXK_SEL
    if (plane == 0) mbmi->txk_type[(blk_row << 4) + blk_col] = DCT_DCT;
#endif
Angie Chiang's avatar
Angie Chiang committed
300
301
302
    return 0;
  }

Linfeng Zhang's avatar
Linfeng Zhang committed
303
  memset(levels, 0, sizeof(levels[0]) * seg_eob);
304
305
  memset(signs, 0, sizeof(signs[0]) * seg_eob);

Jingning Han's avatar
Jingning Han committed
306
307
  (void)blk_row;
  (void)blk_col;
Angie Chiang's avatar
Angie Chiang committed
308
#if CONFIG_TXK_SEL
309
310
  av1_read_tx_type(cm, xd, blk_row, blk_col, block, plane,
                   get_min_tx_size(tx_size), r);
Angie Chiang's avatar
Angie Chiang committed
311
#endif
312
313
  const TX_TYPE tx_type =
      av1_get_tx_type(plane_type, xd, blk_row, blk_col, block, tx_size);
Angie Chiang's avatar
Angie Chiang committed
314
  const SCAN_ORDER *const scan_order = get_scan(cm, tx_size, tx_type, mbmi);
315
  const int16_t *scan = scan_order->scan;
Angie Chiang's avatar
Angie Chiang committed
316

Dake He's avatar
Dake He committed
317
318
319
320
321
322
323
324
325
326
  unsigned int(*nz_map_count)[SIG_COEF_CONTEXTS][2] =
      (counts) ? &counts->nz_map[txs_ctx][plane_type] : NULL;
  int16_t dummy;
  int16_t max_eob_pt = get_eob_pos_token(seg_eob, &dummy);

  int16_t eob_extra = 0;
  int16_t eob_pt = 0;
  int is_equal = 0;

  for (int i = 1; i < max_eob_pt; i++) {
Jingning Han's avatar
Jingning Han committed
327
    int eob_pos_ctx = av1_get_eob_pos_ctx(tx_type, i);
Dake He's avatar
Dake He committed
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
    is_equal = av1_read_record_bin(
        counts, r, ec_ctx->eob_flag_cdf[txs_ctx][plane_type][eob_pos_ctx], 2,
        ACCT_STR);

    // aom_read_symbol(r,
    // ec_ctx->eob_flag_cdf[AOMMIN(txs_ctx,3)][plane_type][eob_pos_ctx], 2,
    // ACCT_STR);
    if (counts) ++counts->eob_flag[txs_ctx][plane_type][eob_pos_ctx][is_equal];

    if (is_equal) {
      eob_pt = i;
      break;
    }
  }
  if (is_equal == 0) {
    eob_pt = max_eob_pt;
  }

  // printf("Dec: ");
  if (k_eob_offset_bits[eob_pt] > 0) {
Angie Chiang's avatar
Angie Chiang committed
348
349
350
351
    int eob_shift = k_eob_offset_bits[eob_pt] - 1;
    int bit = av1_read_record_bin(
        counts, r, ec_ctx->eob_extra_cdf[txs_ctx][plane_type][eob_pt], 2,
        ACCT_STR);
Angie Chiang's avatar
Angie Chiang committed
352
    if (counts) ++counts->eob_extra[txs_ctx][plane_type][eob_pt][bit];
Angie Chiang's avatar
Angie Chiang committed
353
354
355
356
357
358
359
    if (bit) {
      eob_extra += (1 << eob_shift);
    }

    for (int i = 1; i < k_eob_offset_bits[eob_pt]; i++) {
      eob_shift = k_eob_offset_bits[eob_pt] - 1 - i;
      bit = av1_read_record_bit(counts, r, ACCT_STR);
Dake He's avatar
Dake He committed
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
      if (bit) {
        eob_extra += (1 << eob_shift);
      }
      //  printf("%d ", bit);
    }
  }
  *eob = rec_eob_pos(eob_pt, eob_extra);
  // printf("=>[%d, %d], (%d, %d)\n", seg_eob, *eob, eob_pt, eob_extra);

  for (int i = 0; i < *eob; ++i) {
    c = *eob - 1 - i;
    int is_nz;
    int coeff_ctx = get_nz_map_ctx(levels, c, scan, bwl, height, tx_type, 1);
    // int eob_ctx = get_eob_ctx(tcoeffs, scan[c], txs_ctx, tx_type);

    if (c < *eob - 1) {
      is_nz = av1_read_record_bin(
          counts, r, ec_ctx->nz_map_cdf[txs_ctx][plane_type][coeff_ctx], 2,
          ACCT_STR);
    } else {
      is_nz = 1;
    }

    // set non-zero coefficient map.
    levels[scan[c]] = is_nz;

    if (counts) ++(*nz_map_count)[coeff_ctx][is_nz];
  }

389
  *max_scan_line = *eob;
390
391
392
393

  int i;
  for (i = 0; i < NUM_BASE_LEVELS; ++i) {
    update_eob = 0;
394
    for (c = *eob - 1; c >= 0; --c) {
395
      uint8_t *const level = &levels[scan[c]];
396
397
      int ctx;

398
      if (*level <= i) continue;
399

400
      ctx = get_base_ctx(levels, scan[c], bwl, height, i + 1);
401

402
      if (av1_read_record_bin(
403
              counts, r, ec_ctx->coeff_base_cdf[txs_ctx][plane_type][i][ctx], 2,
Jingning Han's avatar
Jingning Han committed
404
              ACCT_STR)) {
405
        assert(*level == i + 1);
406
407
        cul_level += i + 1;

408
        if (counts) ++counts->coeff_base[txs_ctx][plane_type][i][ctx][1];
409
410
411

        continue;
      }
412
      *level = i + 2;
413
      if (counts) ++counts->coeff_base[txs_ctx][plane_type][i][ctx][0];
414
415
416
417
418
419

      // update the eob flag for coefficients with magnitude above 1.
      update_eob = AOMMAX(update_eob, c);
    }
  }

420
421
422
  // Loop to decode all signs in the transform block,
  // starting with the sign of the DC (if applicable)
  for (c = 0; c < *eob; ++c) {
423
    int8_t *const sign = &signs[scan[c]];
424
    if (levels[scan[c]] == 0) continue;
425
426
    if (c == 0) {
      int dc_sign_ctx = txb_ctx->dc_sign_ctx;
427
#if LV_MAP_PROB
428
      *sign = av1_read_record_bin(
429
          counts, r, ec_ctx->dc_sign_cdf[plane_type][dc_sign_ctx], 2, ACCT_STR);
430
431
432
#else
      *sign = aom_read(r, ec_ctx->dc_sign[plane_type][dc_sign_ctx], ACCT_STR);
#endif
433
      if (counts) ++counts->dc_sign[plane_type][dc_sign_ctx][*sign];
434
    } else {
435
      *sign = av1_read_record_bit(counts, r, ACCT_STR);
436
    }
437
438
439
440
441
442
443
444
  }

  for (c = update_eob; c >= 0; --c) {
    uint8_t *const level = &levels[scan[c]];
    int idx;
    int ctx;

    if (*level <= NUM_BASE_LEVELS) continue;
445

446
    ctx = get_br_ctx(levels, scan[c], bwl, height);
447

448
    for (idx = 0; idx < BASE_RANGE_SETS; ++idx) {
449
      if (av1_read_record_bin(
450
              counts, r, ec_ctx->coeff_br_cdf[txs_ctx][plane_type][idx][ctx], 2,
Jingning Han's avatar
Jingning Han committed
451
              ACCT_STR)) {
452
453
454
455
        int extra_bits = (1 << br_extra_bits[idx]) - 1;
        //        int br_offset = aom_read_literal(r, extra_bits, ACCT_STR);
        int br_offset = 0;
        int tok;
456
        if (counts) ++counts->coeff_br[txs_ctx][plane_type][idx][ctx][1];
457
        for (tok = 0; tok < extra_bits; ++tok) {
458
          if (av1_read_record_bin(
459
                  counts, r, ec_ctx->coeff_lps_cdf[txs_ctx][plane_type][ctx], 2,
Jingning Han's avatar
Jingning Han committed
460
                  ACCT_STR)) {
461
462
463
464
465
466
467
468
469
470
            br_offset = tok;
            if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][1];
            break;
          }
          if (counts) ++counts->coeff_lps[txs_ctx][plane_type][ctx][0];
        }
        if (tok == extra_bits) br_offset = extra_bits;

        int br_base = br_index_to_coeff[idx];

471
472
        *level = NUM_BASE_LEVELS + 1 + br_base + br_offset;
        cul_level += *level;
473
474
        break;
      }
475
      if (counts) ++counts->coeff_br[txs_ctx][plane_type][idx][ctx][0];
476
477
478
    }

    if (idx < BASE_RANGE_SETS) continue;
479
480

    // decode 0-th order Golomb code
481
482
483
484
    *level = COEFF_BASE_RANGE + 1 + NUM_BASE_LEVELS;
    // Save golomb in tcoeffs because adding it to level may incur overflow
    tcoeffs[scan[c]] = read_golomb(xd, r, counts);
    cul_level += *level + tcoeffs[scan[c]];
485
486
  }

487
  for (c = 0; c < *eob; ++c) {
488
489
    const int16_t dqv = (c == 0) ? dequant[0] : dequant[1];
    const int level = levels[scan[c]];
490
    const tran_low_t t = ((level + tcoeffs[scan[c]]) * dqv) >> shift;
491
#if CONFIG_SYMBOLRATE
492
    av1_record_coeff(counts, level);
493
#endif
494
    tcoeffs[scan[c]] = signs[scan[c]] ? -t : t;
495
496
497
498
499
500
501
502
503
  }

  cul_level = AOMMIN(63, cul_level);

  // DC value
  set_dc_sign(&cul_level, tcoeffs[0]);

  return cul_level;
}
Angie Chiang's avatar
Angie Chiang committed
504

505
uint8_t av1_read_coeffs_txb_facade(AV1_COMMON *cm, MACROBLOCKD *xd,
Angie Chiang's avatar
Angie Chiang committed
506
507
                                   aom_reader *r, int row, int col, int block,
                                   int plane, tran_low_t *tcoeffs,
Jingning Han's avatar
Jingning Han committed
508
509
                                   TX_SIZE tx_size, int16_t *max_scan_line,
                                   int *eob) {
Angie Chiang's avatar
Angie Chiang committed
510
  MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
511
  struct macroblockd_plane *pd = &xd->plane[plane];
Angie Chiang's avatar
Angie Chiang committed
512
513
514
515
516
517
518
519

  const BLOCK_SIZE bsize = mbmi->sb_type;
  const BLOCK_SIZE plane_bsize =
      AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));

  TXB_CTX txb_ctx;
  get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col,
              pd->left_context + row, &txb_ctx);
Jingning Han's avatar
Jingning Han committed
520
521
522
  uint8_t cul_level =
      av1_read_coeffs_txb(cm, xd, r, row, col, block, plane, tcoeffs, &txb_ctx,
                          tx_size, max_scan_line, eob);
523
524
#if CONFIG_ADAPT_SCAN
  PLANE_TYPE plane_type = get_plane_type(plane);
525
  TX_TYPE tx_type = av1_get_tx_type(plane_type, xd, row, col, block, tx_size);
526
527
528
529
  if (xd->counts && *eob > 0)
    av1_update_scan_count_facade(cm, xd->counts, tx_size, tx_type, pd->dqcoeff,
                                 *eob);
#endif
530
531
  av1_set_contexts(xd, pd, plane, tx_size, cul_level, col, row);
  return cul_level;
Angie Chiang's avatar
Angie Chiang committed
532
}