/src/aom/aom_dsp/sad_av1.c

Source
/*
 * Copyright (c) 2017, 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 <stdlib.h>

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

#include "aom/aom_integer.h"
#include "aom_ports/mem.h"
#include "aom_dsp/blend.h"

static inline unsigned int masked_sad(const uint8_t *src, int src_stride,
                                      const uint8_t *a, int a_stride,
                                      const uint8_t *b, int b_stride,
                                      const uint8_t *m, int m_stride, int width,
                                      int height) {
  int y, x;
  unsigned int sad = 0;
  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++) {
      const int16_t pred = AOM_BLEND_A64(m[x], a[x], b[x]);
      sad += abs(pred - src[x]);
    }
    src += src_stride;
    a += a_stride;
    b += b_stride;
    m += m_stride;
  }
  return sad;
}

#define MASKSADMXN(m, n)                                                       \
  unsigned int aom_masked_sad##m##x##n##_c(                                    \
      const uint8_t *src, int src_stride, const uint8_t *ref, int ref_stride,  \
      const uint8_t *second_pred, const uint8_t *msk, int msk_stride,          \
      int invert_mask) {                                                       \
    if (!invert_mask)                                                          \
      return masked_sad(src, src_stride, ref, ref_stride, second_pred, m, msk, \
                        msk_stride, m, n);                                     \
    else                                                                       \
      return masked_sad(src, src_stride, second_pred, m, ref, ref_stride, msk, \
                        msk_stride, m, n);                                     \
  }

MASKSADMXN(128, 128)
MASKSADMXN(128, 64)
MASKSADMXN(64, 128)
MASKSADMXN(64, 64)
MASKSADMXN(64, 32)
MASKSADMXN(32, 64)
MASKSADMXN(32, 32)
MASKSADMXN(32, 16)
MASKSADMXN(16, 32)
MASKSADMXN(16, 16)
MASKSADMXN(16, 8)
MASKSADMXN(8, 16)
MASKSADMXN(8, 8)
MASKSADMXN(8, 4)
MASKSADMXN(4, 8)
MASKSADMXN(4, 4)
#if !CONFIG_REALTIME_ONLY
MASKSADMXN(4, 16)
MASKSADMXN(16, 4)
MASKSADMXN(8, 32)
MASKSADMXN(32, 8)
MASKSADMXN(16, 64)
MASKSADMXN(64, 16)
#endif  // !CONFIG_REALTIME_ONLY

#if CONFIG_AV1_HIGHBITDEPTH
static inline unsigned int highbd_masked_sad(const uint8_t *src8,
                                             int src_stride, const uint8_t *a8,
                                             int a_stride, const uint8_t *b8,
                                             int b_stride, const uint8_t *m,
                                             int m_stride, int width,
                                             int height) {
  int y, x;
  unsigned int sad = 0;
  const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
  const uint16_t *a = CONVERT_TO_SHORTPTR(a8);
  const uint16_t *b = CONVERT_TO_SHORTPTR(b8);

  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++) {
      const uint16_t pred = AOM_BLEND_A64(m[x], a[x], b[x]);
      sad += abs(pred - src[x]);
    }

    src += src_stride;
    a += a_stride;
    b += b_stride;
    m += m_stride;
  }

  return sad;
}

#define HIGHBD_MASKSADMXN(m, n)                                         \
  unsigned int aom_highbd_masked_sad##m##x##n##_c(                      \
      const uint8_t *src8, int src_stride, const uint8_t *ref8,         \
      int ref_stride, const uint8_t *second_pred8, const uint8_t *msk,  \
      int msk_stride, int invert_mask) {                                \
    if (!invert_mask)                                                   \
      return highbd_masked_sad(src8, src_stride, ref8, ref_stride,      \
                               second_pred8, m, msk, msk_stride, m, n); \
    else                                                                \
      return highbd_masked_sad(src8, src_stride, second_pred8, m, ref8, \
                               ref_stride, msk, msk_stride, m, n);      \
  }

HIGHBD_MASKSADMXN(128, 128)
HIGHBD_MASKSADMXN(128, 64)
HIGHBD_MASKSADMXN(64, 128)
HIGHBD_MASKSADMXN(64, 64)
HIGHBD_MASKSADMXN(64, 32)
HIGHBD_MASKSADMXN(32, 64)
HIGHBD_MASKSADMXN(32, 32)
HIGHBD_MASKSADMXN(32, 16)
HIGHBD_MASKSADMXN(16, 32)
HIGHBD_MASKSADMXN(16, 16)
HIGHBD_MASKSADMXN(16, 8)
HIGHBD_MASKSADMXN(8, 16)
HIGHBD_MASKSADMXN(8, 8)
HIGHBD_MASKSADMXN(8, 4)
HIGHBD_MASKSADMXN(4, 8)
HIGHBD_MASKSADMXN(4, 4)
#if !CONFIG_REALTIME_ONLY
HIGHBD_MASKSADMXN(4, 16)
HIGHBD_MASKSADMXN(16, 4)
HIGHBD_MASKSADMXN(8, 32)
HIGHBD_MASKSADMXN(32, 8)
HIGHBD_MASKSADMXN(16, 64)
HIGHBD_MASKSADMXN(64, 16)
#endif  // !CONFIG_REALTIME_ONLY
#endif  // CONFIG_AV1_HIGHBITDEPTH

#if !CONFIG_REALTIME_ONLY
// pre: predictor being evaluated
// wsrc: target weighted prediction (has been *4096 to keep precision)
// mask: 2d weights (scaled by 4096)
static inline unsigned int obmc_sad(const uint8_t *pre, int pre_stride,
                                    const int32_t *wsrc, const int32_t *mask,
                                    int width, int height) {
  int y, x;
  unsigned int sad = 0;

  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++)
      sad += ROUND_POWER_OF_TWO(abs(wsrc[x] - pre[x] * mask[x]), 12);

    pre += pre_stride;
    wsrc += width;
    mask += width;
  }

  return sad;
}

#define OBMCSADMXN(m, n)                                                     \
  unsigned int aom_obmc_sad##m##x##n##_c(const uint8_t *ref, int ref_stride, \
                                         const int32_t *wsrc,                \
                                         const int32_t *mask) {              \
    return obmc_sad(ref, ref_stride, wsrc, mask, m, n);                      \
  }

OBMCSADMXN(128, 128)
OBMCSADMXN(128, 64)
OBMCSADMXN(64, 128)
OBMCSADMXN(64, 64)
OBMCSADMXN(64, 32)
OBMCSADMXN(32, 64)
OBMCSADMXN(32, 32)
OBMCSADMXN(32, 16)
OBMCSADMXN(16, 32)
OBMCSADMXN(16, 16)
OBMCSADMXN(16, 8)
OBMCSADMXN(8, 16)
OBMCSADMXN(8, 8)
OBMCSADMXN(8, 4)
OBMCSADMXN(4, 8)
OBMCSADMXN(4, 4)
OBMCSADMXN(4, 16)
OBMCSADMXN(16, 4)
OBMCSADMXN(8, 32)
OBMCSADMXN(32, 8)
OBMCSADMXN(16, 64)
OBMCSADMXN(64, 16)

#if CONFIG_AV1_HIGHBITDEPTH
static inline unsigned int highbd_obmc_sad(const uint8_t *pre8, int pre_stride,
                                           const int32_t *wsrc,
                                           const int32_t *mask, int width,
                                           int height) {
  int y, x;
  unsigned int sad = 0;
  const uint16_t *pre = CONVERT_TO_SHORTPTR(pre8);

  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++)
      sad += ROUND_POWER_OF_TWO(abs(wsrc[x] - pre[x] * mask[x]), 12);

    pre += pre_stride;
    wsrc += width;
    mask += width;
  }

  return sad;
}

#define HIGHBD_OBMCSADMXN(m, n)                                \
  unsigned int aom_highbd_obmc_sad##m##x##n##_c(               \
      const uint8_t *ref, int ref_stride, const int32_t *wsrc, \
      const int32_t *mask) {                                   \
    return highbd_obmc_sad(ref, ref_stride, wsrc, mask, m, n); \
  }

HIGHBD_OBMCSADMXN(128, 128)
HIGHBD_OBMCSADMXN(128, 64)
HIGHBD_OBMCSADMXN(64, 128)
HIGHBD_OBMCSADMXN(64, 64)
HIGHBD_OBMCSADMXN(64, 32)
HIGHBD_OBMCSADMXN(32, 64)
HIGHBD_OBMCSADMXN(32, 32)
HIGHBD_OBMCSADMXN(32, 16)
HIGHBD_OBMCSADMXN(16, 32)
HIGHBD_OBMCSADMXN(16, 16)
HIGHBD_OBMCSADMXN(16, 8)
HIGHBD_OBMCSADMXN(8, 16)
HIGHBD_OBMCSADMXN(8, 8)
HIGHBD_OBMCSADMXN(8, 4)
HIGHBD_OBMCSADMXN(4, 8)
HIGHBD_OBMCSADMXN(4, 4)
HIGHBD_OBMCSADMXN(4, 16)
HIGHBD_OBMCSADMXN(16, 4)
HIGHBD_OBMCSADMXN(8, 32)
HIGHBD_OBMCSADMXN(32, 8)
HIGHBD_OBMCSADMXN(16, 64)
HIGHBD_OBMCSADMXN(64, 16)
#endif  // CONFIG_AV1_HIGHBITDEPTH
#endif  // !CONFIG_REALTIME_ONLY

Coverage Report

Created: 2026-04-01 07:49

Line	Count	Source
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		#include <stdlib.h>
13
14		#include "config/aom_config.h"
15		#include "config/aom_dsp_rtcd.h"
16
17		#include "aom/aom_integer.h"
18		#include "aom_ports/mem.h"
19		#include "aom_dsp/blend.h"
20
21		static inline unsigned int masked_sad(const uint8_t *src, int src_stride,
22		const uint8_t *a, int a_stride,
23		const uint8_t *b, int b_stride,
24		const uint8_t *m, int m_stride, int width,
25	0	int height) {
26	0	int y, x;
27	0	unsigned int sad = 0;
28	0	for (y = 0; y < height; y++) {
29	0	for (x = 0; x < width; x++) {
30	0	const int16_t pred = AOM_BLEND_A64(m[x], a[x], b[x]);
31	0	sad += abs(pred - src[x]);
32	0	}
33	0	src += src_stride;
34	0	a += a_stride;
35	0	b += b_stride;
36	0	m += m_stride;
37	0	}
38	0	return sad;
39	0	}
40
41		#define MASKSADMXN(m, n) \
42		unsigned int aom_masked_sad##m##x##n##_c( \
43		const uint8_t src, int src_stride, const uint8_t ref, int ref_stride, \
44		const uint8_t second_pred, const uint8_t msk, int msk_stride, \
45	0	int invert_mask) { \
46	0	if (!invert_mask) \
47	0	return masked_sad(src, src_stride, ref, ref_stride, second_pred, m, msk, \
48	0	msk_stride, m, n); \
49	0	else \
50	0	return masked_sad(src, src_stride, second_pred, m, ref, ref_stride, msk, \
51	0	msk_stride, m, n); \
52	0	} Unexecuted instantiation: aom_masked_sad128x128_c Unexecuted instantiation: aom_masked_sad128x64_c Unexecuted instantiation: aom_masked_sad64x128_c Unexecuted instantiation: aom_masked_sad64x64_c Unexecuted instantiation: aom_masked_sad64x32_c Unexecuted instantiation: aom_masked_sad32x64_c Unexecuted instantiation: aom_masked_sad32x32_c Unexecuted instantiation: aom_masked_sad32x16_c Unexecuted instantiation: aom_masked_sad16x32_c Unexecuted instantiation: aom_masked_sad16x16_c Unexecuted instantiation: aom_masked_sad16x8_c Unexecuted instantiation: aom_masked_sad8x16_c Unexecuted instantiation: aom_masked_sad8x8_c Unexecuted instantiation: aom_masked_sad8x4_c Unexecuted instantiation: aom_masked_sad4x8_c Unexecuted instantiation: aom_masked_sad4x4_c Unexecuted instantiation: aom_masked_sad4x16_c Unexecuted instantiation: aom_masked_sad16x4_c Unexecuted instantiation: aom_masked_sad8x32_c Unexecuted instantiation: aom_masked_sad32x8_c Unexecuted instantiation: aom_masked_sad16x64_c Unexecuted instantiation: aom_masked_sad64x16_c
53
54		MASKSADMXN(128, 128)
55		MASKSADMXN(128, 64)
56		MASKSADMXN(64, 128)
57		MASKSADMXN(64, 64)
58		MASKSADMXN(64, 32)
59		MASKSADMXN(32, 64)
60		MASKSADMXN(32, 32)
61		MASKSADMXN(32, 16)
62		MASKSADMXN(16, 32)
63		MASKSADMXN(16, 16)
64		MASKSADMXN(16, 8)
65		MASKSADMXN(8, 16)
66		MASKSADMXN(8, 8)
67		MASKSADMXN(8, 4)
68		MASKSADMXN(4, 8)
69		MASKSADMXN(4, 4)
70		#if !CONFIG_REALTIME_ONLY
71		MASKSADMXN(4, 16)
72		MASKSADMXN(16, 4)
73		MASKSADMXN(8, 32)
74		MASKSADMXN(32, 8)
75		MASKSADMXN(16, 64)
76		MASKSADMXN(64, 16)
77		#endif // !CONFIG_REALTIME_ONLY
78
79		#if CONFIG_AV1_HIGHBITDEPTH
80		static inline unsigned int highbd_masked_sad(const uint8_t *src8,
81		int src_stride, const uint8_t *a8,
82		int a_stride, const uint8_t *b8,
83		int b_stride, const uint8_t *m,
84		int m_stride, int width,
85	0	int height) {
86	0	int y, x;
87	0	unsigned int sad = 0;
88	0	const uint16_t *src = CONVERT_TO_SHORTPTR(src8);
89	0	const uint16_t *a = CONVERT_TO_SHORTPTR(a8);
90	0	const uint16_t *b = CONVERT_TO_SHORTPTR(b8);
91
92	0	for (y = 0; y < height; y++) {
93	0	for (x = 0; x < width; x++) {
94	0	const uint16_t pred = AOM_BLEND_A64(m[x], a[x], b[x]);
95	0	sad += abs(pred - src[x]);
96	0	}
97
98	0	src += src_stride;
99	0	a += a_stride;
100	0	b += b_stride;
101	0	m += m_stride;
102	0	}
103
104	0	return sad;
105	0	}
106
107		#define HIGHBD_MASKSADMXN(m, n) \
108		unsigned int aom_highbd_masked_sad##m##x##n##_c( \
109		const uint8_t src8, int src_stride, const uint8_t ref8, \
110		int ref_stride, const uint8_t second_pred8, const uint8_t msk, \
111	0	int msk_stride, int invert_mask) { \
112	0	if (!invert_mask) \
113	0	return highbd_masked_sad(src8, src_stride, ref8, ref_stride, \
114	0	second_pred8, m, msk, msk_stride, m, n); \
115	0	else \
116	0	return highbd_masked_sad(src8, src_stride, second_pred8, m, ref8, \
117	0	ref_stride, msk, msk_stride, m, n); \
118	0	} Unexecuted instantiation: aom_highbd_masked_sad128x128_c Unexecuted instantiation: aom_highbd_masked_sad128x64_c Unexecuted instantiation: aom_highbd_masked_sad64x128_c Unexecuted instantiation: aom_highbd_masked_sad64x64_c Unexecuted instantiation: aom_highbd_masked_sad64x32_c Unexecuted instantiation: aom_highbd_masked_sad32x64_c Unexecuted instantiation: aom_highbd_masked_sad32x32_c Unexecuted instantiation: aom_highbd_masked_sad32x16_c Unexecuted instantiation: aom_highbd_masked_sad16x32_c Unexecuted instantiation: aom_highbd_masked_sad16x16_c Unexecuted instantiation: aom_highbd_masked_sad16x8_c Unexecuted instantiation: aom_highbd_masked_sad8x16_c Unexecuted instantiation: aom_highbd_masked_sad8x8_c Unexecuted instantiation: aom_highbd_masked_sad8x4_c Unexecuted instantiation: aom_highbd_masked_sad4x8_c Unexecuted instantiation: aom_highbd_masked_sad4x4_c Unexecuted instantiation: aom_highbd_masked_sad4x16_c Unexecuted instantiation: aom_highbd_masked_sad16x4_c Unexecuted instantiation: aom_highbd_masked_sad8x32_c Unexecuted instantiation: aom_highbd_masked_sad32x8_c Unexecuted instantiation: aom_highbd_masked_sad16x64_c Unexecuted instantiation: aom_highbd_masked_sad64x16_c
119
120		HIGHBD_MASKSADMXN(128, 128)
121		HIGHBD_MASKSADMXN(128, 64)
122		HIGHBD_MASKSADMXN(64, 128)
123		HIGHBD_MASKSADMXN(64, 64)
124		HIGHBD_MASKSADMXN(64, 32)
125		HIGHBD_MASKSADMXN(32, 64)
126		HIGHBD_MASKSADMXN(32, 32)
127		HIGHBD_MASKSADMXN(32, 16)
128		HIGHBD_MASKSADMXN(16, 32)
129		HIGHBD_MASKSADMXN(16, 16)
130		HIGHBD_MASKSADMXN(16, 8)
131		HIGHBD_MASKSADMXN(8, 16)
132		HIGHBD_MASKSADMXN(8, 8)
133		HIGHBD_MASKSADMXN(8, 4)
134		HIGHBD_MASKSADMXN(4, 8)
135		HIGHBD_MASKSADMXN(4, 4)
136		#if !CONFIG_REALTIME_ONLY
137		HIGHBD_MASKSADMXN(4, 16)
138		HIGHBD_MASKSADMXN(16, 4)
139		HIGHBD_MASKSADMXN(8, 32)
140		HIGHBD_MASKSADMXN(32, 8)
141		HIGHBD_MASKSADMXN(16, 64)
142		HIGHBD_MASKSADMXN(64, 16)
143		#endif // !CONFIG_REALTIME_ONLY
144		#endif // CONFIG_AV1_HIGHBITDEPTH
145
146		#if !CONFIG_REALTIME_ONLY
147		// pre: predictor being evaluated
148		// wsrc: target weighted prediction (has been *4096 to keep precision)
149		// mask: 2d weights (scaled by 4096)
150		static inline unsigned int obmc_sad(const uint8_t *pre, int pre_stride,
151		const int32_t wsrc, const int32_t mask,
152	0	int width, int height) {
153	0	int y, x;
154	0	unsigned int sad = 0;
155
156	0	for (y = 0; y < height; y++) {
157	0	for (x = 0; x < width; x++)
158	0	sad += ROUND_POWER_OF_TWO(abs(wsrc[x] - pre[x] * mask[x]), 12);
159
160	0	pre += pre_stride;
161	0	wsrc += width;
162	0	mask += width;
163	0	}
164
165	0	return sad;
166	0	}
167
168		#define OBMCSADMXN(m, n) \
169		unsigned int aom_obmc_sad##m##x##n##_c(const uint8_t *ref, int ref_stride, \
170		const int32_t *wsrc, \
171	0	const int32_t *mask) { \
172	0	return obmc_sad(ref, ref_stride, wsrc, mask, m, n); \
173	0	} Unexecuted instantiation: aom_obmc_sad128x128_c Unexecuted instantiation: aom_obmc_sad128x64_c Unexecuted instantiation: aom_obmc_sad64x128_c Unexecuted instantiation: aom_obmc_sad64x64_c Unexecuted instantiation: aom_obmc_sad64x32_c Unexecuted instantiation: aom_obmc_sad32x64_c Unexecuted instantiation: aom_obmc_sad32x32_c Unexecuted instantiation: aom_obmc_sad32x16_c Unexecuted instantiation: aom_obmc_sad16x32_c Unexecuted instantiation: aom_obmc_sad16x16_c Unexecuted instantiation: aom_obmc_sad16x8_c Unexecuted instantiation: aom_obmc_sad8x16_c Unexecuted instantiation: aom_obmc_sad8x8_c Unexecuted instantiation: aom_obmc_sad8x4_c Unexecuted instantiation: aom_obmc_sad4x8_c Unexecuted instantiation: aom_obmc_sad4x4_c Unexecuted instantiation: aom_obmc_sad4x16_c Unexecuted instantiation: aom_obmc_sad16x4_c Unexecuted instantiation: aom_obmc_sad8x32_c Unexecuted instantiation: aom_obmc_sad32x8_c Unexecuted instantiation: aom_obmc_sad16x64_c Unexecuted instantiation: aom_obmc_sad64x16_c
174
175		OBMCSADMXN(128, 128)
176		OBMCSADMXN(128, 64)
177		OBMCSADMXN(64, 128)
178		OBMCSADMXN(64, 64)
179		OBMCSADMXN(64, 32)
180		OBMCSADMXN(32, 64)
181		OBMCSADMXN(32, 32)
182		OBMCSADMXN(32, 16)
183		OBMCSADMXN(16, 32)
184		OBMCSADMXN(16, 16)
185		OBMCSADMXN(16, 8)
186		OBMCSADMXN(8, 16)
187		OBMCSADMXN(8, 8)
188		OBMCSADMXN(8, 4)
189		OBMCSADMXN(4, 8)
190		OBMCSADMXN(4, 4)
191		OBMCSADMXN(4, 16)
192		OBMCSADMXN(16, 4)
193		OBMCSADMXN(8, 32)
194		OBMCSADMXN(32, 8)
195		OBMCSADMXN(16, 64)
196		OBMCSADMXN(64, 16)
197
198		#if CONFIG_AV1_HIGHBITDEPTH
199		static inline unsigned int highbd_obmc_sad(const uint8_t *pre8, int pre_stride,
200		const int32_t *wsrc,
201		const int32_t *mask, int width,
202	0	int height) {
203	0	int y, x;
204	0	unsigned int sad = 0;
205	0	const uint16_t *pre = CONVERT_TO_SHORTPTR(pre8);
206
207	0	for (y = 0; y < height; y++) {
208	0	for (x = 0; x < width; x++)
209	0	sad += ROUND_POWER_OF_TWO(abs(wsrc[x] - pre[x] * mask[x]), 12);
210
211	0	pre += pre_stride;
212	0	wsrc += width;
213	0	mask += width;
214	0	}
215
216	0	return sad;
217	0	}
218
219		#define HIGHBD_OBMCSADMXN(m, n) \
220		unsigned int aom_highbd_obmc_sad##m##x##n##_c( \
221		const uint8_t ref, int ref_stride, const int32_t wsrc, \
222	0	const int32_t *mask) { \
223	0	return highbd_obmc_sad(ref, ref_stride, wsrc, mask, m, n); \
224	0	} Unexecuted instantiation: aom_highbd_obmc_sad128x128_c Unexecuted instantiation: aom_highbd_obmc_sad128x64_c Unexecuted instantiation: aom_highbd_obmc_sad64x128_c Unexecuted instantiation: aom_highbd_obmc_sad64x64_c Unexecuted instantiation: aom_highbd_obmc_sad64x32_c Unexecuted instantiation: aom_highbd_obmc_sad32x64_c Unexecuted instantiation: aom_highbd_obmc_sad32x32_c Unexecuted instantiation: aom_highbd_obmc_sad32x16_c Unexecuted instantiation: aom_highbd_obmc_sad16x32_c Unexecuted instantiation: aom_highbd_obmc_sad16x16_c Unexecuted instantiation: aom_highbd_obmc_sad16x8_c Unexecuted instantiation: aom_highbd_obmc_sad8x16_c Unexecuted instantiation: aom_highbd_obmc_sad8x8_c Unexecuted instantiation: aom_highbd_obmc_sad8x4_c Unexecuted instantiation: aom_highbd_obmc_sad4x8_c Unexecuted instantiation: aom_highbd_obmc_sad4x4_c Unexecuted instantiation: aom_highbd_obmc_sad4x16_c Unexecuted instantiation: aom_highbd_obmc_sad16x4_c Unexecuted instantiation: aom_highbd_obmc_sad8x32_c Unexecuted instantiation: aom_highbd_obmc_sad32x8_c Unexecuted instantiation: aom_highbd_obmc_sad16x64_c Unexecuted instantiation: aom_highbd_obmc_sad64x16_c
225
226		HIGHBD_OBMCSADMXN(128, 128)
227		HIGHBD_OBMCSADMXN(128, 64)
228		HIGHBD_OBMCSADMXN(64, 128)
229		HIGHBD_OBMCSADMXN(64, 64)
230		HIGHBD_OBMCSADMXN(64, 32)
231		HIGHBD_OBMCSADMXN(32, 64)
232		HIGHBD_OBMCSADMXN(32, 32)
233		HIGHBD_OBMCSADMXN(32, 16)
234		HIGHBD_OBMCSADMXN(16, 32)
235		HIGHBD_OBMCSADMXN(16, 16)
236		HIGHBD_OBMCSADMXN(16, 8)
237		HIGHBD_OBMCSADMXN(8, 16)
238		HIGHBD_OBMCSADMXN(8, 8)
239		HIGHBD_OBMCSADMXN(8, 4)
240		HIGHBD_OBMCSADMXN(4, 8)
241		HIGHBD_OBMCSADMXN(4, 4)
242		HIGHBD_OBMCSADMXN(4, 16)
243		HIGHBD_OBMCSADMXN(16, 4)
244		HIGHBD_OBMCSADMXN(8, 32)
245		HIGHBD_OBMCSADMXN(32, 8)
246		HIGHBD_OBMCSADMXN(16, 64)
247		HIGHBD_OBMCSADMXN(64, 16)
248		#endif // CONFIG_AV1_HIGHBITDEPTH
249		#endif // !CONFIG_REALTIME_ONLY