Coverage Report

Created: 2022-08-24 06:17

/src/aom/av1/encoder/hybrid_fwd_txfm.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
3
 *
4
 * This source code is subject to the terms of the BSD 2 Clause License and
5
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
6
 * was not distributed with this source code in the LICENSE file, you can
7
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
8
 * Media Patent License 1.0 was not distributed with this source code in the
9
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
10
 */
11
12
#include "config/aom_config.h"
13
#include "config/av1_rtcd.h"
14
#include "config/aom_dsp_rtcd.h"
15
16
#include "av1/common/idct.h"
17
#include "av1/common/blockd.h"
18
#include "av1/encoder/hybrid_fwd_txfm.h"
19
20
/* 4-point reversible, orthonormal Walsh-Hadamard in 3.5 adds, 0.5 shifts per
21
   pixel. */
22
0
void av1_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride) {
23
0
  int i;
24
0
  tran_high_t a1, b1, c1, d1, e1;
25
0
  const int16_t *ip_pass0 = input;
26
0
  const tran_low_t *ip = NULL;
27
0
  tran_low_t *op = output;
28
29
0
  for (i = 0; i < 4; i++) {
30
0
    a1 = ip_pass0[0 * stride];
31
0
    b1 = ip_pass0[1 * stride];
32
0
    c1 = ip_pass0[2 * stride];
33
0
    d1 = ip_pass0[3 * stride];
34
35
0
    a1 += b1;
36
0
    d1 = d1 - c1;
37
0
    e1 = (a1 - d1) >> 1;
38
0
    b1 = e1 - b1;
39
0
    c1 = e1 - c1;
40
0
    a1 -= c1;
41
0
    d1 += b1;
42
0
    op[0] = (tran_low_t)a1;
43
0
    op[4] = (tran_low_t)c1;
44
0
    op[8] = (tran_low_t)d1;
45
0
    op[12] = (tran_low_t)b1;
46
47
0
    ip_pass0++;
48
0
    op++;
49
0
  }
50
0
  ip = output;
51
0
  op = output;
52
53
0
  for (i = 0; i < 4; i++) {
54
0
    a1 = ip[0];
55
0
    b1 = ip[1];
56
0
    c1 = ip[2];
57
0
    d1 = ip[3];
58
59
0
    a1 += b1;
60
0
    d1 -= c1;
61
0
    e1 = (a1 - d1) >> 1;
62
0
    b1 = e1 - b1;
63
0
    c1 = e1 - c1;
64
0
    a1 -= c1;
65
0
    d1 += b1;
66
0
    op[0] = (tran_low_t)(a1 * UNIT_QUANT_FACTOR);
67
0
    op[1] = (tran_low_t)(c1 * UNIT_QUANT_FACTOR);
68
0
    op[2] = (tran_low_t)(d1 * UNIT_QUANT_FACTOR);
69
0
    op[3] = (tran_low_t)(b1 * UNIT_QUANT_FACTOR);
70
71
0
    ip += 4;
72
0
    op += 4;
73
0
  }
74
0
}
75
76
void av1_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output,
77
0
                          int stride) {
78
0
  av1_fwht4x4_c(input, output, stride);
79
0
}
80
81
static void highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff,
82
0
                                int diff_stride, TxfmParam *txfm_param) {
83
0
  int32_t *dst_coeff = (int32_t *)coeff;
84
0
  const TX_TYPE tx_type = txfm_param->tx_type;
85
0
  const int bd = txfm_param->bd;
86
0
  if (txfm_param->lossless) {
87
0
    assert(tx_type == DCT_DCT);
88
0
    av1_highbd_fwht4x4(src_diff, coeff, diff_stride);
89
0
    return;
90
0
  }
91
0
  av1_fwd_txfm2d_4x4(src_diff, dst_coeff, diff_stride, tx_type, bd);
92
0
}
93
94
static void highbd_fwd_txfm_4x8(const int16_t *src_diff, tran_low_t *coeff,
95
0
                                int diff_stride, TxfmParam *txfm_param) {
96
0
  int32_t *dst_coeff = (int32_t *)coeff;
97
0
  av1_fwd_txfm2d_4x8(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
98
0
                     txfm_param->bd);
99
0
}
100
101
static void highbd_fwd_txfm_8x4(const int16_t *src_diff, tran_low_t *coeff,
102
0
                                int diff_stride, TxfmParam *txfm_param) {
103
0
  int32_t *dst_coeff = (int32_t *)coeff;
104
0
  av1_fwd_txfm2d_8x4(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
105
0
                     txfm_param->bd);
106
0
}
107
108
static void highbd_fwd_txfm_8x16(const int16_t *src_diff, tran_low_t *coeff,
109
0
                                 int diff_stride, TxfmParam *txfm_param) {
110
0
  int32_t *dst_coeff = (int32_t *)coeff;
111
0
  const TX_TYPE tx_type = txfm_param->tx_type;
112
0
  const int bd = txfm_param->bd;
113
0
  av1_fwd_txfm2d_8x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
114
0
}
115
116
static void highbd_fwd_txfm_16x8(const int16_t *src_diff, tran_low_t *coeff,
117
0
                                 int diff_stride, TxfmParam *txfm_param) {
118
0
  int32_t *dst_coeff = (int32_t *)coeff;
119
0
  const TX_TYPE tx_type = txfm_param->tx_type;
120
0
  const int bd = txfm_param->bd;
121
0
  av1_fwd_txfm2d_16x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
122
0
}
123
124
static void highbd_fwd_txfm_16x32(const int16_t *src_diff, tran_low_t *coeff,
125
0
                                  int diff_stride, TxfmParam *txfm_param) {
126
0
  int32_t *dst_coeff = (int32_t *)coeff;
127
0
  av1_fwd_txfm2d_16x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
128
0
                       txfm_param->bd);
129
0
}
130
131
static void highbd_fwd_txfm_32x16(const int16_t *src_diff, tran_low_t *coeff,
132
0
                                  int diff_stride, TxfmParam *txfm_param) {
133
0
  int32_t *dst_coeff = (int32_t *)coeff;
134
0
  av1_fwd_txfm2d_32x16(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
135
0
                       txfm_param->bd);
136
0
}
137
138
#if !CONFIG_REALTIME_ONLY
139
static void highbd_fwd_txfm_16x4(const int16_t *src_diff, tran_low_t *coeff,
140
0
                                 int diff_stride, TxfmParam *txfm_param) {
141
0
  int32_t *dst_coeff = (int32_t *)coeff;
142
0
  av1_fwd_txfm2d_16x4(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
143
0
                      txfm_param->bd);
144
0
}
145
146
static void highbd_fwd_txfm_4x16(const int16_t *src_diff, tran_low_t *coeff,
147
0
                                 int diff_stride, TxfmParam *txfm_param) {
148
0
  int32_t *dst_coeff = (int32_t *)coeff;
149
0
  av1_fwd_txfm2d_4x16(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
150
0
                      txfm_param->bd);
151
0
}
152
153
static void highbd_fwd_txfm_32x8(const int16_t *src_diff, tran_low_t *coeff,
154
0
                                 int diff_stride, TxfmParam *txfm_param) {
155
0
  int32_t *dst_coeff = (int32_t *)coeff;
156
0
  av1_fwd_txfm2d_32x8(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
157
0
                      txfm_param->bd);
158
0
}
159
160
static void highbd_fwd_txfm_8x32(const int16_t *src_diff, tran_low_t *coeff,
161
0
                                 int diff_stride, TxfmParam *txfm_param) {
162
0
  int32_t *dst_coeff = (int32_t *)coeff;
163
0
  av1_fwd_txfm2d_8x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
164
0
                      txfm_param->bd);
165
0
}
166
#endif
167
168
static void highbd_fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff,
169
0
                                int diff_stride, TxfmParam *txfm_param) {
170
0
  int32_t *dst_coeff = (int32_t *)coeff;
171
0
  const TX_TYPE tx_type = txfm_param->tx_type;
172
0
  const int bd = txfm_param->bd;
173
0
  av1_fwd_txfm2d_8x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
174
0
}
175
176
static void highbd_fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff,
177
0
                                  int diff_stride, TxfmParam *txfm_param) {
178
0
  int32_t *dst_coeff = (int32_t *)coeff;
179
0
  const TX_TYPE tx_type = txfm_param->tx_type;
180
0
  const int bd = txfm_param->bd;
181
0
  av1_fwd_txfm2d_16x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
182
0
}
183
184
static void highbd_fwd_txfm_32x32(const int16_t *src_diff, tran_low_t *coeff,
185
0
                                  int diff_stride, TxfmParam *txfm_param) {
186
0
  int32_t *dst_coeff = (int32_t *)coeff;
187
0
  const TX_TYPE tx_type = txfm_param->tx_type;
188
0
  const int bd = txfm_param->bd;
189
0
  av1_fwd_txfm2d_32x32(src_diff, dst_coeff, diff_stride, tx_type, bd);
190
0
}
191
192
static void highbd_fwd_txfm_32x64(const int16_t *src_diff, tran_low_t *coeff,
193
0
                                  int diff_stride, TxfmParam *txfm_param) {
194
0
  assert(txfm_param->tx_type == DCT_DCT);
195
0
  int32_t *dst_coeff = (int32_t *)coeff;
196
0
  const int bd = txfm_param->bd;
197
0
  av1_fwd_txfm2d_32x64(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
198
0
                       bd);
199
0
}
200
201
static void highbd_fwd_txfm_64x32(const int16_t *src_diff, tran_low_t *coeff,
202
0
                                  int diff_stride, TxfmParam *txfm_param) {
203
0
  assert(txfm_param->tx_type == DCT_DCT);
204
0
  int32_t *dst_coeff = (int32_t *)coeff;
205
0
  const int bd = txfm_param->bd;
206
0
  av1_fwd_txfm2d_64x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
207
0
                       bd);
208
0
}
209
210
#if !CONFIG_REALTIME_ONLY
211
static void highbd_fwd_txfm_16x64(const int16_t *src_diff, tran_low_t *coeff,
212
0
                                  int diff_stride, TxfmParam *txfm_param) {
213
0
  assert(txfm_param->tx_type == DCT_DCT);
214
0
  int32_t *dst_coeff = (int32_t *)coeff;
215
0
  const int bd = txfm_param->bd;
216
0
  av1_fwd_txfm2d_16x64(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
217
0
}
218
219
static void highbd_fwd_txfm_64x16(const int16_t *src_diff, tran_low_t *coeff,
220
0
                                  int diff_stride, TxfmParam *txfm_param) {
221
0
  assert(txfm_param->tx_type == DCT_DCT);
222
0
  int32_t *dst_coeff = (int32_t *)coeff;
223
0
  const int bd = txfm_param->bd;
224
0
  av1_fwd_txfm2d_64x16(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
225
0
}
226
#endif
227
228
static void highbd_fwd_txfm_64x64(const int16_t *src_diff, tran_low_t *coeff,
229
0
                                  int diff_stride, TxfmParam *txfm_param) {
230
0
  assert(txfm_param->tx_type == DCT_DCT);
231
0
  int32_t *dst_coeff = (int32_t *)coeff;
232
0
  const int bd = txfm_param->bd;
233
0
  av1_fwd_txfm2d_64x64(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
234
0
}
235
236
void av1_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, int diff_stride,
237
0
                  TxfmParam *txfm_param) {
238
0
  if (txfm_param->bd == 8)
239
0
    av1_lowbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
240
0
  else
241
0
    av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
242
0
}
243
244
void av1_lowbd_fwd_txfm_c(const int16_t *src_diff, tran_low_t *coeff,
245
0
                          int diff_stride, TxfmParam *txfm_param) {
246
0
  av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
247
0
}
248
249
void av1_highbd_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff,
250
0
                         int diff_stride, TxfmParam *txfm_param) {
251
0
  assert(av1_ext_tx_used[txfm_param->tx_set_type][txfm_param->tx_type]);
252
0
  const TX_SIZE tx_size = txfm_param->tx_size;
253
0
  switch (tx_size) {
254
0
    case TX_64X64:
255
0
      highbd_fwd_txfm_64x64(src_diff, coeff, diff_stride, txfm_param);
256
0
      break;
257
0
    case TX_32X64:
258
0
      highbd_fwd_txfm_32x64(src_diff, coeff, diff_stride, txfm_param);
259
0
      break;
260
0
    case TX_64X32:
261
0
      highbd_fwd_txfm_64x32(src_diff, coeff, diff_stride, txfm_param);
262
0
      break;
263
264
0
    case TX_32X32:
265
0
      highbd_fwd_txfm_32x32(src_diff, coeff, diff_stride, txfm_param);
266
0
      break;
267
0
    case TX_16X16:
268
0
      highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, txfm_param);
269
0
      break;
270
0
    case TX_8X8:
271
0
      highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, txfm_param);
272
0
      break;
273
0
    case TX_4X8:
274
0
      highbd_fwd_txfm_4x8(src_diff, coeff, diff_stride, txfm_param);
275
0
      break;
276
0
    case TX_8X4:
277
0
      highbd_fwd_txfm_8x4(src_diff, coeff, diff_stride, txfm_param);
278
0
      break;
279
0
    case TX_8X16:
280
0
      highbd_fwd_txfm_8x16(src_diff, coeff, diff_stride, txfm_param);
281
0
      break;
282
0
    case TX_16X8:
283
0
      highbd_fwd_txfm_16x8(src_diff, coeff, diff_stride, txfm_param);
284
0
      break;
285
0
    case TX_16X32:
286
0
      highbd_fwd_txfm_16x32(src_diff, coeff, diff_stride, txfm_param);
287
0
      break;
288
0
    case TX_32X16:
289
0
      highbd_fwd_txfm_32x16(src_diff, coeff, diff_stride, txfm_param);
290
0
      break;
291
0
    case TX_4X4:
292
0
      highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, txfm_param);
293
0
      break;
294
0
#if !CONFIG_REALTIME_ONLY
295
0
    case TX_4X16:
296
0
      highbd_fwd_txfm_4x16(src_diff, coeff, diff_stride, txfm_param);
297
0
      break;
298
0
    case TX_16X4:
299
0
      highbd_fwd_txfm_16x4(src_diff, coeff, diff_stride, txfm_param);
300
0
      break;
301
0
    case TX_8X32:
302
0
      highbd_fwd_txfm_8x32(src_diff, coeff, diff_stride, txfm_param);
303
0
      break;
304
0
    case TX_32X8:
305
0
      highbd_fwd_txfm_32x8(src_diff, coeff, diff_stride, txfm_param);
306
0
      break;
307
0
    case TX_16X64:
308
0
      highbd_fwd_txfm_16x64(src_diff, coeff, diff_stride, txfm_param);
309
0
      break;
310
0
    case TX_64X16:
311
0
      highbd_fwd_txfm_64x16(src_diff, coeff, diff_stride, txfm_param);
312
0
      break;
313
0
#endif
314
0
    default: assert(0); break;
315
0
  }
316
0
}
317
318
void av1_quick_txfm(int use_hadamard, TX_SIZE tx_size, BitDepthInfo bd_info,
319
                    const int16_t *src_diff, int src_stride,
320
0
                    tran_low_t *coeff) {
321
0
  if (use_hadamard) {
322
0
    switch (tx_size) {
323
0
      case TX_4X4: aom_hadamard_4x4(src_diff, src_stride, coeff); break;
324
0
      case TX_8X8: aom_hadamard_8x8(src_diff, src_stride, coeff); break;
325
0
      case TX_16X16: aom_hadamard_16x16(src_diff, src_stride, coeff); break;
326
0
      case TX_32X32: aom_hadamard_32x32(src_diff, src_stride, coeff); break;
327
0
      default: assert(0);
328
0
    }
329
0
  } else {
330
0
    TxfmParam txfm_param;
331
0
    txfm_param.tx_type = DCT_DCT;
332
0
    txfm_param.tx_size = tx_size;
333
0
    txfm_param.lossless = 0;
334
0
    txfm_param.bd = bd_info.bit_depth;
335
0
    txfm_param.is_hbd = bd_info.use_highbitdepth_buf;
336
0
    txfm_param.tx_set_type = EXT_TX_SET_ALL16;
337
0
    av1_fwd_txfm(src_diff, coeff, src_stride, &txfm_param);
338
0
  }
339
0
}