The Tor Browser / file comparison

comparison: media/libyuv/source/row_any.cc

media/libyuv/source/row_any.cc

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:bcde446fa1a5
1 /*
2 * Copyright 2012 The LibYuv Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "libyuv/row.h"
12
13 #include "libyuv/basic_types.h"
14
15 #ifdef __cplusplus
16 namespace libyuv {
17 extern "C" {
18 #endif
19
20 // TODO(fbarchard): Consider 'any' functions handling any quantity of pixels.
21 // TODO(fbarchard): Consider 'any' functions handling odd alignment.
22 // YUV to RGB does multiple of 8 with SIMD and remainder with C.
23 #define YANY(NAMEANY, I420TORGB_SIMD, I420TORGB_C, UV_SHIFT, BPP, MASK) \
24 void NAMEANY(const uint8* y_buf, \
25 const uint8* u_buf, \
26 const uint8* v_buf, \
27 uint8* rgb_buf, \
28 int width) { \
29 int n = width & ~MASK; \
30 I420TORGB_SIMD(y_buf, u_buf, v_buf, rgb_buf, n); \
31 I420TORGB_C(y_buf + n, \
32 u_buf + (n >> UV_SHIFT), \
33 v_buf + (n >> UV_SHIFT), \
34 rgb_buf + n * BPP, width & MASK); \
35 }
36
37 #ifdef HAS_I422TOARGBROW_SSSE3
38 YANY(I444ToARGBRow_Any_SSSE3, I444ToARGBRow_Unaligned_SSSE3, I444ToARGBRow_C,
39 0, 4, 7)
40 YANY(I422ToARGBRow_Any_SSSE3, I422ToARGBRow_Unaligned_SSSE3, I422ToARGBRow_C,
41 1, 4, 7)
42 YANY(I411ToARGBRow_Any_SSSE3, I411ToARGBRow_Unaligned_SSSE3, I411ToARGBRow_C,
43 2, 4, 7)
44 YANY(I422ToBGRARow_Any_SSSE3, I422ToBGRARow_Unaligned_SSSE3, I422ToBGRARow_C,
45 1, 4, 7)
46 YANY(I422ToABGRRow_Any_SSSE3, I422ToABGRRow_Unaligned_SSSE3, I422ToABGRRow_C,
47 1, 4, 7)
48 YANY(I422ToRGBARow_Any_SSSE3, I422ToRGBARow_Unaligned_SSSE3, I422ToRGBARow_C,
49 1, 4, 7)
50 // I422ToRGB565Row_SSSE3 is unaligned.
51 YANY(I422ToARGB4444Row_Any_SSSE3, I422ToARGB4444Row_SSSE3, I422ToARGB4444Row_C,
52 1, 2, 7)
53 YANY(I422ToARGB1555Row_Any_SSSE3, I422ToARGB1555Row_SSSE3, I422ToARGB1555Row_C,
54 1, 2, 7)
55 YANY(I422ToRGB565Row_Any_SSSE3, I422ToRGB565Row_SSSE3, I422ToRGB565Row_C,
56 1, 2, 7)
57 // I422ToRGB24Row_SSSE3 is unaligned.
58 YANY(I422ToRGB24Row_Any_SSSE3, I422ToRGB24Row_SSSE3, I422ToRGB24Row_C, 1, 3, 7)
59 YANY(I422ToRAWRow_Any_SSSE3, I422ToRAWRow_SSSE3, I422ToRAWRow_C, 1, 3, 7)
60 YANY(I422ToYUY2Row_Any_SSE2, I422ToYUY2Row_SSE2, I422ToYUY2Row_C, 1, 2, 15)
61 YANY(I422ToUYVYRow_Any_SSE2, I422ToUYVYRow_SSE2, I422ToUYVYRow_C, 1, 2, 15)
62 #endif // HAS_I422TOARGBROW_SSSE3
63 #ifdef HAS_I422TOARGBROW_AVX2
64 YANY(I422ToARGBRow_Any_AVX2, I422ToARGBRow_AVX2, I422ToARGBRow_C, 1, 4, 15)
65 #endif // HAS_I422TOARGBROW_AVX2
66 #ifdef HAS_I422TOARGBROW_NEON
67 YANY(I444ToARGBRow_Any_NEON, I444ToARGBRow_NEON, I444ToARGBRow_C, 0, 4, 7)
68 YANY(I422ToARGBRow_Any_NEON, I422ToARGBRow_NEON, I422ToARGBRow_C, 1, 4, 7)
69 YANY(I411ToARGBRow_Any_NEON, I411ToARGBRow_NEON, I411ToARGBRow_C, 2, 4, 7)
70 YANY(I422ToBGRARow_Any_NEON, I422ToBGRARow_NEON, I422ToBGRARow_C, 1, 4, 7)
71 YANY(I422ToABGRRow_Any_NEON, I422ToABGRRow_NEON, I422ToABGRRow_C, 1, 4, 7)
72 YANY(I422ToRGBARow_Any_NEON, I422ToRGBARow_NEON, I422ToRGBARow_C, 1, 4, 7)
73 YANY(I422ToRGB24Row_Any_NEON, I422ToRGB24Row_NEON, I422ToRGB24Row_C, 1, 3, 7)
74 YANY(I422ToRAWRow_Any_NEON, I422ToRAWRow_NEON, I422ToRAWRow_C, 1, 3, 7)
75 YANY(I422ToARGB4444Row_Any_NEON, I422ToARGB4444Row_NEON, I422ToARGB4444Row_C,
76 1, 2, 7)
77 YANY(I422ToARGB1555Row_Any_NEON, I422ToARGB1555Row_NEON, I422ToARGB1555Row_C,
78 1, 2, 7)
79 YANY(I422ToRGB565Row_Any_NEON, I422ToRGB565Row_NEON, I422ToRGB565Row_C, 1, 2, 7)
80 YANY(I422ToYUY2Row_Any_NEON, I422ToYUY2Row_NEON, I422ToYUY2Row_C, 1, 2, 15)
81 YANY(I422ToUYVYRow_Any_NEON, I422ToUYVYRow_NEON, I422ToUYVYRow_C, 1, 2, 15)
82 #endif // HAS_I422TOARGBROW_NEON
83 #undef YANY
84
85 // Wrappers to handle odd width
86 #define NV2NY(NAMEANY, NV12TORGB_SIMD, NV12TORGB_C, UV_SHIFT, BPP) \
87 void NAMEANY(const uint8* y_buf, \
88 const uint8* uv_buf, \
89 uint8* rgb_buf, \
90 int width) { \
91 int n = width & ~7; \
92 NV12TORGB_SIMD(y_buf, uv_buf, rgb_buf, n); \
93 NV12TORGB_C(y_buf + n, \
94 uv_buf + (n >> UV_SHIFT), \
95 rgb_buf + n * BPP, width & 7); \
96 }
97
98 #ifdef HAS_NV12TOARGBROW_SSSE3
99 NV2NY(NV12ToARGBRow_Any_SSSE3, NV12ToARGBRow_Unaligned_SSSE3, NV12ToARGBRow_C,
100 0, 4)
101 NV2NY(NV21ToARGBRow_Any_SSSE3, NV21ToARGBRow_Unaligned_SSSE3, NV21ToARGBRow_C,
102 0, 4)
103 #endif // HAS_NV12TOARGBROW_SSSE3
104 #ifdef HAS_NV12TOARGBROW_NEON
105 NV2NY(NV12ToARGBRow_Any_NEON, NV12ToARGBRow_NEON, NV12ToARGBRow_C, 0, 4)
106 NV2NY(NV21ToARGBRow_Any_NEON, NV21ToARGBRow_NEON, NV21ToARGBRow_C, 0, 4)
107 #endif // HAS_NV12TOARGBROW_NEON
108 #ifdef HAS_NV12TORGB565ROW_SSSE3
109 NV2NY(NV12ToRGB565Row_Any_SSSE3, NV12ToRGB565Row_SSSE3, NV12ToRGB565Row_C,
110 0, 2)
111 NV2NY(NV21ToRGB565Row_Any_SSSE3, NV21ToRGB565Row_SSSE3, NV21ToRGB565Row_C,
112 0, 2)
113 #endif // HAS_NV12TORGB565ROW_SSSE3
114 #ifdef HAS_NV12TORGB565ROW_NEON
115 NV2NY(NV12ToRGB565Row_Any_NEON, NV12ToRGB565Row_NEON, NV12ToRGB565Row_C, 0, 2)
116 NV2NY(NV21ToRGB565Row_Any_NEON, NV21ToRGB565Row_NEON, NV21ToRGB565Row_C, 0, 2)
117 #endif // HAS_NV12TORGB565ROW_NEON
118 #undef NVANY
119
120 #define RGBANY(NAMEANY, ARGBTORGB_SIMD, ARGBTORGB_C, MASK, SBPP, BPP) \
121 void NAMEANY(const uint8* src, \
122 uint8* dst, \
123 int width) { \
124 int n = width & ~MASK; \
125 ARGBTORGB_SIMD(src, dst, n); \
126 ARGBTORGB_C(src + n * SBPP, dst + n * BPP, width & MASK); \
127 }
128
129 #if defined(HAS_ARGBTORGB24ROW_SSSE3)
130 RGBANY(ARGBToRGB24Row_Any_SSSE3, ARGBToRGB24Row_SSSE3, ARGBToRGB24Row_C,
131 15, 4, 3)
132 RGBANY(ARGBToRAWRow_Any_SSSE3, ARGBToRAWRow_SSSE3, ARGBToRAWRow_C,
133 15, 4, 3)
134 RGBANY(ARGBToRGB565Row_Any_SSE2, ARGBToRGB565Row_SSE2, ARGBToRGB565Row_C,
135 3, 4, 2)
136 RGBANY(ARGBToARGB1555Row_Any_SSE2, ARGBToARGB1555Row_SSE2, ARGBToARGB1555Row_C,
137 3, 4, 2)
138 RGBANY(ARGBToARGB4444Row_Any_SSE2, ARGBToARGB4444Row_SSE2, ARGBToARGB4444Row_C,
139 3, 4, 2)
140 #endif
141 #if defined(HAS_I400TOARGBROW_SSE2)
142 RGBANY(I400ToARGBRow_Any_SSE2, I400ToARGBRow_Unaligned_SSE2, I400ToARGBRow_C,
143 7, 1, 4)
144 #endif
145 #if defined(HAS_YTOARGBROW_SSE2)
146 RGBANY(YToARGBRow_Any_SSE2, YToARGBRow_SSE2, YToARGBRow_C,
147 7, 1, 4)
148 RGBANY(YUY2ToARGBRow_Any_SSSE3, YUY2ToARGBRow_Unaligned_SSSE3, YUY2ToARGBRow_C,
149 15, 2, 4)
150 RGBANY(UYVYToARGBRow_Any_SSSE3, UYVYToARGBRow_Unaligned_SSSE3, UYVYToARGBRow_C,
151 15, 2, 4)
152 // These require alignment on ARGB, so C is used for remainder.
153 RGBANY(RGB24ToARGBRow_Any_SSSE3, RGB24ToARGBRow_SSSE3, RGB24ToARGBRow_C,
154 15, 3, 4)
155 RGBANY(RAWToARGBRow_Any_SSSE3, RAWToARGBRow_SSSE3, RAWToARGBRow_C,
156 15, 3, 4)
157 RGBANY(RGB565ToARGBRow_Any_SSE2, RGB565ToARGBRow_SSE2, RGB565ToARGBRow_C,
158 7, 2, 4)
159 RGBANY(ARGB1555ToARGBRow_Any_SSE2, ARGB1555ToARGBRow_SSE2, ARGB1555ToARGBRow_C,
160 7, 2, 4)
161 RGBANY(ARGB4444ToARGBRow_Any_SSE2, ARGB4444ToARGBRow_SSE2, ARGB4444ToARGBRow_C,
162 7, 2, 4)
163 #endif
164 #if defined(HAS_ARGBTORGB24ROW_NEON)
165 RGBANY(ARGBToRGB24Row_Any_NEON, ARGBToRGB24Row_NEON, ARGBToRGB24Row_C, 7, 4, 3)
166 RGBANY(ARGBToRAWRow_Any_NEON, ARGBToRAWRow_NEON, ARGBToRAWRow_C, 7, 4, 3)
167 RGBANY(ARGBToRGB565Row_Any_NEON, ARGBToRGB565Row_NEON, ARGBToRGB565Row_C,
168 7, 4, 2)
169 RGBANY(ARGBToARGB1555Row_Any_NEON, ARGBToARGB1555Row_NEON, ARGBToARGB1555Row_C,
170 7, 4, 2)
171 RGBANY(ARGBToARGB4444Row_Any_NEON, ARGBToARGB4444Row_NEON, ARGBToARGB4444Row_C,
172 7, 4, 2)
173 RGBANY(I400ToARGBRow_Any_NEON, I400ToARGBRow_NEON, I400ToARGBRow_C,
174 7, 1, 4)
175 RGBANY(YToARGBRow_Any_NEON, YToARGBRow_NEON, YToARGBRow_C,
176 7, 1, 4)
177 RGBANY(YUY2ToARGBRow_Any_NEON, YUY2ToARGBRow_NEON, YUY2ToARGBRow_C,
178 7, 2, 4)
179 RGBANY(UYVYToARGBRow_Any_NEON, UYVYToARGBRow_NEON, UYVYToARGBRow_C,
180 7, 2, 4)
181 #endif
182 #undef RGBANY
183
184 // ARGB to Bayer does multiple of 4 pixels, SSSE3 aligned src, unaligned dst.
185 #define BAYERANY(NAMEANY, ARGBTORGB_SIMD, ARGBTORGB_C, MASK, SBPP, BPP) \
186 void NAMEANY(const uint8* src, \
187 uint8* dst, uint32 selector, \
188 int width) { \
189 int n = width & ~MASK; \
190 ARGBTORGB_SIMD(src, dst, selector, n); \
191 ARGBTORGB_C(src + n * SBPP, dst + n * BPP, selector, width & MASK); \
192 }
193
194 #if defined(HAS_ARGBTOBAYERROW_SSSE3)
195 BAYERANY(ARGBToBayerRow_Any_SSSE3, ARGBToBayerRow_SSSE3, ARGBToBayerRow_C,
196 7, 4, 1)
197 #endif
198 #if defined(HAS_ARGBTOBAYERROW_NEON)
199 BAYERANY(ARGBToBayerRow_Any_NEON, ARGBToBayerRow_NEON, ARGBToBayerRow_C,
200 7, 4, 1)
201 #endif
202 #if defined(HAS_ARGBTOBAYERGGROW_SSE2)
203 BAYERANY(ARGBToBayerGGRow_Any_SSE2, ARGBToBayerGGRow_SSE2, ARGBToBayerGGRow_C,
204 7, 4, 1)
205 #endif
206 #if defined(HAS_ARGBTOBAYERGGROW_NEON)
207 BAYERANY(ARGBToBayerGGRow_Any_NEON, ARGBToBayerGGRow_NEON, ARGBToBayerGGRow_C,
208 7, 4, 1)
209 #endif
210
211 #undef BAYERANY
212
213 // RGB/YUV to Y does multiple of 16 with SIMD and last 16 with SIMD.
214 #define YANY(NAMEANY, ARGBTOY_SIMD, SBPP, BPP, NUM) \
215 void NAMEANY(const uint8* src_argb, uint8* dst_y, int width) { \
216 ARGBTOY_SIMD(src_argb, dst_y, width - NUM); \
217 ARGBTOY_SIMD(src_argb + (width - NUM) * SBPP, \
218 dst_y + (width - NUM) * BPP, NUM); \
219 }
220
221 #ifdef HAS_ARGBTOYROW_AVX2
222 YANY(ARGBToYRow_Any_AVX2, ARGBToYRow_AVX2, 4, 1, 32)
223 YANY(ARGBToYJRow_Any_AVX2, ARGBToYJRow_AVX2, 4, 1, 32)
224 YANY(YUY2ToYRow_Any_AVX2, YUY2ToYRow_AVX2, 2, 1, 32)
225 YANY(UYVYToYRow_Any_AVX2, UYVYToYRow_AVX2, 2, 1, 32)
226 #endif
227 #ifdef HAS_ARGBTOYROW_SSSE3
228 YANY(ARGBToYRow_Any_SSSE3, ARGBToYRow_Unaligned_SSSE3, 4, 1, 16)
229 #endif
230 #ifdef HAS_BGRATOYROW_SSSE3
231 YANY(BGRAToYRow_Any_SSSE3, BGRAToYRow_Unaligned_SSSE3, 4, 1, 16)
232 YANY(ABGRToYRow_Any_SSSE3, ABGRToYRow_Unaligned_SSSE3, 4, 1, 16)
233 YANY(RGBAToYRow_Any_SSSE3, RGBAToYRow_Unaligned_SSSE3, 4, 1, 16)
234 YANY(YUY2ToYRow_Any_SSE2, YUY2ToYRow_Unaligned_SSE2, 2, 1, 16)
235 YANY(UYVYToYRow_Any_SSE2, UYVYToYRow_Unaligned_SSE2, 2, 1, 16)
236 #endif
237 #ifdef HAS_ARGBTOYJROW_SSSE3
238 YANY(ARGBToYJRow_Any_SSSE3, ARGBToYJRow_Unaligned_SSSE3, 4, 1, 16)
239 #endif
240 #ifdef HAS_ARGBTOYROW_NEON
241 YANY(ARGBToYRow_Any_NEON, ARGBToYRow_NEON, 4, 1, 8)
242 YANY(ARGBToYJRow_Any_NEON, ARGBToYJRow_NEON, 4, 1, 8)
243 YANY(BGRAToYRow_Any_NEON, BGRAToYRow_NEON, 4, 1, 8)
244 YANY(ABGRToYRow_Any_NEON, ABGRToYRow_NEON, 4, 1, 8)
245 YANY(RGBAToYRow_Any_NEON, RGBAToYRow_NEON, 4, 1, 8)
246 YANY(RGB24ToYRow_Any_NEON, RGB24ToYRow_NEON, 3, 1, 8)
247 YANY(RAWToYRow_Any_NEON, RAWToYRow_NEON, 3, 1, 8)
248 YANY(RGB565ToYRow_Any_NEON, RGB565ToYRow_NEON, 2, 1, 8)
249 YANY(ARGB1555ToYRow_Any_NEON, ARGB1555ToYRow_NEON, 2, 1, 8)
250 YANY(ARGB4444ToYRow_Any_NEON, ARGB4444ToYRow_NEON, 2, 1, 8)
251 YANY(YUY2ToYRow_Any_NEON, YUY2ToYRow_NEON, 2, 1, 16)
252 YANY(UYVYToYRow_Any_NEON, UYVYToYRow_NEON, 2, 1, 16)
253 YANY(RGB24ToARGBRow_Any_NEON, RGB24ToARGBRow_NEON, 3, 4, 8)
254 YANY(RAWToARGBRow_Any_NEON, RAWToARGBRow_NEON, 3, 4, 8)
255 YANY(RGB565ToARGBRow_Any_NEON, RGB565ToARGBRow_NEON, 2, 4, 8)
256 YANY(ARGB1555ToARGBRow_Any_NEON, ARGB1555ToARGBRow_NEON, 2, 4, 8)
257 YANY(ARGB4444ToARGBRow_Any_NEON, ARGB4444ToARGBRow_NEON, 2, 4, 8)
258 #endif
259 #undef YANY
260
261 #define YANY(NAMEANY, ARGBTOY_SIMD, ARGBTOY_C, SBPP, BPP, MASK) \
262 void NAMEANY(const uint8* src_argb, uint8* dst_y, int width) { \
263 int n = width & ~MASK; \
264 ARGBTOY_SIMD(src_argb, dst_y, n); \
265 ARGBTOY_C(src_argb + n * SBPP, \
266 dst_y + n * BPP, width & MASK); \
267 }
268
269 // Attenuate is destructive so last16 method can not be used due to overlap.
270 #ifdef HAS_ARGBATTENUATEROW_SSSE3
271 YANY(ARGBAttenuateRow_Any_SSSE3, ARGBAttenuateRow_SSSE3, ARGBAttenuateRow_C,
272 4, 4, 3)
273 #endif
274 #ifdef HAS_ARGBATTENUATEROW_SSE2
275 YANY(ARGBAttenuateRow_Any_SSE2, ARGBAttenuateRow_SSE2, ARGBAttenuateRow_C,
276 4, 4, 3)
277 #endif
278 #ifdef HAS_ARGBUNATTENUATEROW_SSE2
279 YANY(ARGBUnattenuateRow_Any_SSE2, ARGBUnattenuateRow_SSE2, ARGBUnattenuateRow_C,
280 4, 4, 3)
281 #endif
282 #ifdef HAS_ARGBATTENUATEROW_AVX2
283 YANY(ARGBAttenuateRow_Any_AVX2, ARGBAttenuateRow_AVX2, ARGBAttenuateRow_C,
284 4, 4, 7)
285 #endif
286 #ifdef HAS_ARGBUNATTENUATEROW_AVX2
287 YANY(ARGBUnattenuateRow_Any_AVX2, ARGBUnattenuateRow_AVX2, ARGBUnattenuateRow_C,
288 4, 4, 7)
289 #endif
290 #ifdef HAS_ARGBATTENUATEROW_NEON
291 YANY(ARGBAttenuateRow_Any_NEON, ARGBAttenuateRow_NEON, ARGBAttenuateRow_C,
292 4, 4, 7)
293 #endif
294 #undef YANY
295
296 // RGB/YUV to UV does multiple of 16 with SIMD and remainder with C.
297 #define UVANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, BPP, MASK) \
298 void NAMEANY(const uint8* src_argb, int src_stride_argb, \
299 uint8* dst_u, uint8* dst_v, int width) { \
300 int n = width & ~MASK; \
301 ANYTOUV_SIMD(src_argb, src_stride_argb, dst_u, dst_v, n); \
302 ANYTOUV_C(src_argb + n * BPP, src_stride_argb, \
303 dst_u + (n >> 1), \
304 dst_v + (n >> 1), \
305 width & MASK); \
306 }
307
308 #ifdef HAS_ARGBTOUVROW_AVX2
309 UVANY(ARGBToUVRow_Any_AVX2, ARGBToUVRow_AVX2, ARGBToUVRow_C, 4, 31)
310 UVANY(YUY2ToUVRow_Any_AVX2, YUY2ToUVRow_AVX2, YUY2ToUVRow_C, 2, 31)
311 UVANY(UYVYToUVRow_Any_AVX2, UYVYToUVRow_AVX2, UYVYToUVRow_C, 2, 31)
312 #endif
313 #ifdef HAS_ARGBTOUVROW_SSSE3
314 UVANY(ARGBToUVRow_Any_SSSE3, ARGBToUVRow_Unaligned_SSSE3, ARGBToUVRow_C, 4, 15)
315 UVANY(ARGBToUVJRow_Any_SSSE3, ARGBToUVJRow_Unaligned_SSSE3, ARGBToUVJRow_C,
316 4, 15)
317 UVANY(BGRAToUVRow_Any_SSSE3, BGRAToUVRow_Unaligned_SSSE3, BGRAToUVRow_C, 4, 15)
318 UVANY(ABGRToUVRow_Any_SSSE3, ABGRToUVRow_Unaligned_SSSE3, ABGRToUVRow_C, 4, 15)
319 UVANY(RGBAToUVRow_Any_SSSE3, RGBAToUVRow_Unaligned_SSSE3, RGBAToUVRow_C, 4, 15)
320 UVANY(YUY2ToUVRow_Any_SSE2, YUY2ToUVRow_Unaligned_SSE2, YUY2ToUVRow_C, 2, 15)
321 UVANY(UYVYToUVRow_Any_SSE2, UYVYToUVRow_Unaligned_SSE2, UYVYToUVRow_C, 2, 15)
322 #endif
323 #ifdef HAS_ARGBTOUVROW_NEON
324 UVANY(ARGBToUVRow_Any_NEON, ARGBToUVRow_NEON, ARGBToUVRow_C, 4, 15)
325 UVANY(ARGBToUVJRow_Any_NEON, ARGBToUVJRow_NEON, ARGBToUVJRow_C, 4, 15)
326 UVANY(BGRAToUVRow_Any_NEON, BGRAToUVRow_NEON, BGRAToUVRow_C, 4, 15)
327 UVANY(ABGRToUVRow_Any_NEON, ABGRToUVRow_NEON, ABGRToUVRow_C, 4, 15)
328 UVANY(RGBAToUVRow_Any_NEON, RGBAToUVRow_NEON, RGBAToUVRow_C, 4, 15)
329 UVANY(RGB24ToUVRow_Any_NEON, RGB24ToUVRow_NEON, RGB24ToUVRow_C, 3, 15)
330 UVANY(RAWToUVRow_Any_NEON, RAWToUVRow_NEON, RAWToUVRow_C, 3, 15)
331 UVANY(RGB565ToUVRow_Any_NEON, RGB565ToUVRow_NEON, RGB565ToUVRow_C, 2, 15)
332 UVANY(ARGB1555ToUVRow_Any_NEON, ARGB1555ToUVRow_NEON, ARGB1555ToUVRow_C, 2, 15)
333 UVANY(ARGB4444ToUVRow_Any_NEON, ARGB4444ToUVRow_NEON, ARGB4444ToUVRow_C, 2, 15)
334 UVANY(YUY2ToUVRow_Any_NEON, YUY2ToUVRow_NEON, YUY2ToUVRow_C, 2, 15)
335 UVANY(UYVYToUVRow_Any_NEON, UYVYToUVRow_NEON, UYVYToUVRow_C, 2, 15)
336 #endif
337 #undef UVANY
338
339 #define UV422ANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, BPP, MASK, SHIFT) \
340 void NAMEANY(const uint8* src_uv, \
341 uint8* dst_u, uint8* dst_v, int width) { \
342 int n = width & ~MASK; \
343 ANYTOUV_SIMD(src_uv, dst_u, dst_v, n); \
344 ANYTOUV_C(src_uv + n * BPP, \
345 dst_u + (n >> SHIFT), \
346 dst_v + (n >> SHIFT), \
347 width & MASK); \
348 }
349
350 #ifdef HAS_ARGBTOUV444ROW_SSSE3
351 UV422ANY(ARGBToUV444Row_Any_SSSE3, ARGBToUV444Row_Unaligned_SSSE3,
352 ARGBToUV444Row_C, 4, 15, 0)
353 #endif
354 #ifdef HAS_YUY2TOUV422ROW_AVX2
355 UV422ANY(YUY2ToUV422Row_Any_AVX2, YUY2ToUV422Row_AVX2,
356 YUY2ToUV422Row_C, 2, 31, 1)
357 UV422ANY(UYVYToUV422Row_Any_AVX2, UYVYToUV422Row_AVX2,
358 UYVYToUV422Row_C, 2, 31, 1)
359 #endif
360 #ifdef HAS_ARGBTOUVROW_SSSE3
361 UV422ANY(ARGBToUV422Row_Any_SSSE3, ARGBToUV422Row_Unaligned_SSSE3,
362 ARGBToUV422Row_C, 4, 15, 1)
363 UV422ANY(YUY2ToUV422Row_Any_SSE2, YUY2ToUV422Row_Unaligned_SSE2,
364 YUY2ToUV422Row_C, 2, 15, 1)
365 UV422ANY(UYVYToUV422Row_Any_SSE2, UYVYToUV422Row_Unaligned_SSE2,
366 UYVYToUV422Row_C, 2, 15, 1)
367 #endif
368 #ifdef HAS_YUY2TOUV422ROW_NEON
369 UV422ANY(ARGBToUV444Row_Any_NEON, ARGBToUV444Row_NEON,
370 ARGBToUV444Row_C, 4, 7, 0)
371 UV422ANY(ARGBToUV422Row_Any_NEON, ARGBToUV422Row_NEON,
372 ARGBToUV422Row_C, 4, 15, 1)
373 UV422ANY(ARGBToUV411Row_Any_NEON, ARGBToUV411Row_NEON,
374 ARGBToUV411Row_C, 4, 31, 2)
375 UV422ANY(YUY2ToUV422Row_Any_NEON, YUY2ToUV422Row_NEON,
376 YUY2ToUV422Row_C, 2, 15, 1)
377 UV422ANY(UYVYToUV422Row_Any_NEON, UYVYToUV422Row_NEON,
378 UYVYToUV422Row_C, 2, 15, 1)
379 #endif
380 #undef UV422ANY
381
382 #define SPLITUVROWANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, MASK) \
383 void NAMEANY(const uint8* src_uv, \
384 uint8* dst_u, uint8* dst_v, int width) { \
385 int n = width & ~MASK; \
386 ANYTOUV_SIMD(src_uv, dst_u, dst_v, n); \
387 ANYTOUV_C(src_uv + n * 2, \
388 dst_u + n, \
389 dst_v + n, \
390 width & MASK); \
391 }
392
393 #ifdef HAS_SPLITUVROW_SSE2
394 SPLITUVROWANY(SplitUVRow_Any_SSE2, SplitUVRow_Unaligned_SSE2, SplitUVRow_C, 15)
395 #endif
396 #ifdef HAS_SPLITUVROW_AVX2
397 SPLITUVROWANY(SplitUVRow_Any_AVX2, SplitUVRow_AVX2, SplitUVRow_C, 31)
398 #endif
399 #ifdef HAS_SPLITUVROW_NEON
400 SPLITUVROWANY(SplitUVRow_Any_NEON, SplitUVRow_NEON, SplitUVRow_C, 15)
401 #endif
402 #ifdef HAS_SPLITUVROW_MIPS_DSPR2
403 SPLITUVROWANY(SplitUVRow_Any_MIPS_DSPR2, SplitUVRow_Unaligned_MIPS_DSPR2,
404 SplitUVRow_C, 15)
405 #endif
406 #undef SPLITUVROWANY
407
408 #define MERGEUVROW_ANY(NAMEANY, ANYTOUV_SIMD, ANYTOUV_C, MASK) \
409 void NAMEANY(const uint8* src_u, const uint8* src_v, \
410 uint8* dst_uv, int width) { \
411 int n = width & ~MASK; \
412 ANYTOUV_SIMD(src_u, src_v, dst_uv, n); \
413 ANYTOUV_C(src_u + n, \
414 src_v + n, \
415 dst_uv + n * 2, \
416 width & MASK); \
417 }
418
419 #ifdef HAS_MERGEUVROW_SSE2
420 MERGEUVROW_ANY(MergeUVRow_Any_SSE2, MergeUVRow_Unaligned_SSE2, MergeUVRow_C, 15)
421 #endif
422 #ifdef HAS_MERGEUVROW_AVX2
423 MERGEUVROW_ANY(MergeUVRow_Any_AVX2, MergeUVRow_AVX2, MergeUVRow_C, 31)
424 #endif
425 #ifdef HAS_MERGEUVROW_NEON
426 MERGEUVROW_ANY(MergeUVRow_Any_NEON, MergeUVRow_NEON, MergeUVRow_C, 15)
427 #endif
428 #undef MERGEUVROW_ANY
429
430 #define MATHROW_ANY(NAMEANY, ARGBMATH_SIMD, ARGBMATH_C, MASK) \
431 void NAMEANY(const uint8* src_argb0, const uint8* src_argb1, \
432 uint8* dst_argb, int width) { \
433 int n = width & ~MASK; \
434 ARGBMATH_SIMD(src_argb0, src_argb1, dst_argb, n); \
435 ARGBMATH_C(src_argb0 + n * 4, \
436 src_argb1 + n * 4, \
437 dst_argb + n * 4, \
438 width & MASK); \
439 }
440
441 #ifdef HAS_ARGBMULTIPLYROW_SSE2
442 MATHROW_ANY(ARGBMultiplyRow_Any_SSE2, ARGBMultiplyRow_SSE2, ARGBMultiplyRow_C,
443 3)
444 #endif
445 #ifdef HAS_ARGBADDROW_SSE2
446 MATHROW_ANY(ARGBAddRow_Any_SSE2, ARGBAddRow_SSE2, ARGBAddRow_C, 3)
447 #endif
448 #ifdef HAS_ARGBSUBTRACTROW_SSE2
449 MATHROW_ANY(ARGBSubtractRow_Any_SSE2, ARGBSubtractRow_SSE2, ARGBSubtractRow_C,
450 3)
451 #endif
452 #ifdef HAS_ARGBMULTIPLYROW_AVX2
453 MATHROW_ANY(ARGBMultiplyRow_Any_AVX2, ARGBMultiplyRow_AVX2, ARGBMultiplyRow_C,
454 7)
455 #endif
456 #ifdef HAS_ARGBADDROW_AVX2
457 MATHROW_ANY(ARGBAddRow_Any_AVX2, ARGBAddRow_AVX2, ARGBAddRow_C, 7)
458 #endif
459 #ifdef HAS_ARGBSUBTRACTROW_AVX2
460 MATHROW_ANY(ARGBSubtractRow_Any_AVX2, ARGBSubtractRow_AVX2, ARGBSubtractRow_C,
461 7)
462 #endif
463 #ifdef HAS_ARGBMULTIPLYROW_NEON
464 MATHROW_ANY(ARGBMultiplyRow_Any_NEON, ARGBMultiplyRow_NEON, ARGBMultiplyRow_C,
465 7)
466 #endif
467 #ifdef HAS_ARGBADDROW_NEON
468 MATHROW_ANY(ARGBAddRow_Any_NEON, ARGBAddRow_NEON, ARGBAddRow_C, 7)
469 #endif
470 #ifdef HAS_ARGBSUBTRACTROW_NEON
471 MATHROW_ANY(ARGBSubtractRow_Any_NEON, ARGBSubtractRow_NEON, ARGBSubtractRow_C,
472 7)
473 #endif
474 #undef MATHROW_ANY
475
476 // Shuffle may want to work in place, so last16 method can not be used.
477 #define YANY(NAMEANY, ARGBTOY_SIMD, ARGBTOY_C, SBPP, BPP, MASK) \
478 void NAMEANY(const uint8* src_argb, uint8* dst_argb, \
479 const uint8* shuffler, int width) { \
480 int n = width & ~MASK; \
481 ARGBTOY_SIMD(src_argb, dst_argb, shuffler, n); \
482 ARGBTOY_C(src_argb + n * SBPP, \
483 dst_argb + n * BPP, shuffler, width & MASK); \
484 }
485
486 #ifdef HAS_ARGBSHUFFLEROW_SSE2
487 YANY(ARGBShuffleRow_Any_SSE2, ARGBShuffleRow_SSE2,
488 ARGBShuffleRow_C, 4, 4, 3)
489 #endif
490 #ifdef HAS_ARGBSHUFFLEROW_SSSE3
491 YANY(ARGBShuffleRow_Any_SSSE3, ARGBShuffleRow_Unaligned_SSSE3,
492 ARGBShuffleRow_C, 4, 4, 7)
493 #endif
494 #ifdef HAS_ARGBSHUFFLEROW_AVX2
495 YANY(ARGBShuffleRow_Any_AVX2, ARGBShuffleRow_AVX2,
496 ARGBShuffleRow_C, 4, 4, 15)
497 #endif
498 #ifdef HAS_ARGBSHUFFLEROW_NEON
499 YANY(ARGBShuffleRow_Any_NEON, ARGBShuffleRow_NEON,
500 ARGBShuffleRow_C, 4, 4, 3)
501 #endif
502 #undef YANY
503
504 // Interpolate may want to work in place, so last16 method can not be used.
505 #define NANY(NAMEANY, TERP_SIMD, TERP_C, SBPP, BPP, MASK) \
506 void NAMEANY(uint8* dst_ptr, const uint8* src_ptr, \
507 ptrdiff_t src_stride_ptr, int width, \
508 int source_y_fraction) { \
509 int n = width & ~MASK; \
510 TERP_SIMD(dst_ptr, src_ptr, src_stride_ptr, \
511 n, source_y_fraction); \
512 TERP_C(dst_ptr + n * BPP, \
513 src_ptr + n * SBPP, src_stride_ptr, \
514 width & MASK, source_y_fraction); \
515 }
516
517 #ifdef HAS_INTERPOLATEROW_AVX2
518 NANY(InterpolateRow_Any_AVX2, InterpolateRow_AVX2,
519 InterpolateRow_C, 1, 1, 32)
520 #endif
521 #ifdef HAS_INTERPOLATEROW_SSSE3
522 NANY(InterpolateRow_Any_SSSE3, InterpolateRow_Unaligned_SSSE3,
523 InterpolateRow_C, 1, 1, 15)
524 #endif
525 #ifdef HAS_INTERPOLATEROW_SSE2
526 NANY(InterpolateRow_Any_SSE2, InterpolateRow_Unaligned_SSE2,
527 InterpolateRow_C, 1, 1, 15)
528 #endif
529 #ifdef HAS_INTERPOLATEROW_NEON
530 NANY(InterpolateRow_Any_NEON, InterpolateRow_NEON,
531 InterpolateRow_C, 1, 1, 15)
532 #endif
533 #ifdef HAS_INTERPOLATEROW_MIPS_DSPR2
534 NANY(InterpolateRow_Any_MIPS_DSPR2, InterpolateRow_MIPS_DSPR2,
535 InterpolateRow_C, 1, 1, 3)
536 #endif
537 #undef NANY
538
539 #ifdef __cplusplus
540 } // extern "C"
541 } // namespace libyuv
542 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial