Coverage Report

Created: 2025-06-13 07:07

/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
}
decodetxb.c:get_txb_bhl
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
}
decodetxb.c:get_txb_wide
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
}
decodetxb.c:get_txb_high
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
}
decodetxb.c:set_levels
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
}
decodetxb.c:get_br_ctx
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
}
decodetxb.c:get_nz_mag
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
}
decodetxb.c:set_dc_sign
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
}
decodetxb.c:get_txb_ctx
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_