vp9_tokenize.c 35.5 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5
6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9
10
11
12
13
14
15
 */


#include <math.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
16
17
#include "vp9/encoder/vp9_onyx_int.h"
#include "vp9/encoder/vp9_tokenize.h"
John Koleszar's avatar
John Koleszar committed
18
19
#include "vpx_mem/vpx_mem.h"

20
21
22
#include "vp9/common/vp9_pred_common.h"
#include "vp9/common/vp9_seg_common.h"
#include "vp9/common/vp9_entropy.h"
23

John Koleszar's avatar
John Koleszar committed
24
/* Global event counters used for accumulating statistics across several
25
   compressions, then generating vp9_context.c = initial stats. */
John Koleszar's avatar
John Koleszar committed
26
27

#ifdef ENTROPY_STATS
28
29
30
vp9_coeff_accum context_counters_4x4[BLOCK_TYPES];
vp9_coeff_accum context_counters_8x8[BLOCK_TYPES];
vp9_coeff_accum context_counters_16x16[BLOCK_TYPES];
31
vp9_coeff_accum context_counters_32x32[BLOCK_TYPES];
32

33
34
35
extern vp9_coeff_stats tree_update_hist_4x4[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_8x8[BLOCK_TYPES];
extern vp9_coeff_stats tree_update_hist_16x16[BLOCK_TYPES];
36
extern vp9_coeff_stats tree_update_hist_32x32[BLOCK_TYPES];
37
38
#endif  /* ENTROPY_STATS */

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#if CONFIG_CODE_NONZEROCOUNT
#ifdef NZC_STATS
unsigned int nzc_counts_4x4[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
                           [NZC4X4_TOKENS];
unsigned int nzc_counts_8x8[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
                           [NZC8X8_TOKENS];
unsigned int nzc_counts_16x16[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
                             [NZC16X16_TOKENS];
unsigned int nzc_counts_32x32[MAX_NZC_CONTEXTS][REF_TYPES][BLOCK_TYPES]
                             [NZC32X32_TOKENS];
unsigned int nzc_pcat_counts[MAX_NZC_CONTEXTS][NZC_TOKENS_EXTRA]
                            [NZC_BITS_EXTRA][2];
#endif
#endif

John Koleszar's avatar
John Koleszar committed
54
static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2];
55
const TOKENVALUE *vp9_dct_value_tokens_ptr;
John Koleszar's avatar
John Koleszar committed
56
static int dct_value_cost[DCT_MAX_VALUE * 2];
57
const int *vp9_dct_value_cost_ptr;
58

John Koleszar's avatar
John Koleszar committed
59
static void fill_value_tokens() {
John Koleszar's avatar
John Koleszar committed
60

John Koleszar's avatar
John Koleszar committed
61
  TOKENVALUE *const t = dct_value_tokens + DCT_MAX_VALUE;
62
  vp9_extra_bit_struct *const e = vp9_extra_bits;
John Koleszar's avatar
John Koleszar committed
63

John Koleszar's avatar
John Koleszar committed
64
65
  int i = -DCT_MAX_VALUE;
  int sign = 1;
John Koleszar's avatar
John Koleszar committed
66

John Koleszar's avatar
John Koleszar committed
67
68
69
  do {
    if (!i)
      sign = 0;
John Koleszar's avatar
John Koleszar committed
70

John Koleszar's avatar
John Koleszar committed
71
72
73
    {
      const int a = sign ? -i : i;
      int eb = sign;
John Koleszar's avatar
John Koleszar committed
74

John Koleszar's avatar
John Koleszar committed
75
76
      if (a > 4) {
        int j = 4;
John Koleszar's avatar
John Koleszar committed
77

John Koleszar's avatar
John Koleszar committed
78
        while (++j < 11  &&  e[j].base_val <= a) {}
John Koleszar's avatar
John Koleszar committed
79

John Koleszar's avatar
John Koleszar committed
80
81
82
83
        t[i].Token = --j;
        eb |= (a - e[j].base_val) << 1;
      } else
        t[i].Token = a;
John Koleszar's avatar
John Koleszar committed
84

John Koleszar's avatar
John Koleszar committed
85
86
      t[i].Extra = eb;
    }
John Koleszar's avatar
John Koleszar committed
87

John Koleszar's avatar
John Koleszar committed
88
89
90
    // initialize the cost for extra bits for all possible coefficient value.
    {
      int cost = 0;
91
      vp9_extra_bit_struct *p = vp9_extra_bits + t[i].Token;
John Koleszar's avatar
John Koleszar committed
92

John Koleszar's avatar
John Koleszar committed
93
94
95
      if (p->base_val) {
        const int extra = t[i].Extra;
        const int Length = p->Len;
John Koleszar's avatar
John Koleszar committed
96

John Koleszar's avatar
John Koleszar committed
97
        if (Length)
98
          cost += treed_cost(p->tree, p->prob, extra >> 1, Length);
John Koleszar's avatar
John Koleszar committed
99

100
        cost += vp9_cost_bit(vp9_prob_half, extra & 1); /* sign */
John Koleszar's avatar
John Koleszar committed
101
102
        dct_value_cost[i + DCT_MAX_VALUE] = cost;
      }
John Koleszar's avatar
John Koleszar committed
103
104
105

    }

John Koleszar's avatar
John Koleszar committed
106
107
  } while (++i < DCT_MAX_VALUE);

108
109
  vp9_dct_value_tokens_ptr = dct_value_tokens + DCT_MAX_VALUE;
  vp9_dct_value_cost_ptr   = dct_value_cost + DCT_MAX_VALUE;
John Koleszar's avatar
John Koleszar committed
110
}
111

112
113
extern const int *vp9_get_coef_neighbors_handle(const int *scan, int *pad);

114
static void tokenize_b(VP9_COMP *cpi,
115
                       MACROBLOCKD *xd,
Yaowu Xu's avatar
Yaowu Xu committed
116
                       const int ib,
117
118
119
120
                       TOKENEXTRA **tp,
                       PLANE_TYPE type,
                       TX_SIZE tx_size,
                       int dry_run) {
121
  MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
Daniel Kang's avatar
Daniel Kang committed
122
  int pt; /* near block/prev token context index */
123
  int c = 0;
124
  const int eob = xd->eobs[ib];     /* one beyond last nonzero coeff */
Daniel Kang's avatar
Daniel Kang committed
125
  TOKENEXTRA *t = *tp;        /* store tokens starting here */
126
  int16_t *qcoeff_ptr = xd->qcoeff + 16 * ib;
127
  int seg_eob, default_eob, pad;
128
129
  const int segment_id = mbmi->segment_id;
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
130
  const int *scan, *nb;
131
132
  vp9_coeff_count *counts;
  vp9_coeff_probs *probs;
133
134
  const int ref = mbmi->ref_frame != INTRA_FRAME;
  ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;
135
  uint8_t token_cache[1024];
136
137
138
139
140
#if CONFIG_CODE_NONZEROCOUNT
  int zerosleft, nzc = 0;
  if (eob == 0)
    assert(xd->nzcs[ib] == 0);
#endif
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

  if (sb_type == BLOCK_SIZE_SB64X64) {
    a = (ENTROPY_CONTEXT *)xd->above_context +
                                             vp9_block2above_sb64[tx_size][ib];
    l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left_sb64[tx_size][ib];
    a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    a2 = a1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    l2 = l1 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    a3 = a2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    l3 = l2 + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
  } else if (sb_type == BLOCK_SIZE_SB32X32) {
    a = (ENTROPY_CONTEXT *)xd->above_context + vp9_block2above_sb[tx_size][ib];
    l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left_sb[tx_size][ib];
    a1 = a + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    l1 = l + sizeof(ENTROPY_CONTEXT_PLANES) / sizeof(ENTROPY_CONTEXT);
    a2 = a3 = l2 = l3 = NULL;
  } else {
    a = (ENTROPY_CONTEXT *)xd->above_context + vp9_block2above[tx_size][ib];
    l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left[tx_size][ib];
    a1 = l1 = a2 = l2 = a3 = l3 = NULL;
  }
163

164
165
  switch (tx_size) {
    default:
166
167
168
    case TX_4X4: {
      const TX_TYPE tx_type = (type == PLANE_TYPE_Y_WITH_DC) ?
                              get_tx_type_4x4(xd, ib) : DCT_DCT;
169
170
      a_ec = *a;
      l_ec = *l;
171
      seg_eob = 16;
172
      scan = vp9_default_zig_zag1d_4x4;
173
174
      if (tx_type != DCT_DCT) {
        if (tx_type == ADST_DCT) {
175
          scan = vp9_row_scan_4x4;
176
        } else if (tx_type == DCT_ADST) {
177
          scan = vp9_col_scan_4x4;
178
179
        }
      }
180
181
      counts = cpi->coef_counts_4x4;
      probs = cpi->common.fc.coef_probs_4x4;
182
      break;
183
    }
184
    case TX_8X8:
185
186
187
188
      a_ec = (a[0] + a[1]) != 0;
      l_ec = (l[0] + l[1]) != 0;
      seg_eob = 64;
      scan = vp9_default_zig_zag1d_8x8;
189
190
      counts = cpi->coef_counts_8x8;
      probs = cpi->common.fc.coef_probs_8x8;
191
192
      break;
    case TX_16X16:
Yaowu Xu's avatar
Yaowu Xu committed
193
194
195
      if (type != PLANE_TYPE_UV) {
        a_ec = (a[0] + a[1] + a[2] + a[3]) != 0;
        l_ec = (l[0] + l[1] + l[2] + l[3]) != 0;
196
197
198
      } else {
        a_ec = (a[0] + a[1] + a1[0] + a1[1]) != 0;
        l_ec = (l[0] + l[1] + l1[0] + l1[1]) != 0;
Yaowu Xu's avatar
Yaowu Xu committed
199
      }
200
      seg_eob = 256;
201
      scan = vp9_default_zig_zag1d_16x16;
202
203
      counts = cpi->coef_counts_16x16;
      probs = cpi->common.fc.coef_probs_16x16;
204
205
      break;
    case TX_32X32:
206
207
208
209
210
211
212
213
214
215
216
      if (type != PLANE_TYPE_UV) {
        a_ec = (a[0] + a[1] + a[2] + a[3] +
                a1[0] + a1[1] + a1[2] + a1[3]) != 0;
        l_ec = (l[0] + l[1] + l[2] + l[3] +
                l1[0] + l1[1] + l1[2] + l1[3]) != 0;
      } else {
        a_ec = (a[0] + a[1] + a1[0] + a1[1] +
                a2[0] + a2[1] + a3[0] + a3[1]) != 0;
        l_ec = (l[0] + l[1] + l1[0] + l1[1] +
                l2[0] + l2[1] + l3[0] + l3[1]) != 0;
      }
217
218
219
220
      seg_eob = 1024;
      scan = vp9_default_zig_zag1d_32x32;
      counts = cpi->coef_counts_32x32;
      probs = cpi->common.fc.coef_probs_32x32;
221
      break;
John Koleszar's avatar
John Koleszar committed
222
223
  }

Yaowu Xu's avatar
Yaowu Xu committed
224
  VP9_COMBINEENTROPYCONTEXTS(pt, a_ec, l_ec);
225
226
  nb = vp9_get_coef_neighbors_handle(scan, &pad);
  default_eob = seg_eob;
Yaowu Xu's avatar
Yaowu Xu committed
227

Paul Wilkins's avatar
Paul Wilkins committed
228
229
  if (vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP))
    seg_eob = 0;
John Koleszar's avatar
John Koleszar committed
230

231
  do {
232
    const int band = get_coef_band(scan, tx_size, c);
233
    int token;
234
235
236
237
    int v = 0;
#if CONFIG_CODE_NONZEROCOUNT
    zerosleft = seg_eob - xd->nzcs[ib] - c + nzc;
#endif
238
    if (c < eob) {
239
      const int rc = scan[c];
240
      v = qcoeff_ptr[rc];
241
242
      assert(-DCT_MAX_VALUE <= v  &&  v < DCT_MAX_VALUE);

243
244
      t->Extra = vp9_dct_value_tokens_ptr[v].Extra;
      token    = vp9_dct_value_tokens_ptr[v].Token;
245
    } else {
246
247
248
#if CONFIG_CODE_NONZEROCOUNT
      break;
#else
249
      token = DCT_EOB_TOKEN;
250
#endif
251
    }
John Koleszar's avatar
John Koleszar committed
252
253

    t->Token = token;
254
    t->context_tree = probs[type][ref][band][pt];
255
256
257
258
#if CONFIG_CODE_NONZEROCOUNT
    // Skip zero node if there are no zeros left
    t->skip_eob_node = 1 + (zerosleft == 0);
#else
259
    t->skip_eob_node = (c > 0) && (token_cache[c - 1] == 0);
260
#endif
261
    assert(vp9_coef_encodings[t->Token].Len - t->skip_eob_node > 0);
262
    if (!dry_run) {
263
      ++counts[type][ref][band][pt][token];
264
265
      if (!t->skip_eob_node)
        ++cpi->common.fc.eob_branch_counts[tx_size][type][ref][band][pt];
266
    }
267
268
269
#if CONFIG_CODE_NONZEROCOUNT
    nzc += (v != 0);
#endif
270
    token_cache[c] = token;
271

272
    pt = vp9_get_coef_context(scan, nb, pad, token_cache, c, default_eob);
273
    ++t;
274
  } while (c < eob && ++c < seg_eob);
275
276
277
#if CONFIG_CODE_NONZEROCOUNT
  assert(nzc == xd->nzcs[ib]);
#endif
278
279

  *tp = t;
280
  a_ec = l_ec = (c > 0); /* 0 <-> all coeff data is zero */
Yaowu Xu's avatar
Yaowu Xu committed
281
282
283
  a[0] = a_ec;
  l[0] = l_ec;

284
  if (tx_size == TX_8X8) {
Yaowu Xu's avatar
Yaowu Xu committed
285
286
287
    a[1] = a_ec;
    l[1] = l_ec;
  } else if (tx_size == TX_16X16) {
Yaowu Xu's avatar
Yaowu Xu committed
288
289
290
291
    if (type != PLANE_TYPE_UV) {
      a[1] = a[2] = a[3] = a_ec;
      l[1] = l[2] = l[3] = l_ec;
    } else {
292
293
      a1[0] = a1[1] = a[1] = a_ec;
      l1[0] = l1[1] = l[1] = l_ec;
Yaowu Xu's avatar
Yaowu Xu committed
294
    }
295
  } else if (tx_size == TX_32X32) {
296
297
298
299
300
301
302
303
304
305
306
    if (type != PLANE_TYPE_UV) {
      a[1] = a[2] = a[3] = a_ec;
      l[1] = l[2] = l[3] = l_ec;
      a1[0] = a1[1] = a1[2] = a1[3] = a_ec;
      l1[0] = l1[1] = l1[2] = l1[3] = l_ec;
    } else {
      a[1] = a1[0] = a1[1] = a_ec;
      l[1] = l1[0] = l1[1] = l_ec;
      a2[0] = a2[1] = a3[0] = a3[1] = a_ec;
      l2[0] = l2[1] = l3[0] = l3[1] = l_ec;
    }
Yaowu Xu's avatar
Yaowu Xu committed
307
  }
John Koleszar's avatar
John Koleszar committed
308
309
}

310
int vp9_mby_is_skippable_4x4(MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
311
312
  int skip = 1;
  int i = 0;
313

314
  for (i = 0; i < 16; i++)
315
    skip &= (!xd->eobs[i]);
316

John Koleszar's avatar
John Koleszar committed
317
  return skip;
318
}
319

320
int vp9_mbuv_is_skippable_4x4(MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
321
322
  int skip = 1;
  int i;
323

John Koleszar's avatar
John Koleszar committed
324
  for (i = 16; i < 24; i++)
325
    skip &= (!xd->eobs[i]);
John Koleszar's avatar
John Koleszar committed
326
  return skip;
327
328
}

329
330
static int mb_is_skippable_4x4(MACROBLOCKD *xd) {
  return (vp9_mby_is_skippable_4x4(xd) &
331
          vp9_mbuv_is_skippable_4x4(xd));
332
}
Yaowu Xu's avatar
Yaowu Xu committed
333

334
int vp9_mby_is_skippable_8x8(MACROBLOCKD *xd) {
John Koleszar's avatar
John Koleszar committed
335
336
  int skip = 1;
  int i = 0;
337

338
  for (i = 0; i < 16; i += 4)
339
    skip &= (!xd->eobs[i]);
340

John Koleszar's avatar
John Koleszar committed
341
  return skip;
342
}
343

344
int vp9_mbuv_is_skippable_8x8(MACROBLOCKD *xd) {
345
  return (!xd->eobs[16]) & (!xd->eobs[20]);
346
}
347

348
349
static int mb_is_skippable_8x8(MACROBLOCKD *xd) {
  return (vp9_mby_is_skippable_8x8(xd) &
350
          vp9_mbuv_is_skippable_8x8(xd));
Deb Mukherjee's avatar
Deb Mukherjee committed
351
352
}

353
354
static int mb_is_skippable_8x8_4x4uv(MACROBLOCKD *xd) {
  return (vp9_mby_is_skippable_8x8(xd) &
355
          vp9_mbuv_is_skippable_4x4(xd));
356
}
Yaowu Xu's avatar
Yaowu Xu committed
357

358
int vp9_mby_is_skippable_16x16(MACROBLOCKD *xd) {
359
  return (!xd->eobs[0]);
Daniel Kang's avatar
Daniel Kang committed
360
361
}

362
363
static int mb_is_skippable_16x16(MACROBLOCKD *xd) {
  return (vp9_mby_is_skippable_16x16(xd) & vp9_mbuv_is_skippable_8x8(xd));
Daniel Kang's avatar
Daniel Kang committed
364
}
365

366
int vp9_sby_is_skippable_32x32(MACROBLOCKD *xd) {
367
  return (!xd->eobs[0]);
368
369
370
}

int vp9_sbuv_is_skippable_16x16(MACROBLOCKD *xd) {
371
  return (!xd->eobs[64]) & (!xd->eobs[80]);
372
373
374
375
376
377
378
}

static int sb_is_skippable_32x32(MACROBLOCKD *xd) {
  return vp9_sby_is_skippable_32x32(xd) &&
         vp9_sbuv_is_skippable_16x16(xd);
}

379
int vp9_sby_is_skippable_16x16(MACROBLOCKD *xd) {
380
381
382
383
384
385
386
387
388
389
  int skip = 1;
  int i = 0;

  for (i = 0; i < 64; i += 16)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb_is_skippable_16x16(MACROBLOCKD *xd) {
390
  return vp9_sby_is_skippable_16x16(xd) & vp9_sbuv_is_skippable_16x16(xd);
391
392
}

393
int vp9_sby_is_skippable_8x8(MACROBLOCKD *xd) {
394
395
396
397
398
399
400
401
402
  int skip = 1;
  int i = 0;

  for (i = 0; i < 64; i += 4)
    skip &= (!xd->eobs[i]);

  return skip;
}

403
int vp9_sbuv_is_skippable_8x8(MACROBLOCKD *xd) {
404
405
406
407
408
409
410
411
412
413
  int skip = 1;
  int i = 0;

  for (i = 64; i < 96; i += 4)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb_is_skippable_8x8(MACROBLOCKD *xd) {
414
  return vp9_sby_is_skippable_8x8(xd) & vp9_sbuv_is_skippable_8x8(xd);
415
416
}

417
int vp9_sby_is_skippable_4x4(MACROBLOCKD *xd) {
418
419
420
421
422
423
424
425
426
  int skip = 1;
  int i = 0;

  for (i = 0; i < 64; i++)
    skip &= (!xd->eobs[i]);

  return skip;
}

427
int vp9_sbuv_is_skippable_4x4(MACROBLOCKD *xd) {
428
429
430
431
432
433
434
435
436
437
  int skip = 1;
  int i = 0;

  for (i = 64; i < 96; i++)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb_is_skippable_4x4(MACROBLOCKD *xd) {
438
  return vp9_sby_is_skippable_4x4(xd) & vp9_sbuv_is_skippable_4x4(xd);
439
440
}

441
442
443
444
445
446
447
448
449
void vp9_tokenize_sb(VP9_COMP *cpi,
                     MACROBLOCKD *xd,
                     TOKENEXTRA **t,
                     int dry_run) {
  VP9_COMMON * const cm = &cpi->common;
  MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
  TOKENEXTRA *t_backup = *t;
  const int mb_skip_context = vp9_get_pred_context(cm, xd, PRED_MBSKIP);
  const int segment_id = mbmi->segment_id;
Paul Wilkins's avatar
Paul Wilkins committed
450
  const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
451
452
  int b;

453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
  switch (mbmi->txfm_size) {
    case TX_32X32:
      mbmi->mb_skip_coeff = sb_is_skippable_32x32(xd);
      break;
    case TX_16X16:
      mbmi->mb_skip_coeff = sb_is_skippable_16x16(xd);
      break;
    case TX_8X8:
      mbmi->mb_skip_coeff = sb_is_skippable_8x8(xd);
      break;
    case TX_4X4:
      mbmi->mb_skip_coeff = sb_is_skippable_4x4(xd);
      break;
    default: assert(0);
  }
468
469
470
471
472
473
474

  if (mbmi->mb_skip_coeff) {
    if (!dry_run)
      cpi->skip_true_count[mb_skip_context] += skip_inc;
    if (!cm->mb_no_coeff_skip) {
      vp9_stuff_sb(cpi, xd, t, dry_run);
    } else {
475
      vp9_reset_sb_tokens_context(xd);
476
477
478
479
480
481
482
483
484
    }
    if (dry_run)
      *t = t_backup;
    return;
  }

  if (!dry_run)
    cpi->skip_false_count[mb_skip_context] += skip_inc;

485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
  switch (mbmi->txfm_size) {
    case TX_32X32:
      tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC,
                 TX_32X32, dry_run);
      for (b = 64; b < 96; b += 16)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_16X16, dry_run);
      break;
    case TX_16X16:
      for (b = 0; b < 64; b += 16)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_16X16, dry_run);
      for (b = 64; b < 96; b += 16)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_16X16, dry_run);
      break;
    case TX_8X8:
      for (b = 0; b < 64; b += 4)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_8X8, dry_run);
      for (b = 64; b < 96; b += 4)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_8X8, dry_run);
      break;
    case TX_4X4:
      for (b = 0; b < 64; b++)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_4X4, dry_run);
      for (b = 64; b < 96; b++)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_4X4, dry_run);
      break;
    default: assert(0);
  }
519

520
521
522
523
  if (dry_run)
    *t = t_backup;
}

524
int vp9_sb64y_is_skippable_32x32(MACROBLOCKD *xd) {
525
526
527
528
529
530
531
532
533
534
535
536
537
538
  int skip = 1;
  int i = 0;

  for (i = 0; i < 256; i += 64)
    skip &= (!xd->eobs[i]);

  return skip;
}

int vp9_sb64uv_is_skippable_32x32(MACROBLOCKD *xd) {
  return (!xd->eobs[256]) & (!xd->eobs[320]);
}

static int sb64_is_skippable_32x32(MACROBLOCKD *xd) {
539
  return vp9_sb64y_is_skippable_32x32(xd) & vp9_sb64uv_is_skippable_32x32(xd);
540
541
}

542
int vp9_sb64y_is_skippable_16x16(MACROBLOCKD *xd) {
543
544
545
546
547
548
549
550
551
  int skip = 1;
  int i = 0;

  for (i = 0; i < 256; i += 16)
    skip &= (!xd->eobs[i]);

  return skip;
}

552
int vp9_sb64uv_is_skippable_16x16(MACROBLOCKD *xd) {
553
554
555
556
557
558
559
560
561
562
  int skip = 1;
  int i = 0;

  for (i = 256; i < 384; i += 16)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb64_is_skippable_16x16(MACROBLOCKD *xd) {
563
  return vp9_sb64y_is_skippable_16x16(xd) & vp9_sb64uv_is_skippable_16x16(xd);
564
565
}

566
int vp9_sb64y_is_skippable_8x8(MACROBLOCKD *xd) {
567
568
569
570
571
572
573
574
575
  int skip = 1;
  int i = 0;

  for (i = 0; i < 256; i += 4)
    skip &= (!xd->eobs[i]);

  return skip;
}

576
int vp9_sb64uv_is_skippable_8x8(MACROBLOCKD *xd) {
577
578
579
580
581
582
583
584
585
586
  int skip = 1;
  int i = 0;

  for (i = 256; i < 384; i += 4)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb64_is_skippable_8x8(MACROBLOCKD *xd) {
587
  return vp9_sb64y_is_skippable_8x8(xd) & vp9_sb64uv_is_skippable_8x8(xd);
588
589
}

590
int vp9_sb64y_is_skippable_4x4(MACROBLOCKD *xd) {
591
592
593
594
595
596
597
598
599
  int skip = 1;
  int i = 0;

  for (i = 0; i < 256; i++)
    skip &= (!xd->eobs[i]);

  return skip;
}

600
int vp9_sb64uv_is_skippable_4x4(MACROBLOCKD *xd) {
601
602
603
604
605
606
607
608
609
610
  int skip = 1;
  int i = 0;

  for (i = 256; i < 384; i++)
    skip &= (!xd->eobs[i]);

  return skip;
}

static int sb64_is_skippable_4x4(MACROBLOCKD *xd) {
611
  return vp9_sb64y_is_skippable_4x4(xd) & vp9_sb64uv_is_skippable_4x4(xd);
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
}

void vp9_tokenize_sb64(VP9_COMP *cpi,
                       MACROBLOCKD *xd,
                       TOKENEXTRA **t,
                       int dry_run) {
  VP9_COMMON * const cm = &cpi->common;
  MB_MODE_INFO * const mbmi = &xd->mode_info_context->mbmi;
  TOKENEXTRA *t_backup = *t;
  const int mb_skip_context = vp9_get_pred_context(cm, xd, PRED_MBSKIP);
  const int segment_id = mbmi->segment_id;
  const int skip_inc = !vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP);
  int b;

  switch (mbmi->txfm_size) {
    case TX_32X32:
      mbmi->mb_skip_coeff = sb64_is_skippable_32x32(xd);
      break;
    case TX_16X16:
      mbmi->mb_skip_coeff = sb64_is_skippable_16x16(xd);
      break;
    case TX_8X8:
      mbmi->mb_skip_coeff = sb64_is_skippable_8x8(xd);
      break;
    case TX_4X4:
      mbmi->mb_skip_coeff = sb64_is_skippable_4x4(xd);
      break;
    default: assert(0);
  }

  if (mbmi->mb_skip_coeff) {
    if (!dry_run)
      cpi->skip_true_count[mb_skip_context] += skip_inc;
    if (!cm->mb_no_coeff_skip) {
      vp9_stuff_sb64(cpi, xd, t, dry_run);
    } else {
      vp9_reset_sb64_tokens_context(xd);
    }
    if (dry_run)
      *t = t_backup;
    return;
  }

  if (!dry_run)
    cpi->skip_false_count[mb_skip_context] += skip_inc;

  switch (mbmi->txfm_size) {
    case TX_32X32:
      for (b = 0; b < 256; b += 64)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_32X32, dry_run);
      for (b = 256; b < 384; b += 64)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_32X32, dry_run);
      break;
    case TX_16X16:
      for (b = 0; b < 256; b += 16)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_16X16, dry_run);
      for (b = 256; b < 384; b += 16)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_16X16, dry_run);
      break;
    case TX_8X8:
      for (b = 0; b < 256; b += 4)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_8X8, dry_run);
      for (b = 256; b < 384; b += 4)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_8X8, dry_run);
      break;
    case TX_4X4:
      for (b = 0; b < 256; b++)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC,
                   TX_4X4, dry_run);
      for (b = 256; b < 384; b++)
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV,
                   TX_4X4, dry_run);
      break;
    default: assert(0);
692
  }
693

694
695
696
697
  if (dry_run)
    *t = t_backup;
}

698
void vp9_tokenize_mb(VP9_COMP *cpi,
Paul Wilkins's avatar
Paul Wilkins committed
699
                     MACROBLOCKD *xd,
700
701
                     TOKENEXTRA **t,
                     int dry_run) {
John Koleszar's avatar
John Koleszar committed
702
  int b;
703
  int tx_size = xd->mode_info_context->mbmi.txfm_size;
Paul Wilkins's avatar
Paul Wilkins committed
704
  int mb_skip_context = vp9_get_pred_context(&cpi->common, xd, PRED_MBSKIP);
705
  TOKENEXTRA *t_backup = *t;
Paul Wilkins's avatar
Paul Wilkins committed
706

John Koleszar's avatar
John Koleszar committed
707
708
709
710
  // If the MB is going to be skipped because of a segment level flag
  // exclude this from the skip count stats used to calculate the
  // transmitted skip probability;
  int skip_inc;
Paul Wilkins's avatar
Paul Wilkins committed
711
  int segment_id = xd->mode_info_context->mbmi.segment_id;
712

Paul Wilkins's avatar
Paul Wilkins committed
713
  if (!vp9_segfeature_active(xd, segment_id, SEG_LVL_SKIP)) {
John Koleszar's avatar
John Koleszar committed
714
715
716
    skip_inc = 1;
  } else
    skip_inc = 0;
717

718
  switch (tx_size) {
Daniel Kang's avatar
Daniel Kang committed
719
    case TX_16X16:
720

Daniel Kang's avatar
Daniel Kang committed
721
      xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(xd);
Daniel Kang's avatar
Daniel Kang committed
722
723
      break;
    case TX_8X8:
724
725
      if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
          xd->mode_info_context->mbmi.mode == SPLITMV)
726
        xd->mode_info_context->mbmi.mb_skip_coeff =
727
            mb_is_skippable_8x8_4x4uv(xd);
Deb Mukherjee's avatar
Deb Mukherjee committed
728
      else
729
        xd->mode_info_context->mbmi.mb_skip_coeff =
730
            mb_is_skippable_8x8(xd);
Daniel Kang's avatar
Daniel Kang committed
731
      break;
Deb Mukherjee's avatar
Deb Mukherjee committed
732

Daniel Kang's avatar
Daniel Kang committed
733
    default:
734
      xd->mode_info_context->mbmi.mb_skip_coeff =
735
          mb_is_skippable_4x4(xd);
Daniel Kang's avatar
Daniel Kang committed
736
737
      break;
  }
738

Paul Wilkins's avatar
Paul Wilkins committed
739
  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
740
741
    if (!dry_run)
      cpi->skip_true_count[mb_skip_context] += skip_inc;
John Koleszar's avatar
John Koleszar committed
742
    if (!cpi->common.mb_no_coeff_skip) {
743
      vp9_stuff_mb(cpi, xd, t, dry_run);
John Koleszar's avatar
John Koleszar committed
744
    } else {
Yaowu Xu's avatar
Yaowu Xu committed
745
      vp9_reset_mb_tokens_context(xd);
John Koleszar's avatar
John Koleszar committed
746
    }
Yaowu Xu's avatar
Yaowu Xu committed
747

748
749
    if (dry_run)
      *t = t_backup;
John Koleszar's avatar
John Koleszar committed
750
751
752
    return;
  }

753
754
  if (!dry_run)
    cpi->skip_false_count[mb_skip_context] += skip_inc;
755

756
  if (tx_size == TX_16X16) {
Yaowu Xu's avatar
Yaowu Xu committed
757
    tokenize_b(cpi, xd, 0, t, PLANE_TYPE_Y_WITH_DC, TX_16X16, dry_run);
Daniel Kang's avatar
Daniel Kang committed
758
    for (b = 16; b < 24; b += 4) {
Yaowu Xu's avatar
Yaowu Xu committed
759
      tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
Daniel Kang's avatar
Daniel Kang committed
760
    }
761
  } else if (tx_size == TX_8X8) {
John Koleszar's avatar
John Koleszar committed
762
    for (b = 0; b < 16; b += 4) {
763
      tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_8X8, dry_run);
John Koleszar's avatar
John Koleszar committed
764
    }
765
766
    if (xd->mode_info_context->mbmi.mode == I8X8_PRED ||
        xd->mode_info_context->mbmi.mode == SPLITMV) {
767
      for (b = 16; b < 24; b++) {
Yaowu Xu's avatar
Yaowu Xu committed
768
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
769
      }
770
    } else {
Deb Mukherjee's avatar
Deb Mukherjee committed
771
      for (b = 16; b < 24; b += 4) {
Yaowu Xu's avatar
Yaowu Xu committed
772
        tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_8X8, dry_run);
Deb Mukherjee's avatar
Deb Mukherjee committed
773
      }
774
    }
Jingning Han's avatar
Jingning Han committed
775
  } else {
776
777
778
779
    for (b = 0; b < 16; b++)
      tokenize_b(cpi, xd, b, t, PLANE_TYPE_Y_WITH_DC, TX_4X4, dry_run);
    for (b = 16; b < 24; b++)
      tokenize_b(cpi, xd, b, t, PLANE_TYPE_UV, TX_4X4, dry_run);
Jingning Han's avatar
Jingning Han committed
780
  }
781
782
  if (dry_run)
    *t = t_backup;
John Koleszar's avatar
John Koleszar committed
783
}
784

John Koleszar's avatar
John Koleszar committed
785
#ifdef ENTROPY_STATS
John Koleszar's avatar
John Koleszar committed
786
787
788
void init_context_counters(void) {
  FILE *f = fopen("context.bin", "rb");
  if (!f) {
789
    vpx_memset(context_counters_4x4, 0, sizeof(context_counters_4x4));
John Koleszar's avatar
John Koleszar committed
790
    vpx_memset(context_counters_8x8, 0, sizeof(context_counters_8x8));
Daniel Kang's avatar
Daniel Kang committed
791
    vpx_memset(context_counters_16x16, 0, sizeof(context_counters_16x16));
792
    vpx_memset(context_counters_32x32, 0, sizeof(context_counters_32x32));
John Koleszar's avatar
John Koleszar committed
793
  } else {
794
    fread(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
John Koleszar's avatar
John Koleszar committed
795
    fread(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
Daniel Kang's avatar
Daniel Kang committed
796
    fread(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
797
    fread(context_counters_32x32, sizeof(context_counters_32x32), 1, f);
John Koleszar's avatar
John Koleszar committed
798
799
800
801
802
    fclose(f);
  }

  f = fopen("treeupdate.bin", "rb");
  if (!f) {
803
    vpx_memset(tree_update_hist_4x4, 0, sizeof(tree_update_hist_4x4));
John Koleszar's avatar
John Koleszar committed
804
    vpx_memset(tree_update_hist_8x8, 0, sizeof(tree_update_hist_8x8));
Daniel Kang's avatar
Daniel Kang committed
805
    vpx_memset(tree_update_hist_16x16, 0, sizeof(tree_update_hist_16x16));
806
    vpx_memset(tree_update_hist_32x32, 0, sizeof(tree_update_hist_32x32));
John Koleszar's avatar
John Koleszar committed
807
  } else {
808
    fread(tree_update_hist_4x4, sizeof(tree_update_hist_4x4), 1, f);
John Koleszar's avatar
John Koleszar committed
809
    fread(tree_update_hist_8x8, sizeof(tree_update_hist_8x8), 1, f);
Daniel Kang's avatar
Daniel Kang committed
810
    fread(tree_update_hist_16x16, sizeof(tree_update_hist_16x16), 1, f);
811
    fread(tree_update_hist_32x32, sizeof(tree_update_hist_32x32), 1, f);
John Koleszar's avatar
John Koleszar committed
812
813
    fclose(f);
  }
John Koleszar's avatar
John Koleszar committed
814
815
}

816
817
static void print_counter(FILE *f, vp9_coeff_accum *context_counters,
                          int block_types, const char *header) {
818
  int type, ref, band, pt, t;
John Koleszar's avatar
John Koleszar committed
819

820
  fprintf(f, "static const vp9_coeff_count %s = {\n", header);
John Koleszar's avatar
John Koleszar committed
821

822
#define Comma(X) (X ? "," : "")
John Koleszar's avatar
John Koleszar committed
823
824
  type = 0;
  do {
825
    ref = 0;
John Koleszar's avatar
John Koleszar committed
826
827
    fprintf(f, "%s\n  { /* block Type %d */", Comma(type), type);
    do {
828
829
      fprintf(f, "%s\n    { /* %s */", Comma(type), ref ? "Inter" : "Intra");
      band = 0;
John Koleszar's avatar
John Koleszar committed
830
      do {
831
832
        fprintf(f, "%s\n      { /* Coeff Band %d */", Comma(band), band);
        pt = 0;
John Koleszar's avatar
John Koleszar committed
833
        do {
834
835
836
837
838
839
840
841
842
          fprintf(f, "%s\n        {", Comma(pt));

          t = 0;
          do {
            const int64_t x = context_counters[type][ref][band][pt][t];
            const int y = (int) x;

            assert(x == (int64_t) y);  /* no overflow handling yet */
            fprintf(f, "%s %d", Comma(t), y);
843
          } while (++t < 1 + MAX_ENTROPY_TOKENS);
844
845
846
847
          fprintf(f, "}");
        } while (++pt < PREV_COEF_CONTEXTS);
        fprintf(f, "\n      }");
      } while (++band < COEF_BANDS);
John Koleszar's avatar
John Koleszar committed
848
      fprintf(f, "\n    }");
849
    } while (++ref < REF_TYPES);
John Koleszar's avatar
John Koleszar committed
850
    fprintf(f, "\n  }");
851
  } while (++type < block_types);
Daniel Kang's avatar
Daniel Kang committed
852
  fprintf(f, "\n};\n");
853
}
854

855
856
static void print_probs(FILE *f, vp9_coeff_accum *context_counters,
                        int block_types, const char *header) {
857
  int type, ref, band, pt, t;
Daniel Kang's avatar
Daniel Kang committed
858

859
  fprintf(f, "static const vp9_coeff_probs %s = {", header);
860

John Koleszar's avatar
John Koleszar committed
861
  type = 0;
862
#define Newline(x, spaces) (x ? " " : "\n" spaces)
John Koleszar's avatar
John Koleszar committed
863
  do {
864
865
    fprintf(f, "%s%s{ /* block Type %d */",
            Comma(type), Newline(type, "  "), type);
866
    ref = 0;
John Koleszar's avatar
John Koleszar committed
867
    do {
868
869
870
      fprintf(f, "%s%s{ /* %s */",
              Comma(band), Newline(band, "    "), ref ? "Inter" : "Intra");
      band = 0;
John Koleszar's avatar
John Koleszar committed
871
      do {
872
873
874
        fprintf(f, "%s%s{ /* Coeff Band %d */",
                Comma(band), Newline(band, "      "), band);
        pt = 0;
John Koleszar's avatar
John Koleszar committed
875
        do {
876
          unsigned int branch_ct[ENTROPY_NODES][2];
877
          unsigned int coef_counts[MAX_ENTROPY_TOKENS + 1];
878
879
          vp9_prob coef_probs[ENTROPY_NODES];

880
881
882
          if (pt >= 3 && band == 0)
            break;
          for (t = 0; t < MAX_ENTROPY_TOKENS + 1; ++t)
883
            coef_counts[t] = context_counters[type][ref][band][pt][t];
884
885
          vp9_tree_probs_from_distribution(vp9_coef_tree, coef_probs,
                                           branch_ct, coef_counts, 0);
886
887
          branch_ct[0][1] = coef_counts[MAX_ENTROPY_TOKENS] - branch_ct[0][0];
          coef_probs[0] = get_binary_prob(branch_ct[0][0], branch_ct[0][1]);
888
889
890
891
892
893
894
895
896
897
898
          fprintf(f, "%s\n      {", Comma(pt));

          t = 0;
          do {
            fprintf(f, "%s %3d", Comma(t), coef_probs[t]);
          } while (++t < ENTROPY_NODES);

          fprintf(f, " }");
        } while (++pt < PREV_COEF_CONTEXTS);
        fprintf(f, "\n      }");
      } while (++band < COEF_BANDS);
John Koleszar's avatar
John Koleszar committed
899
      fprintf(f, "\n    }");
900
    } while (++ref < REF_TYPES);
John Koleszar's avatar
John Koleszar committed
901
    fprintf(f, "\n  }");
902
  } while (++type < block_types);
John Koleszar's avatar
John Koleszar committed
903
  fprintf(f, "\n};\n");
904
}
905

906
907
void print_context_counters() {
  FILE *f = fopen("vp9_context.c", "w");
908

909
910
  fprintf(f, "#include \"vp9_entropy.h\"\n");
  fprintf(f, "\n/* *** GENERATED FILE: DO NOT EDIT *** */\n\n");
John Koleszar's avatar
John Koleszar committed
911

912
  /* print counts */
913
  print_counter(f, context_counters_4x4, BLOCK_TYPES,
914
                "vp9_default_coef_counts_4x4[BLOCK_TYPES]");
915
  print_counter(f, context_counters_8x8, BLOCK_TYPES,
916
                "vp9_default_coef_counts_8x8[BLOCK_TYPES]");
917
  print_counter(f, context_counters_16x16, BLOCK_TYPES,
918
919
920
                "vp9_default_coef_counts_16x16[BLOCK_TYPES]");
  print_counter(f, context_counters_32x32, BLOCK_TYPES,
                "vp9_default_coef_counts_32x32[BLOCK_TYPES]");
Daniel Kang's avatar
Daniel Kang committed
921

922
  /* print coefficient probabilities */
923
  print_probs(f, context_counters_4x4, BLOCK_TYPES,
924
              "default_coef_probs_4x4[BLOCK_TYPES]");
925
  print_probs(f, context_counters_8x8, BLOCK_TYPES,
926
              "default_coef_probs_8x8[BLOCK_TYPES]");
927
  print_probs(f, context_counters_16x16, BLOCK_TYPES,
928
929
930
              "default_coef_probs_16x16[BLOCK_TYPES]");
  print_probs(f, context_counters_32x32, BLOCK_TYPES,
              "default_coef_probs_32x32[BLOCK_TYPES]");
Daniel Kang's avatar
Daniel Kang committed
931

John Koleszar's avatar
John Koleszar committed
932
933
934
  fclose(f);

  f = fopen("context.bin", "wb");
935
  fwrite(context_counters_4x4, sizeof(context_counters_4x4), 1, f);
John Koleszar's avatar
John Koleszar committed
936
  fwrite(context_counters_8x8, sizeof(context_counters_8x8), 1, f);
Daniel Kang's avatar
Daniel Kang committed
937
  fwrite(context_counters_16x16, sizeof(context_counters_16x16), 1, f);
938
  fwrite(context_counters_32x32, sizeof(context_counters_32x32), 1, f);
John Koleszar's avatar
John Koleszar committed
939
  fclose(f);
John Koleszar's avatar
John Koleszar committed
940
941
942
}
#endif

943
void vp9_tokenize_initialize() {
John Koleszar's avatar
John Koleszar committed
944
  fill_value_tokens();
John Koleszar's avatar
John Koleszar committed
945
946
}

947
948
949
950
951
952
953
static void stuff_b(VP9_COMP *cpi,
                    MACROBLOCKD *xd,
                    const int ib,
                    TOKENEXTRA **tp,
                    PLANE_TYPE type,
                    TX_SIZE tx_size,
                    int dry_run) {
954
955
956
  MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
  const BLOCK_SIZE_TYPE sb_type = mbmi->sb_type;
#if CONFIG_CODE_NONZEROCOUNT == 0
957
958
  vp9_coeff_count *counts;
  vp9_coeff_probs *probs;
959
960
  int pt, band;
  TOKENEXTRA *t = *tp;
961
  const int ref = mbmi->ref_frame != INTRA_FRAME;
962
#endif
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
  ENTROPY_CONTEXT *a, *l, *a1, *l1, *a2, *l2, *a3, *l3, a_ec, l_ec;

  if (sb_type == BLOCK_SIZE_SB32X32) {
    a = (ENTROPY_CONTEXT *)xd->above_context +
                                             vp9_block2above_sb64[tx_size][ib];
    l = (ENTROPY_CONTEXT *)xd->left_context + vp9_block2left_sb64[tx_size][ib];
    a1 = a +