/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-05-30 06:10

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