/work/aom/av1/encoder/hybrid_fwd_txfm.c

Source
/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#include "config/aom_config.h"
#include "config/av1_rtcd.h"
#include "config/aom_dsp_rtcd.h"

#include "av1/common/idct.h"
#include "av1/common/blockd.h"
#include "av1/encoder/hybrid_fwd_txfm.h"

/* 4-point reversible, orthonormal Walsh-Hadamard in 3.5 adds, 0.5 shifts per
   pixel. */
void av1_fwht4x4_c(const int16_t *input, tran_low_t *output, int stride) {
  int i;
  tran_high_t a1, b1, c1, d1, e1;
  const int16_t *ip_pass0 = input;
  const tran_low_t *ip = NULL;
  tran_low_t *op = output;

  for (i = 0; i < 4; i++) {
    a1 = ip_pass0[0 * stride];
    b1 = ip_pass0[1 * stride];
    c1 = ip_pass0[2 * stride];
    d1 = ip_pass0[3 * stride];

    a1 += b1;
    d1 = d1 - c1;
    e1 = (a1 - d1) >> 1;
    b1 = e1 - b1;
    c1 = e1 - c1;
    a1 -= c1;
    d1 += b1;
    op[0] = (tran_low_t)a1;
    op[4] = (tran_low_t)c1;
    op[8] = (tran_low_t)d1;
    op[12] = (tran_low_t)b1;

    ip_pass0++;
    op++;
  }
  ip = output;
  op = output;

  for (i = 0; i < 4; i++) {
    a1 = ip[0];
    b1 = ip[1];
    c1 = ip[2];
    d1 = ip[3];

    a1 += b1;
    d1 -= c1;
    e1 = (a1 - d1) >> 1;
    b1 = e1 - b1;
    c1 = e1 - c1;
    a1 -= c1;
    d1 += b1;
    op[0] = (tran_low_t)(a1 * UNIT_QUANT_FACTOR);
    op[1] = (tran_low_t)(c1 * UNIT_QUANT_FACTOR);
    op[2] = (tran_low_t)(d1 * UNIT_QUANT_FACTOR);
    op[3] = (tran_low_t)(b1 * UNIT_QUANT_FACTOR);

    ip += 4;
    op += 4;
  }
}

void av1_highbd_fwht4x4_c(const int16_t *input, tran_low_t *output,
                          int stride) {
  av1_fwht4x4_c(input, output, stride);
}

static void highbd_fwd_txfm_4x4(const int16_t *src_diff, tran_low_t *coeff,
                                int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  if (txfm_param->lossless) {
    assert(tx_type == DCT_DCT);
    av1_highbd_fwht4x4(src_diff, coeff, diff_stride);
    return;
  }
  av1_fwd_txfm2d_4x4(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_4x8(const int16_t *src_diff, tran_low_t *coeff,
                                int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_4x8(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                     txfm_param->bd);
}

static void highbd_fwd_txfm_8x4(const int16_t *src_diff, tran_low_t *coeff,
                                int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_8x4(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                     txfm_param->bd);
}

static void highbd_fwd_txfm_8x16(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_8x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_16x8(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_16x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_16x32(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_16x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                       txfm_param->bd);
}

static void highbd_fwd_txfm_32x16(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_32x16(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                       txfm_param->bd);
}

#if !CONFIG_REALTIME_ONLY
static void highbd_fwd_txfm_16x4(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_16x4(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                      txfm_param->bd);
}

static void highbd_fwd_txfm_4x16(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_4x16(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                      txfm_param->bd);
}

static void highbd_fwd_txfm_32x8(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_32x8(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                      txfm_param->bd);
}

static void highbd_fwd_txfm_8x32(const int16_t *src_diff, tran_low_t *coeff,
                                 int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  av1_fwd_txfm2d_8x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                      txfm_param->bd);
}
#endif

static void highbd_fwd_txfm_8x8(const int16_t *src_diff, tran_low_t *coeff,
                                int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_8x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_16x16(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_16x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_32x32(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  int32_t *dst_coeff = (int32_t *)coeff;
  const TX_TYPE tx_type = txfm_param->tx_type;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_32x32(src_diff, dst_coeff, diff_stride, tx_type, bd);
}

static void highbd_fwd_txfm_32x64(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  assert(txfm_param->tx_type == DCT_DCT);
  int32_t *dst_coeff = (int32_t *)coeff;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_32x64(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                       bd);
}

static void highbd_fwd_txfm_64x32(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  assert(txfm_param->tx_type == DCT_DCT);
  int32_t *dst_coeff = (int32_t *)coeff;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_64x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
                       bd);
}

#if !CONFIG_REALTIME_ONLY
static void highbd_fwd_txfm_16x64(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  assert(txfm_param->tx_type == DCT_DCT);
  int32_t *dst_coeff = (int32_t *)coeff;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_16x64(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
}

static void highbd_fwd_txfm_64x16(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  assert(txfm_param->tx_type == DCT_DCT);
  int32_t *dst_coeff = (int32_t *)coeff;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_64x16(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
}
#endif

static void highbd_fwd_txfm_64x64(const int16_t *src_diff, tran_low_t *coeff,
                                  int diff_stride, TxfmParam *txfm_param) {
  assert(txfm_param->tx_type == DCT_DCT);
  int32_t *dst_coeff = (int32_t *)coeff;
  const int bd = txfm_param->bd;
  av1_fwd_txfm2d_64x64(src_diff, dst_coeff, diff_stride, DCT_DCT, bd);
}

void av1_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff, int diff_stride,
                  TxfmParam *txfm_param) {
  if (txfm_param->bd == 8)
    av1_lowbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
  else
    av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
}

void av1_lowbd_fwd_txfm_c(const int16_t *src_diff, tran_low_t *coeff,
                          int diff_stride, TxfmParam *txfm_param) {
  av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
}

void av1_highbd_fwd_txfm(const int16_t *src_diff, tran_low_t *coeff,
                         int diff_stride, TxfmParam *txfm_param) {
  assert(av1_ext_tx_used[txfm_param->tx_set_type][txfm_param->tx_type]);
  const TX_SIZE tx_size = txfm_param->tx_size;
  switch (tx_size) {
    case TX_64X64:
      highbd_fwd_txfm_64x64(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_32X64:
      highbd_fwd_txfm_32x64(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_64X32:
      highbd_fwd_txfm_64x32(src_diff, coeff, diff_stride, txfm_param);
      break;

    case TX_32X32:
      highbd_fwd_txfm_32x32(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_16X16:
      highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_8X8:
      highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_4X8:
      highbd_fwd_txfm_4x8(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_8X4:
      highbd_fwd_txfm_8x4(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_8X16:
      highbd_fwd_txfm_8x16(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_16X8:
      highbd_fwd_txfm_16x8(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_16X32:
      highbd_fwd_txfm_16x32(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_32X16:
      highbd_fwd_txfm_32x16(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_4X4:
      highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, txfm_param);
      break;
#if !CONFIG_REALTIME_ONLY
    case TX_4X16:
      highbd_fwd_txfm_4x16(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_16X4:
      highbd_fwd_txfm_16x4(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_8X32:
      highbd_fwd_txfm_8x32(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_32X8:
      highbd_fwd_txfm_32x8(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_16X64:
      highbd_fwd_txfm_16x64(src_diff, coeff, diff_stride, txfm_param);
      break;
    case TX_64X16:
      highbd_fwd_txfm_64x16(src_diff, coeff, diff_stride, txfm_param);
      break;
#endif
    default: assert(0); break;
  }
}

void av1_quick_txfm(int use_hadamard, TX_SIZE tx_size, BitDepthInfo bd_info,
                    const int16_t *src_diff, int src_stride,
                    tran_low_t *coeff) {
  if (use_hadamard) {
    switch (tx_size) {
      case TX_4X4: aom_hadamard_4x4(src_diff, src_stride, coeff); break;
      case TX_8X8: aom_hadamard_8x8(src_diff, src_stride, coeff); break;
      case TX_16X16: aom_hadamard_16x16(src_diff, src_stride, coeff); break;
      case TX_32X32: aom_hadamard_32x32(src_diff, src_stride, coeff); break;
      default: assert(0);
    }
  } else {
    TxfmParam txfm_param;
    txfm_param.tx_type = DCT_DCT;
    txfm_param.tx_size = tx_size;
    txfm_param.lossless = 0;
    txfm_param.bd = bd_info.bit_depth;
    txfm_param.is_hbd = bd_info.use_highbitdepth_buf;
    txfm_param.tx_set_type = EXT_TX_SET_ALL16;
    av1_fwd_txfm(src_diff, coeff, src_stride, &txfm_param);
  }
}

Coverage Report

Created: 2026-06-15 06:25

Line	Count	Source
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	10.2M	void av1_fwht4x4_c(const int16_t input, tran_low_t output, int stride) {
23	10.2M	int i;
24	10.2M	tran_high_t a1, b1, c1, d1, e1;
25	10.2M	const int16_t *ip_pass0 = input;
26	10.2M	const tran_low_t *ip = NULL;
27	10.2M	tran_low_t *op = output;
28
29	51.0M	for (i = 0; i < 4; i++) {
30	40.8M	a1 = ip_pass0[0 * stride];
31	40.8M	b1 = ip_pass0[1 * stride];
32	40.8M	c1 = ip_pass0[2 * stride];
33	40.8M	d1 = ip_pass0[3 * stride];
34
35	40.8M	a1 += b1;
36	40.8M	d1 = d1 - c1;
37	40.8M	e1 = (a1 - d1) >> 1;
38	40.8M	b1 = e1 - b1;
39	40.8M	c1 = e1 - c1;
40	40.8M	a1 -= c1;
41	40.8M	d1 += b1;
42	40.8M	op[0] = (tran_low_t)a1;
43	40.8M	op[4] = (tran_low_t)c1;
44	40.8M	op[8] = (tran_low_t)d1;
45	40.8M	op[12] = (tran_low_t)b1;
46
47	40.8M	ip_pass0++;
48	40.8M	op++;
49	40.8M	}
50	10.2M	ip = output;
51	10.2M	op = output;
52
53	51.0M	for (i = 0; i < 4; i++) {
54	40.8M	a1 = ip[0];
55	40.8M	b1 = ip[1];
56	40.8M	c1 = ip[2];
57	40.8M	d1 = ip[3];
58
59	40.8M	a1 += b1;
60	40.8M	d1 -= c1;
61	40.8M	e1 = (a1 - d1) >> 1;
62	40.8M	b1 = e1 - b1;
63	40.8M	c1 = e1 - c1;
64	40.8M	a1 -= c1;
65	40.8M	d1 += b1;
66	40.8M	op[0] = (tran_low_t)(a1 * UNIT_QUANT_FACTOR);
67	40.8M	op[1] = (tran_low_t)(c1 * UNIT_QUANT_FACTOR);
68	40.8M	op[2] = (tran_low_t)(d1 * UNIT_QUANT_FACTOR);
69	40.8M	op[3] = (tran_low_t)(b1 * UNIT_QUANT_FACTOR);
70
71	40.8M	ip += 4;
72	40.8M	op += 4;
73	40.8M	}
74	10.2M	}
75
76		void av1_highbd_fwht4x4_c(const int16_t input, tran_low_t output,
77	10.2M	int stride) {
78	10.2M	av1_fwht4x4_c(input, output, stride);
79	10.2M	}
80
81		static void highbd_fwd_txfm_4x4(const int16_t src_diff, tran_low_t coeff,
82	10.3M	int diff_stride, TxfmParam *txfm_param) {
83	10.3M	int32_t dst_coeff = (int32_t )coeff;
84	10.3M	const TX_TYPE tx_type = txfm_param->tx_type;
85	10.3M	const int bd = txfm_param->bd;
86	10.3M	if (txfm_param->lossless) {
87	10.2M	assert(tx_type == DCT_DCT);
88	10.2M	av1_highbd_fwht4x4(src_diff, coeff, diff_stride);
89	10.2M	return;
90	10.2M	}
91	133k	av1_fwd_txfm2d_4x4(src_diff, dst_coeff, diff_stride, tx_type, bd);
92	133k	}
93
94		static void highbd_fwd_txfm_4x8(const int16_t src_diff, tran_low_t coeff,
95	20.7k	int diff_stride, TxfmParam *txfm_param) {
96	20.7k	int32_t dst_coeff = (int32_t )coeff;
97	20.7k	av1_fwd_txfm2d_4x8(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
98	20.7k	txfm_param->bd);
99	20.7k	}
100
101		static void highbd_fwd_txfm_8x4(const int16_t src_diff, tran_low_t coeff,
102	29.0k	int diff_stride, TxfmParam *txfm_param) {
103	29.0k	int32_t dst_coeff = (int32_t )coeff;
104	29.0k	av1_fwd_txfm2d_8x4(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
105	29.0k	txfm_param->bd);
106	29.0k	}
107
108		static void highbd_fwd_txfm_8x16(const int16_t src_diff, tran_low_t coeff,
109	55.8k	int diff_stride, TxfmParam *txfm_param) {
110	55.8k	int32_t dst_coeff = (int32_t )coeff;
111	55.8k	const TX_TYPE tx_type = txfm_param->tx_type;
112	55.8k	const int bd = txfm_param->bd;
113	55.8k	av1_fwd_txfm2d_8x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
114	55.8k	}
115
116		static void highbd_fwd_txfm_16x8(const int16_t src_diff, tran_low_t coeff,
117	76.7k	int diff_stride, TxfmParam *txfm_param) {
118	76.7k	int32_t dst_coeff = (int32_t )coeff;
119	76.7k	const TX_TYPE tx_type = txfm_param->tx_type;
120	76.7k	const int bd = txfm_param->bd;
121	76.7k	av1_fwd_txfm2d_16x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
122	76.7k	}
123
124		static void highbd_fwd_txfm_16x32(const int16_t src_diff, tran_low_t coeff,
125	24.4k	int diff_stride, TxfmParam *txfm_param) {
126	24.4k	int32_t dst_coeff = (int32_t )coeff;
127	24.4k	av1_fwd_txfm2d_16x32(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
128	24.4k	txfm_param->bd);
129	24.4k	}
130
131		static void highbd_fwd_txfm_32x16(const int16_t src_diff, tran_low_t coeff,
132	32.1k	int diff_stride, TxfmParam *txfm_param) {
133	32.1k	int32_t dst_coeff = (int32_t )coeff;
134	32.1k	av1_fwd_txfm2d_32x16(src_diff, dst_coeff, diff_stride, txfm_param->tx_type,
135	32.1k	txfm_param->bd);
136	32.1k	}
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	241k	int diff_stride, TxfmParam *txfm_param) {
170	241k	int32_t dst_coeff = (int32_t )coeff;
171	241k	const TX_TYPE tx_type = txfm_param->tx_type;
172	241k	const int bd = txfm_param->bd;
173	241k	av1_fwd_txfm2d_8x8(src_diff, dst_coeff, diff_stride, tx_type, bd);
174	241k	}
175
176		static void highbd_fwd_txfm_16x16(const int16_t src_diff, tran_low_t coeff,
177	292k	int diff_stride, TxfmParam *txfm_param) {
178	292k	int32_t dst_coeff = (int32_t )coeff;
179	292k	const TX_TYPE tx_type = txfm_param->tx_type;
180	292k	const int bd = txfm_param->bd;
181	292k	av1_fwd_txfm2d_16x16(src_diff, dst_coeff, diff_stride, tx_type, bd);
182	292k	}
183
184		static void highbd_fwd_txfm_32x32(const int16_t src_diff, tran_low_t coeff,
185	215k	int diff_stride, TxfmParam *txfm_param) {
186	215k	int32_t dst_coeff = (int32_t )coeff;
187	215k	const TX_TYPE tx_type = txfm_param->tx_type;
188	215k	const int bd = txfm_param->bd;
189	215k	av1_fwd_txfm2d_32x32(src_diff, dst_coeff, diff_stride, tx_type, bd);
190	215k	}
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	11.3M	TxfmParam *txfm_param) {
238	11.3M	if (txfm_param->bd == 8)
239	11.3M	av1_lowbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
240	18.4E	else
241	18.4E	av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
242	11.3M	}
243
244		void av1_lowbd_fwd_txfm_c(const int16_t src_diff, tran_low_t coeff,
245	11.3M	int diff_stride, TxfmParam *txfm_param) {
246	11.3M	av1_highbd_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
247	11.3M	}
248
249		void av1_highbd_fwd_txfm(const int16_t src_diff, tran_low_t coeff,
250	11.3M	int diff_stride, TxfmParam *txfm_param) {
251	11.3M	assert(av1_ext_tx_used[txfm_param->tx_set_type][txfm_param->tx_type]);
252	11.3M	const TX_SIZE tx_size = txfm_param->tx_size;
253	11.3M	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	215k	case TX_32X32:
265	215k	highbd_fwd_txfm_32x32(src_diff, coeff, diff_stride, txfm_param);
266	215k	break;
267	292k	case TX_16X16:
268	292k	highbd_fwd_txfm_16x16(src_diff, coeff, diff_stride, txfm_param);
269	292k	break;
270	241k	case TX_8X8:
271	241k	highbd_fwd_txfm_8x8(src_diff, coeff, diff_stride, txfm_param);
272	241k	break;
273	20.7k	case TX_4X8:
274	20.7k	highbd_fwd_txfm_4x8(src_diff, coeff, diff_stride, txfm_param);
275	20.7k	break;
276	29.0k	case TX_8X4:
277	29.0k	highbd_fwd_txfm_8x4(src_diff, coeff, diff_stride, txfm_param);
278	29.0k	break;
279	55.8k	case TX_8X16:
280	55.8k	highbd_fwd_txfm_8x16(src_diff, coeff, diff_stride, txfm_param);
281	55.8k	break;
282	76.7k	case TX_16X8:
283	76.7k	highbd_fwd_txfm_16x8(src_diff, coeff, diff_stride, txfm_param);
284	76.7k	break;
285	24.4k	case TX_16X32:
286	24.4k	highbd_fwd_txfm_16x32(src_diff, coeff, diff_stride, txfm_param);
287	24.4k	break;
288	32.1k	case TX_32X16:
289	32.1k	highbd_fwd_txfm_32x16(src_diff, coeff, diff_stride, txfm_param);
290	32.1k	break;
291	10.3M	case TX_4X4:
292	10.3M	highbd_fwd_txfm_4x4(src_diff, coeff, diff_stride, txfm_param);
293	10.3M	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	11.3M	}
316	11.3M	}
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	1.33M	tran_low_t *coeff) {
321	1.33M	if (use_hadamard) {
322	1.11M	switch (tx_size) {
323	0	case TX_4X4: aom_hadamard_4x4(src_diff, src_stride, coeff); break;
324	444k	case TX_8X8: aom_hadamard_8x8(src_diff, src_stride, coeff); break;
325	333k	case TX_16X16: aom_hadamard_16x16(src_diff, src_stride, coeff); break;
326	335k	case TX_32X32: aom_hadamard_32x32(src_diff, src_stride, coeff); break;
327	0	default: assert(0);
328	1.11M	}
329	1.11M	} else {
330	216k	TxfmParam txfm_param;
331	216k	txfm_param.tx_type = DCT_DCT;
332	216k	txfm_param.tx_size = tx_size;
333	216k	txfm_param.lossless = 0;
334	216k	txfm_param.bd = bd_info.bit_depth;
335	216k	txfm_param.is_hbd = bd_info.use_highbitdepth_buf;
336	216k	txfm_param.tx_set_type = EXT_TX_SET_ALL16;
337	216k	av1_fwd_txfm(src_diff, coeff, src_stride, &txfm_param);
338	216k	}
339	1.33M	}