The Tor Browser / file comparison

comparison: media/libyuv/source/row_neon.cc

media/libyuv/source/row_neon.cc

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:1070526bec34
1 /*
2 * Copyright 2011 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 #ifdef __cplusplus
14 namespace libyuv {
15 extern "C" {
16 #endif
17
18 // This module is for GCC Neon
19 #if !defined(LIBYUV_DISABLE_NEON) && defined(__ARM_NEON__)
20
21 // Read 8 Y, 4 U and 4 V from 422
22 #define READYUV422 \
23 "vld1.8 {d0}, [%0]! \n" \
24 "vld1.32 {d2[0]}, [%1]! \n" \
25 "vld1.32 {d2[1]}, [%2]! \n"
26
27 // Read 8 Y, 2 U and 2 V from 422
28 #define READYUV411 \
29 "vld1.8 {d0}, [%0]! \n" \
30 "vld1.16 {d2[0]}, [%1]! \n" \
31 "vld1.16 {d2[1]}, [%2]! \n" \
32 "vmov.u8 d3, d2 \n" \
33 "vzip.u8 d2, d3 \n"
34
35 // Read 8 Y, 8 U and 8 V from 444
36 #define READYUV444 \
37 "vld1.8 {d0}, [%0]! \n" \
38 "vld1.8 {d2}, [%1]! \n" \
39 "vld1.8 {d3}, [%2]! \n" \
40 "vpaddl.u8 q1, q1 \n" \
41 "vrshrn.u16 d2, q1, #1 \n"
42
43 // Read 8 Y, and set 4 U and 4 V to 128
44 #define READYUV400 \
45 "vld1.8 {d0}, [%0]! \n" \
46 "vmov.u8 d2, #128 \n"
47
48 // Read 8 Y and 4 UV from NV12
49 #define READNV12 \
50 "vld1.8 {d0}, [%0]! \n" \
51 "vld1.8 {d2}, [%1]! \n" \
52 "vmov.u8 d3, d2 \n"/* split odd/even uv apart */\
53 "vuzp.u8 d2, d3 \n" \
54 "vtrn.u32 d2, d3 \n"
55
56 // Read 8 Y and 4 VU from NV21
57 #define READNV21 \
58 "vld1.8 {d0}, [%0]! \n" \
59 "vld1.8 {d2}, [%1]! \n" \
60 "vmov.u8 d3, d2 \n"/* split odd/even uv apart */\
61 "vuzp.u8 d3, d2 \n" \
62 "vtrn.u32 d2, d3 \n"
63
64 // Read 8 YUY2
65 #define READYUY2 \
66 "vld2.8 {d0, d2}, [%0]! \n" \
67 "vmov.u8 d3, d2 \n" \
68 "vuzp.u8 d2, d3 \n" \
69 "vtrn.u32 d2, d3 \n"
70
71 // Read 8 UYVY
72 #define READUYVY \
73 "vld2.8 {d2, d3}, [%0]! \n" \
74 "vmov.u8 d0, d3 \n" \
75 "vmov.u8 d3, d2 \n" \
76 "vuzp.u8 d2, d3 \n" \
77 "vtrn.u32 d2, d3 \n"
78
79 #define YUV422TORGB \
80 "veor.u8 d2, d26 \n"/*subtract 128 from u and v*/\
81 "vmull.s8 q8, d2, d24 \n"/* u/v B/R component */\
82 "vmull.s8 q9, d2, d25 \n"/* u/v G component */\
83 "vmov.u8 d1, #0 \n"/* split odd/even y apart */\
84 "vtrn.u8 d0, d1 \n" \
85 "vsub.s16 q0, q0, q15 \n"/* offset y */\
86 "vmul.s16 q0, q0, q14 \n" \
87 "vadd.s16 d18, d19 \n" \
88 "vqadd.s16 d20, d0, d16 \n" /* B */ \
89 "vqadd.s16 d21, d1, d16 \n" \
90 "vqadd.s16 d22, d0, d17 \n" /* R */ \
91 "vqadd.s16 d23, d1, d17 \n" \
92 "vqadd.s16 d16, d0, d18 \n" /* G */ \
93 "vqadd.s16 d17, d1, d18 \n" \
94 "vqshrun.s16 d0, q10, #6 \n" /* B */ \
95 "vqshrun.s16 d1, q11, #6 \n" /* G */ \
96 "vqshrun.s16 d2, q8, #6 \n" /* R */ \
97 "vmovl.u8 q10, d0 \n"/* set up for reinterleave*/\
98 "vmovl.u8 q11, d1 \n" \
99 "vmovl.u8 q8, d2 \n" \
100 "vtrn.u8 d20, d21 \n" \
101 "vtrn.u8 d22, d23 \n" \
102 "vtrn.u8 d16, d17 \n" \
103 "vmov.u8 d21, d16 \n"
104
105 static vec8 kUVToRB = { 127, 127, 127, 127, 102, 102, 102, 102,
106 0, 0, 0, 0, 0, 0, 0, 0 };
107 static vec8 kUVToG = { -25, -25, -25, -25, -52, -52, -52, -52,
108 0, 0, 0, 0, 0, 0, 0, 0 };
109
110 void I444ToARGBRow_NEON(const uint8* src_y,
111 const uint8* src_u,
112 const uint8* src_v,
113 uint8* dst_argb,
114 int width) {
115 asm volatile (
116 "vld1.8 {d24}, [%5] \n"
117 "vld1.8 {d25}, [%6] \n"
118 "vmov.u8 d26, #128 \n"
119 "vmov.u16 q14, #74 \n"
120 "vmov.u16 q15, #16 \n"
121 ".p2align 2 \n"
122 "1: \n"
123 READYUV444
124 YUV422TORGB
125 "subs %4, %4, #8 \n"
126 "vmov.u8 d23, #255 \n"
127 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
128 "bgt 1b \n"
129 : "+r"(src_y), // %0
130 "+r"(src_u), // %1
131 "+r"(src_v), // %2
132 "+r"(dst_argb), // %3
133 "+r"(width) // %4
134 : "r"(&kUVToRB), // %5
135 "r"(&kUVToG) // %6
136 : "cc", "memory", "q0", "q1", "q2", "q3",
137 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
138 );
139 }
140
141 void I422ToARGBRow_NEON(const uint8* src_y,
142 const uint8* src_u,
143 const uint8* src_v,
144 uint8* dst_argb,
145 int width) {
146 asm volatile (
147 "vld1.8 {d24}, [%5] \n"
148 "vld1.8 {d25}, [%6] \n"
149 "vmov.u8 d26, #128 \n"
150 "vmov.u16 q14, #74 \n"
151 "vmov.u16 q15, #16 \n"
152 ".p2align 2 \n"
153 "1: \n"
154 READYUV422
155 YUV422TORGB
156 "subs %4, %4, #8 \n"
157 "vmov.u8 d23, #255 \n"
158 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
159 "bgt 1b \n"
160 : "+r"(src_y), // %0
161 "+r"(src_u), // %1
162 "+r"(src_v), // %2
163 "+r"(dst_argb), // %3
164 "+r"(width) // %4
165 : "r"(&kUVToRB), // %5
166 "r"(&kUVToG) // %6
167 : "cc", "memory", "q0", "q1", "q2", "q3",
168 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
169 );
170 }
171
172 void I411ToARGBRow_NEON(const uint8* src_y,
173 const uint8* src_u,
174 const uint8* src_v,
175 uint8* dst_argb,
176 int width) {
177 asm volatile (
178 "vld1.8 {d24}, [%5] \n"
179 "vld1.8 {d25}, [%6] \n"
180 "vmov.u8 d26, #128 \n"
181 "vmov.u16 q14, #74 \n"
182 "vmov.u16 q15, #16 \n"
183 ".p2align 2 \n"
184 "1: \n"
185 READYUV411
186 YUV422TORGB
187 "subs %4, %4, #8 \n"
188 "vmov.u8 d23, #255 \n"
189 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
190 "bgt 1b \n"
191 : "+r"(src_y), // %0
192 "+r"(src_u), // %1
193 "+r"(src_v), // %2
194 "+r"(dst_argb), // %3
195 "+r"(width) // %4
196 : "r"(&kUVToRB), // %5
197 "r"(&kUVToG) // %6
198 : "cc", "memory", "q0", "q1", "q2", "q3",
199 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
200 );
201 }
202
203 void I422ToBGRARow_NEON(const uint8* src_y,
204 const uint8* src_u,
205 const uint8* src_v,
206 uint8* dst_bgra,
207 int width) {
208 asm volatile (
209 "vld1.8 {d24}, [%5] \n"
210 "vld1.8 {d25}, [%6] \n"
211 "vmov.u8 d26, #128 \n"
212 "vmov.u16 q14, #74 \n"
213 "vmov.u16 q15, #16 \n"
214 ".p2align 2 \n"
215 "1: \n"
216 READYUV422
217 YUV422TORGB
218 "subs %4, %4, #8 \n"
219 "vswp.u8 d20, d22 \n"
220 "vmov.u8 d19, #255 \n"
221 "vst4.8 {d19, d20, d21, d22}, [%3]! \n"
222 "bgt 1b \n"
223 : "+r"(src_y), // %0
224 "+r"(src_u), // %1
225 "+r"(src_v), // %2
226 "+r"(dst_bgra), // %3
227 "+r"(width) // %4
228 : "r"(&kUVToRB), // %5
229 "r"(&kUVToG) // %6
230 : "cc", "memory", "q0", "q1", "q2", "q3",
231 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
232 );
233 }
234
235 void I422ToABGRRow_NEON(const uint8* src_y,
236 const uint8* src_u,
237 const uint8* src_v,
238 uint8* dst_abgr,
239 int width) {
240 asm volatile (
241 "vld1.8 {d24}, [%5] \n"
242 "vld1.8 {d25}, [%6] \n"
243 "vmov.u8 d26, #128 \n"
244 "vmov.u16 q14, #74 \n"
245 "vmov.u16 q15, #16 \n"
246 ".p2align 2 \n"
247 "1: \n"
248 READYUV422
249 YUV422TORGB
250 "subs %4, %4, #8 \n"
251 "vswp.u8 d20, d22 \n"
252 "vmov.u8 d23, #255 \n"
253 "vst4.8 {d20, d21, d22, d23}, [%3]! \n"
254 "bgt 1b \n"
255 : "+r"(src_y), // %0
256 "+r"(src_u), // %1
257 "+r"(src_v), // %2
258 "+r"(dst_abgr), // %3
259 "+r"(width) // %4
260 : "r"(&kUVToRB), // %5
261 "r"(&kUVToG) // %6
262 : "cc", "memory", "q0", "q1", "q2", "q3",
263 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
264 );
265 }
266
267 void I422ToRGBARow_NEON(const uint8* src_y,
268 const uint8* src_u,
269 const uint8* src_v,
270 uint8* dst_rgba,
271 int width) {
272 asm volatile (
273 "vld1.8 {d24}, [%5] \n"
274 "vld1.8 {d25}, [%6] \n"
275 "vmov.u8 d26, #128 \n"
276 "vmov.u16 q14, #74 \n"
277 "vmov.u16 q15, #16 \n"
278 ".p2align 2 \n"
279 "1: \n"
280 READYUV422
281 YUV422TORGB
282 "subs %4, %4, #8 \n"
283 "vmov.u8 d19, #255 \n"
284 "vst4.8 {d19, d20, d21, d22}, [%3]! \n"
285 "bgt 1b \n"
286 : "+r"(src_y), // %0
287 "+r"(src_u), // %1
288 "+r"(src_v), // %2
289 "+r"(dst_rgba), // %3
290 "+r"(width) // %4
291 : "r"(&kUVToRB), // %5
292 "r"(&kUVToG) // %6
293 : "cc", "memory", "q0", "q1", "q2", "q3",
294 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
295 );
296 }
297
298 void I422ToRGB24Row_NEON(const uint8* src_y,
299 const uint8* src_u,
300 const uint8* src_v,
301 uint8* dst_rgb24,
302 int width) {
303 asm volatile (
304 "vld1.8 {d24}, [%5] \n"
305 "vld1.8 {d25}, [%6] \n"
306 "vmov.u8 d26, #128 \n"
307 "vmov.u16 q14, #74 \n"
308 "vmov.u16 q15, #16 \n"
309 ".p2align 2 \n"
310 "1: \n"
311 READYUV422
312 YUV422TORGB
313 "subs %4, %4, #8 \n"
314 "vst3.8 {d20, d21, d22}, [%3]! \n"
315 "bgt 1b \n"
316 : "+r"(src_y), // %0
317 "+r"(src_u), // %1
318 "+r"(src_v), // %2
319 "+r"(dst_rgb24), // %3
320 "+r"(width) // %4
321 : "r"(&kUVToRB), // %5
322 "r"(&kUVToG) // %6
323 : "cc", "memory", "q0", "q1", "q2", "q3",
324 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
325 );
326 }
327
328 void I422ToRAWRow_NEON(const uint8* src_y,
329 const uint8* src_u,
330 const uint8* src_v,
331 uint8* dst_raw,
332 int width) {
333 asm volatile (
334 "vld1.8 {d24}, [%5] \n"
335 "vld1.8 {d25}, [%6] \n"
336 "vmov.u8 d26, #128 \n"
337 "vmov.u16 q14, #74 \n"
338 "vmov.u16 q15, #16 \n"
339 ".p2align 2 \n"
340 "1: \n"
341 READYUV422
342 YUV422TORGB
343 "subs %4, %4, #8 \n"
344 "vswp.u8 d20, d22 \n"
345 "vst3.8 {d20, d21, d22}, [%3]! \n"
346 "bgt 1b \n"
347 : "+r"(src_y), // %0
348 "+r"(src_u), // %1
349 "+r"(src_v), // %2
350 "+r"(dst_raw), // %3
351 "+r"(width) // %4
352 : "r"(&kUVToRB), // %5
353 "r"(&kUVToG) // %6
354 : "cc", "memory", "q0", "q1", "q2", "q3",
355 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
356 );
357 }
358
359 #define ARGBTORGB565 \
360 "vshr.u8 d20, d20, #3 \n" /* B */ \
361 "vshr.u8 d21, d21, #2 \n" /* G */ \
362 "vshr.u8 d22, d22, #3 \n" /* R */ \
363 "vmovl.u8 q8, d20 \n" /* B */ \
364 "vmovl.u8 q9, d21 \n" /* G */ \
365 "vmovl.u8 q10, d22 \n" /* R */ \
366 "vshl.u16 q9, q9, #5 \n" /* G */ \
367 "vshl.u16 q10, q10, #11 \n" /* R */ \
368 "vorr q0, q8, q9 \n" /* BG */ \
369 "vorr q0, q0, q10 \n" /* BGR */
370
371 void I422ToRGB565Row_NEON(const uint8* src_y,
372 const uint8* src_u,
373 const uint8* src_v,
374 uint8* dst_rgb565,
375 int width) {
376 asm volatile (
377 "vld1.8 {d24}, [%5] \n"
378 "vld1.8 {d25}, [%6] \n"
379 "vmov.u8 d26, #128 \n"
380 "vmov.u16 q14, #74 \n"
381 "vmov.u16 q15, #16 \n"
382 ".p2align 2 \n"
383 "1: \n"
384 READYUV422
385 YUV422TORGB
386 "subs %4, %4, #8 \n"
387 ARGBTORGB565
388 "vst1.8 {q0}, [%3]! \n" // store 8 pixels RGB565.
389 "bgt 1b \n"
390 : "+r"(src_y), // %0
391 "+r"(src_u), // %1
392 "+r"(src_v), // %2
393 "+r"(dst_rgb565), // %3
394 "+r"(width) // %4
395 : "r"(&kUVToRB), // %5
396 "r"(&kUVToG) // %6
397 : "cc", "memory", "q0", "q1", "q2", "q3",
398 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
399 );
400 }
401
402 #define ARGBTOARGB1555 \
403 "vshr.u8 q10, q10, #3 \n" /* B */ \
404 "vshr.u8 d22, d22, #3 \n" /* R */ \
405 "vshr.u8 d23, d23, #7 \n" /* A */ \
406 "vmovl.u8 q8, d20 \n" /* B */ \
407 "vmovl.u8 q9, d21 \n" /* G */ \
408 "vmovl.u8 q10, d22 \n" /* R */ \
409 "vmovl.u8 q11, d23 \n" /* A */ \
410 "vshl.u16 q9, q9, #5 \n" /* G */ \
411 "vshl.u16 q10, q10, #10 \n" /* R */ \
412 "vshl.u16 q11, q11, #15 \n" /* A */ \
413 "vorr q0, q8, q9 \n" /* BG */ \
414 "vorr q1, q10, q11 \n" /* RA */ \
415 "vorr q0, q0, q1 \n" /* BGRA */
416
417 void I422ToARGB1555Row_NEON(const uint8* src_y,
418 const uint8* src_u,
419 const uint8* src_v,
420 uint8* dst_argb1555,
421 int width) {
422 asm volatile (
423 "vld1.8 {d24}, [%5] \n"
424 "vld1.8 {d25}, [%6] \n"
425 "vmov.u8 d26, #128 \n"
426 "vmov.u16 q14, #74 \n"
427 "vmov.u16 q15, #16 \n"
428 ".p2align 2 \n"
429 "1: \n"
430 READYUV422
431 YUV422TORGB
432 "subs %4, %4, #8 \n"
433 "vmov.u8 d23, #255 \n"
434 ARGBTOARGB1555
435 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB1555.
436 "bgt 1b \n"
437 : "+r"(src_y), // %0
438 "+r"(src_u), // %1
439 "+r"(src_v), // %2
440 "+r"(dst_argb1555), // %3
441 "+r"(width) // %4
442 : "r"(&kUVToRB), // %5
443 "r"(&kUVToG) // %6
444 : "cc", "memory", "q0", "q1", "q2", "q3",
445 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
446 );
447 }
448
449 #define ARGBTOARGB4444 \
450 "vshr.u8 d20, d20, #4 \n" /* B */ \
451 "vbic.32 d21, d21, d4 \n" /* G */ \
452 "vshr.u8 d22, d22, #4 \n" /* R */ \
453 "vbic.32 d23, d23, d4 \n" /* A */ \
454 "vorr d0, d20, d21 \n" /* BG */ \
455 "vorr d1, d22, d23 \n" /* RA */ \
456 "vzip.u8 d0, d1 \n" /* BGRA */
457
458 void I422ToARGB4444Row_NEON(const uint8* src_y,
459 const uint8* src_u,
460 const uint8* src_v,
461 uint8* dst_argb4444,
462 int width) {
463 asm volatile (
464 "vld1.8 {d24}, [%5] \n"
465 "vld1.8 {d25}, [%6] \n"
466 "vmov.u8 d26, #128 \n"
467 "vmov.u16 q14, #74 \n"
468 "vmov.u16 q15, #16 \n"
469 "vmov.u8 d4, #0x0f \n" // bits to clear with vbic.
470 ".p2align 2 \n"
471 "1: \n"
472 READYUV422
473 YUV422TORGB
474 "subs %4, %4, #8 \n"
475 "vmov.u8 d23, #255 \n"
476 ARGBTOARGB4444
477 "vst1.8 {q0}, [%3]! \n" // store 8 pixels ARGB4444.
478 "bgt 1b \n"
479 : "+r"(src_y), // %0
480 "+r"(src_u), // %1
481 "+r"(src_v), // %2
482 "+r"(dst_argb4444), // %3
483 "+r"(width) // %4
484 : "r"(&kUVToRB), // %5
485 "r"(&kUVToG) // %6
486 : "cc", "memory", "q0", "q1", "q2", "q3",
487 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
488 );
489 }
490
491 void YToARGBRow_NEON(const uint8* src_y,
492 uint8* dst_argb,
493 int width) {
494 asm volatile (
495 "vld1.8 {d24}, [%3] \n"
496 "vld1.8 {d25}, [%4] \n"
497 "vmov.u8 d26, #128 \n"
498 "vmov.u16 q14, #74 \n"
499 "vmov.u16 q15, #16 \n"
500 ".p2align 2 \n"
501 "1: \n"
502 READYUV400
503 YUV422TORGB
504 "subs %2, %2, #8 \n"
505 "vmov.u8 d23, #255 \n"
506 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
507 "bgt 1b \n"
508 : "+r"(src_y), // %0
509 "+r"(dst_argb), // %1
510 "+r"(width) // %2
511 : "r"(&kUVToRB), // %3
512 "r"(&kUVToG) // %4
513 : "cc", "memory", "q0", "q1", "q2", "q3",
514 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
515 );
516 }
517
518 void I400ToARGBRow_NEON(const uint8* src_y,
519 uint8* dst_argb,
520 int width) {
521 asm volatile (
522 ".p2align 2 \n"
523 "vmov.u8 d23, #255 \n"
524 "1: \n"
525 "vld1.8 {d20}, [%0]! \n"
526 "vmov d21, d20 \n"
527 "vmov d22, d20 \n"
528 "subs %2, %2, #8 \n"
529 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
530 "bgt 1b \n"
531 : "+r"(src_y), // %0
532 "+r"(dst_argb), // %1
533 "+r"(width) // %2
534 :
535 : "cc", "memory", "d20", "d21", "d22", "d23"
536 );
537 }
538
539 void NV12ToARGBRow_NEON(const uint8* src_y,
540 const uint8* src_uv,
541 uint8* dst_argb,
542 int width) {
543 asm volatile (
544 "vld1.8 {d24}, [%4] \n"
545 "vld1.8 {d25}, [%5] \n"
546 "vmov.u8 d26, #128 \n"
547 "vmov.u16 q14, #74 \n"
548 "vmov.u16 q15, #16 \n"
549 ".p2align 2 \n"
550 "1: \n"
551 READNV12
552 YUV422TORGB
553 "subs %3, %3, #8 \n"
554 "vmov.u8 d23, #255 \n"
555 "vst4.8 {d20, d21, d22, d23}, [%2]! \n"
556 "bgt 1b \n"
557 : "+r"(src_y), // %0
558 "+r"(src_uv), // %1
559 "+r"(dst_argb), // %2
560 "+r"(width) // %3
561 : "r"(&kUVToRB), // %4
562 "r"(&kUVToG) // %5
563 : "cc", "memory", "q0", "q1", "q2", "q3",
564 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
565 );
566 }
567
568 void NV21ToARGBRow_NEON(const uint8* src_y,
569 const uint8* src_uv,
570 uint8* dst_argb,
571 int width) {
572 asm volatile (
573 "vld1.8 {d24}, [%4] \n"
574 "vld1.8 {d25}, [%5] \n"
575 "vmov.u8 d26, #128 \n"
576 "vmov.u16 q14, #74 \n"
577 "vmov.u16 q15, #16 \n"
578 ".p2align 2 \n"
579 "1: \n"
580 READNV21
581 YUV422TORGB
582 "subs %3, %3, #8 \n"
583 "vmov.u8 d23, #255 \n"
584 "vst4.8 {d20, d21, d22, d23}, [%2]! \n"
585 "bgt 1b \n"
586 : "+r"(src_y), // %0
587 "+r"(src_uv), // %1
588 "+r"(dst_argb), // %2
589 "+r"(width) // %3
590 : "r"(&kUVToRB), // %4
591 "r"(&kUVToG) // %5
592 : "cc", "memory", "q0", "q1", "q2", "q3",
593 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
594 );
595 }
596
597 void NV12ToRGB565Row_NEON(const uint8* src_y,
598 const uint8* src_uv,
599 uint8* dst_rgb565,
600 int width) {
601 asm volatile (
602 "vld1.8 {d24}, [%4] \n"
603 "vld1.8 {d25}, [%5] \n"
604 "vmov.u8 d26, #128 \n"
605 "vmov.u16 q14, #74 \n"
606 "vmov.u16 q15, #16 \n"
607 ".p2align 2 \n"
608 "1: \n"
609 READNV12
610 YUV422TORGB
611 "subs %3, %3, #8 \n"
612 ARGBTORGB565
613 "vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565.
614 "bgt 1b \n"
615 : "+r"(src_y), // %0
616 "+r"(src_uv), // %1
617 "+r"(dst_rgb565), // %2
618 "+r"(width) // %3
619 : "r"(&kUVToRB), // %4
620 "r"(&kUVToG) // %5
621 : "cc", "memory", "q0", "q1", "q2", "q3",
622 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
623 );
624 }
625
626 void NV21ToRGB565Row_NEON(const uint8* src_y,
627 const uint8* src_uv,
628 uint8* dst_rgb565,
629 int width) {
630 asm volatile (
631 "vld1.8 {d24}, [%4] \n"
632 "vld1.8 {d25}, [%5] \n"
633 "vmov.u8 d26, #128 \n"
634 "vmov.u16 q14, #74 \n"
635 "vmov.u16 q15, #16 \n"
636 ".p2align 2 \n"
637 "1: \n"
638 READNV21
639 YUV422TORGB
640 "subs %3, %3, #8 \n"
641 ARGBTORGB565
642 "vst1.8 {q0}, [%2]! \n" // store 8 pixels RGB565.
643 "bgt 1b \n"
644 : "+r"(src_y), // %0
645 "+r"(src_uv), // %1
646 "+r"(dst_rgb565), // %2
647 "+r"(width) // %3
648 : "r"(&kUVToRB), // %4
649 "r"(&kUVToG) // %5
650 : "cc", "memory", "q0", "q1", "q2", "q3",
651 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
652 );
653 }
654
655 void YUY2ToARGBRow_NEON(const uint8* src_yuy2,
656 uint8* dst_argb,
657 int width) {
658 asm volatile (
659 "vld1.8 {d24}, [%3] \n"
660 "vld1.8 {d25}, [%4] \n"
661 "vmov.u8 d26, #128 \n"
662 "vmov.u16 q14, #74 \n"
663 "vmov.u16 q15, #16 \n"
664 ".p2align 2 \n"
665 "1: \n"
666 READYUY2
667 YUV422TORGB
668 "subs %2, %2, #8 \n"
669 "vmov.u8 d23, #255 \n"
670 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
671 "bgt 1b \n"
672 : "+r"(src_yuy2), // %0
673 "+r"(dst_argb), // %1
674 "+r"(width) // %2
675 : "r"(&kUVToRB), // %3
676 "r"(&kUVToG) // %4
677 : "cc", "memory", "q0", "q1", "q2", "q3",
678 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
679 );
680 }
681
682 void UYVYToARGBRow_NEON(const uint8* src_uyvy,
683 uint8* dst_argb,
684 int width) {
685 asm volatile (
686 "vld1.8 {d24}, [%3] \n"
687 "vld1.8 {d25}, [%4] \n"
688 "vmov.u8 d26, #128 \n"
689 "vmov.u16 q14, #74 \n"
690 "vmov.u16 q15, #16 \n"
691 ".p2align 2 \n"
692 "1: \n"
693 READUYVY
694 YUV422TORGB
695 "subs %2, %2, #8 \n"
696 "vmov.u8 d23, #255 \n"
697 "vst4.8 {d20, d21, d22, d23}, [%1]! \n"
698 "bgt 1b \n"
699 : "+r"(src_uyvy), // %0
700 "+r"(dst_argb), // %1
701 "+r"(width) // %2
702 : "r"(&kUVToRB), // %3
703 "r"(&kUVToG) // %4
704 : "cc", "memory", "q0", "q1", "q2", "q3",
705 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
706 );
707 }
708
709 // Reads 16 pairs of UV and write even values to dst_u and odd to dst_v.
710 void SplitUVRow_NEON(const uint8* src_uv, uint8* dst_u, uint8* dst_v,
711 int width) {
712 asm volatile (
713 ".p2align 2 \n"
714 "1: \n"
715 "vld2.8 {q0, q1}, [%0]! \n" // load 16 pairs of UV
716 "subs %3, %3, #16 \n" // 16 processed per loop
717 "vst1.8 {q0}, [%1]! \n" // store U
718 "vst1.8 {q1}, [%2]! \n" // store V
719 "bgt 1b \n"
720 : "+r"(src_uv), // %0
721 "+r"(dst_u), // %1
722 "+r"(dst_v), // %2
723 "+r"(width) // %3 // Output registers
724 : // Input registers
725 : "cc", "memory", "q0", "q1" // Clobber List
726 );
727 }
728
729 // Reads 16 U's and V's and writes out 16 pairs of UV.
730 void MergeUVRow_NEON(const uint8* src_u, const uint8* src_v, uint8* dst_uv,
731 int width) {
732 asm volatile (
733 ".p2align 2 \n"
734 "1: \n"
735 "vld1.8 {q0}, [%0]! \n" // load U
736 "vld1.8 {q1}, [%1]! \n" // load V
737 "subs %3, %3, #16 \n" // 16 processed per loop
738 "vst2.u8 {q0, q1}, [%2]! \n" // store 16 pairs of UV
739 "bgt 1b \n"
740 :
741 "+r"(src_u), // %0
742 "+r"(src_v), // %1
743 "+r"(dst_uv), // %2
744 "+r"(width) // %3 // Output registers
745 : // Input registers
746 : "cc", "memory", "q0", "q1" // Clobber List
747 );
748 }
749
750 // Copy multiple of 32. vld4.8 allow unaligned and is fastest on a15.
751 void CopyRow_NEON(const uint8* src, uint8* dst, int count) {
752 asm volatile (
753 ".p2align 2 \n"
754 "1: \n"
755 "vld1.8 {d0, d1, d2, d3}, [%0]! \n" // load 32
756 "subs %2, %2, #32 \n" // 32 processed per loop
757 "vst1.8 {d0, d1, d2, d3}, [%1]! \n" // store 32
758 "bgt 1b \n"
759 : "+r"(src), // %0
760 "+r"(dst), // %1
761 "+r"(count) // %2 // Output registers
762 : // Input registers
763 : "cc", "memory", "q0", "q1" // Clobber List
764 );
765 }
766
767 // SetRow8 writes 'count' bytes using a 32 bit value repeated.
768 void SetRow_NEON(uint8* dst, uint32 v32, int count) {
769 asm volatile (
770 "vdup.u32 q0, %2 \n" // duplicate 4 ints
771 "1: \n"
772 "subs %1, %1, #16 \n" // 16 bytes per loop
773 "vst1.8 {q0}, [%0]! \n" // store
774 "bgt 1b \n"
775 : "+r"(dst), // %0
776 "+r"(count) // %1
777 : "r"(v32) // %2
778 : "cc", "memory", "q0"
779 );
780 }
781
782 // TODO(fbarchard): Make fully assembler
783 // SetRow32 writes 'count' words using a 32 bit value repeated.
784 void ARGBSetRows_NEON(uint8* dst, uint32 v32, int width,
785 int dst_stride, int height) {
786 for (int y = 0; y < height; ++y) {
787 SetRow_NEON(dst, v32, width << 2);
788 dst += dst_stride;
789 }
790 }
791
792 void MirrorRow_NEON(const uint8* src, uint8* dst, int width) {
793 asm volatile (
794 // Start at end of source row.
795 "mov r3, #-16 \n"
796 "add %0, %0, %2 \n"
797 "sub %0, #16 \n"
798
799 ".p2align 2 \n"
800 "1: \n"
801 "vld1.8 {q0}, [%0], r3 \n" // src -= 16
802 "subs %2, #16 \n" // 16 pixels per loop.
803 "vrev64.8 q0, q0 \n"
804 "vst1.8 {d1}, [%1]! \n" // dst += 16
805 "vst1.8 {d0}, [%1]! \n"
806 "bgt 1b \n"
807 : "+r"(src), // %0
808 "+r"(dst), // %1
809 "+r"(width) // %2
810 :
811 : "cc", "memory", "r3", "q0"
812 );
813 }
814
815 void MirrorUVRow_NEON(const uint8* src_uv, uint8* dst_u, uint8* dst_v,
816 int width) {
817 asm volatile (
818 // Start at end of source row.
819 "mov r12, #-16 \n"
820 "add %0, %0, %3, lsl #1 \n"
821 "sub %0, #16 \n"
822
823 ".p2align 2 \n"
824 "1: \n"
825 "vld2.8 {d0, d1}, [%0], r12 \n" // src -= 16
826 "subs %3, #8 \n" // 8 pixels per loop.
827 "vrev64.8 q0, q0 \n"
828 "vst1.8 {d0}, [%1]! \n" // dst += 8
829 "vst1.8 {d1}, [%2]! \n"
830 "bgt 1b \n"
831 : "+r"(src_uv), // %0
832 "+r"(dst_u), // %1
833 "+r"(dst_v), // %2
834 "+r"(width) // %3
835 :
836 : "cc", "memory", "r12", "q0"
837 );
838 }
839
840 void ARGBMirrorRow_NEON(const uint8* src, uint8* dst, int width) {
841 asm volatile (
842 // Start at end of source row.
843 "mov r3, #-16 \n"
844 "add %0, %0, %2, lsl #2 \n"
845 "sub %0, #16 \n"
846
847 ".p2align 2 \n"
848 "1: \n"
849 "vld1.8 {q0}, [%0], r3 \n" // src -= 16
850 "subs %2, #4 \n" // 4 pixels per loop.
851 "vrev64.32 q0, q0 \n"
852 "vst1.8 {d1}, [%1]! \n" // dst += 16
853 "vst1.8 {d0}, [%1]! \n"
854 "bgt 1b \n"
855 : "+r"(src), // %0
856 "+r"(dst), // %1
857 "+r"(width) // %2
858 :
859 : "cc", "memory", "r3", "q0"
860 );
861 }
862
863 void RGB24ToARGBRow_NEON(const uint8* src_rgb24, uint8* dst_argb, int pix) {
864 asm volatile (
865 "vmov.u8 d4, #255 \n" // Alpha
866 ".p2align 2 \n"
867 "1: \n"
868 "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RGB24.
869 "subs %2, %2, #8 \n" // 8 processed per loop.
870 "vst4.8 {d1, d2, d3, d4}, [%1]! \n" // store 8 pixels of ARGB.
871 "bgt 1b \n"
872 : "+r"(src_rgb24), // %0
873 "+r"(dst_argb), // %1
874 "+r"(pix) // %2
875 :
876 : "cc", "memory", "d1", "d2", "d3", "d4" // Clobber List
877 );
878 }
879
880 void RAWToARGBRow_NEON(const uint8* src_raw, uint8* dst_argb, int pix) {
881 asm volatile (
882 "vmov.u8 d4, #255 \n" // Alpha
883 ".p2align 2 \n"
884 "1: \n"
885 "vld3.8 {d1, d2, d3}, [%0]! \n" // load 8 pixels of RAW.
886 "subs %2, %2, #8 \n" // 8 processed per loop.
887 "vswp.u8 d1, d3 \n" // swap R, B
888 "vst4.8 {d1, d2, d3, d4}, [%1]! \n" // store 8 pixels of ARGB.
889 "bgt 1b \n"
890 : "+r"(src_raw), // %0
891 "+r"(dst_argb), // %1
892 "+r"(pix) // %2
893 :
894 : "cc", "memory", "d1", "d2", "d3", "d4" // Clobber List
895 );
896 }
897
898 #define RGB565TOARGB \
899 "vshrn.u16 d6, q0, #5 \n" /* G xxGGGGGG */ \
900 "vuzp.u8 d0, d1 \n" /* d0 xxxBBBBB RRRRRxxx */ \
901 "vshl.u8 d6, d6, #2 \n" /* G GGGGGG00 upper 6 */ \
902 "vshr.u8 d1, d1, #3 \n" /* R 000RRRRR lower 5 */ \
903 "vshl.u8 q0, q0, #3 \n" /* B,R BBBBB000 upper 5 */ \
904 "vshr.u8 q2, q0, #5 \n" /* B,R 00000BBB lower 3 */ \
905 "vorr.u8 d0, d0, d4 \n" /* B */ \
906 "vshr.u8 d4, d6, #6 \n" /* G 000000GG lower 2 */ \
907 "vorr.u8 d2, d1, d5 \n" /* R */ \
908 "vorr.u8 d1, d4, d6 \n" /* G */
909
910 void RGB565ToARGBRow_NEON(const uint8* src_rgb565, uint8* dst_argb, int pix) {
911 asm volatile (
912 "vmov.u8 d3, #255 \n" // Alpha
913 ".p2align 2 \n"
914 "1: \n"
915 "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels.
916 "subs %2, %2, #8 \n" // 8 processed per loop.
917 RGB565TOARGB
918 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB.
919 "bgt 1b \n"
920 : "+r"(src_rgb565), // %0
921 "+r"(dst_argb), // %1
922 "+r"(pix) // %2
923 :
924 : "cc", "memory", "q0", "q1", "q2", "q3" // Clobber List
925 );
926 }
927
928 #define ARGB1555TOARGB \
929 "vshrn.u16 d7, q0, #8 \n" /* A Arrrrrxx */ \
930 "vshr.u8 d6, d7, #2 \n" /* R xxxRRRRR */ \
931 "vshrn.u16 d5, q0, #5 \n" /* G xxxGGGGG */ \
932 "vmovn.u16 d4, q0 \n" /* B xxxBBBBB */ \
933 "vshr.u8 d7, d7, #7 \n" /* A 0000000A */ \
934 "vneg.s8 d7, d7 \n" /* A AAAAAAAA upper 8 */ \
935 "vshl.u8 d6, d6, #3 \n" /* R RRRRR000 upper 5 */ \
936 "vshr.u8 q1, q3, #5 \n" /* R,A 00000RRR lower 3 */ \
937 "vshl.u8 q0, q2, #3 \n" /* B,G BBBBB000 upper 5 */ \
938 "vshr.u8 q2, q0, #5 \n" /* B,G 00000BBB lower 3 */ \
939 "vorr.u8 q1, q1, q3 \n" /* R,A */ \
940 "vorr.u8 q0, q0, q2 \n" /* B,G */ \
941
942 // RGB555TOARGB is same as ARGB1555TOARGB but ignores alpha.
943 #define RGB555TOARGB \
944 "vshrn.u16 d6, q0, #5 \n" /* G xxxGGGGG */ \
945 "vuzp.u8 d0, d1 \n" /* d0 xxxBBBBB xRRRRRxx */ \
946 "vshl.u8 d6, d6, #3 \n" /* G GGGGG000 upper 5 */ \
947 "vshr.u8 d1, d1, #2 \n" /* R 00xRRRRR lower 5 */ \
948 "vshl.u8 q0, q0, #3 \n" /* B,R BBBBB000 upper 5 */ \
949 "vshr.u8 q2, q0, #5 \n" /* B,R 00000BBB lower 3 */ \
950 "vorr.u8 d0, d0, d4 \n" /* B */ \
951 "vshr.u8 d4, d6, #5 \n" /* G 00000GGG lower 3 */ \
952 "vorr.u8 d2, d1, d5 \n" /* R */ \
953 "vorr.u8 d1, d4, d6 \n" /* G */
954
955 void ARGB1555ToARGBRow_NEON(const uint8* src_argb1555, uint8* dst_argb,
956 int pix) {
957 asm volatile (
958 "vmov.u8 d3, #255 \n" // Alpha
959 ".p2align 2 \n"
960 "1: \n"
961 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels.
962 "subs %2, %2, #8 \n" // 8 processed per loop.
963 ARGB1555TOARGB
964 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB.
965 "bgt 1b \n"
966 : "+r"(src_argb1555), // %0
967 "+r"(dst_argb), // %1
968 "+r"(pix) // %2
969 :
970 : "cc", "memory", "q0", "q1", "q2", "q3" // Clobber List
971 );
972 }
973
974 #define ARGB4444TOARGB \
975 "vuzp.u8 d0, d1 \n" /* d0 BG, d1 RA */ \
976 "vshl.u8 q2, q0, #4 \n" /* B,R BBBB0000 */ \
977 "vshr.u8 q1, q0, #4 \n" /* G,A 0000GGGG */ \
978 "vshr.u8 q0, q2, #4 \n" /* B,R 0000BBBB */ \
979 "vorr.u8 q0, q0, q2 \n" /* B,R BBBBBBBB */ \
980 "vshl.u8 q2, q1, #4 \n" /* G,A GGGG0000 */ \
981 "vorr.u8 q1, q1, q2 \n" /* G,A GGGGGGGG */ \
982 "vswp.u8 d1, d2 \n" /* B,R,G,A -> B,G,R,A */
983
984 void ARGB4444ToARGBRow_NEON(const uint8* src_argb4444, uint8* dst_argb,
985 int pix) {
986 asm volatile (
987 "vmov.u8 d3, #255 \n" // Alpha
988 ".p2align 2 \n"
989 "1: \n"
990 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels.
991 "subs %2, %2, #8 \n" // 8 processed per loop.
992 ARGB4444TOARGB
993 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB.
994 "bgt 1b \n"
995 : "+r"(src_argb4444), // %0
996 "+r"(dst_argb), // %1
997 "+r"(pix) // %2
998 :
999 : "cc", "memory", "q0", "q1", "q2" // Clobber List
1000 );
1001 }
1002
1003 void ARGBToRGB24Row_NEON(const uint8* src_argb, uint8* dst_rgb24, int pix) {
1004 asm volatile (
1005 ".p2align 2 \n"
1006 "1: \n"
1007 "vld4.8 {d1, d2, d3, d4}, [%0]! \n" // load 8 pixels of ARGB.
1008 "subs %2, %2, #8 \n" // 8 processed per loop.
1009 "vst3.8 {d1, d2, d3}, [%1]! \n" // store 8 pixels of RGB24.
1010 "bgt 1b \n"
1011 : "+r"(src_argb), // %0
1012 "+r"(dst_rgb24), // %1
1013 "+r"(pix) // %2
1014 :
1015 : "cc", "memory", "d1", "d2", "d3", "d4" // Clobber List
1016 );
1017 }
1018
1019 void ARGBToRAWRow_NEON(const uint8* src_argb, uint8* dst_raw, int pix) {
1020 asm volatile (
1021 ".p2align 2 \n"
1022 "1: \n"
1023 "vld4.8 {d1, d2, d3, d4}, [%0]! \n" // load 8 pixels of ARGB.
1024 "subs %2, %2, #8 \n" // 8 processed per loop.
1025 "vswp.u8 d1, d3 \n" // swap R, B
1026 "vst3.8 {d1, d2, d3}, [%1]! \n" // store 8 pixels of RAW.
1027 "bgt 1b \n"
1028 : "+r"(src_argb), // %0
1029 "+r"(dst_raw), // %1
1030 "+r"(pix) // %2
1031 :
1032 : "cc", "memory", "d1", "d2", "d3", "d4" // Clobber List
1033 );
1034 }
1035
1036 void YUY2ToYRow_NEON(const uint8* src_yuy2, uint8* dst_y, int pix) {
1037 asm volatile (
1038 ".p2align 2 \n"
1039 "1: \n"
1040 "vld2.8 {q0, q1}, [%0]! \n" // load 16 pixels of YUY2.
1041 "subs %2, %2, #16 \n" // 16 processed per loop.
1042 "vst1.8 {q0}, [%1]! \n" // store 16 pixels of Y.
1043 "bgt 1b \n"
1044 : "+r"(src_yuy2), // %0
1045 "+r"(dst_y), // %1
1046 "+r"(pix) // %2
1047 :
1048 : "cc", "memory", "q0", "q1" // Clobber List
1049 );
1050 }
1051
1052 void UYVYToYRow_NEON(const uint8* src_uyvy, uint8* dst_y, int pix) {
1053 asm volatile (
1054 ".p2align 2 \n"
1055 "1: \n"
1056 "vld2.8 {q0, q1}, [%0]! \n" // load 16 pixels of UYVY.
1057 "subs %2, %2, #16 \n" // 16 processed per loop.
1058 "vst1.8 {q1}, [%1]! \n" // store 16 pixels of Y.
1059 "bgt 1b \n"
1060 : "+r"(src_uyvy), // %0
1061 "+r"(dst_y), // %1
1062 "+r"(pix) // %2
1063 :
1064 : "cc", "memory", "q0", "q1" // Clobber List
1065 );
1066 }
1067
1068 void YUY2ToUV422Row_NEON(const uint8* src_yuy2, uint8* dst_u, uint8* dst_v,
1069 int pix) {
1070 asm volatile (
1071 ".p2align 2 \n"
1072 "1: \n"
1073 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of YUY2.
1074 "subs %3, %3, #16 \n" // 16 pixels = 8 UVs.
1075 "vst1.8 {d1}, [%1]! \n" // store 8 U.
1076 "vst1.8 {d3}, [%2]! \n" // store 8 V.
1077 "bgt 1b \n"
1078 : "+r"(src_yuy2), // %0
1079 "+r"(dst_u), // %1
1080 "+r"(dst_v), // %2
1081 "+r"(pix) // %3
1082 :
1083 : "cc", "memory", "d0", "d1", "d2", "d3" // Clobber List
1084 );
1085 }
1086
1087 void UYVYToUV422Row_NEON(const uint8* src_uyvy, uint8* dst_u, uint8* dst_v,
1088 int pix) {
1089 asm volatile (
1090 ".p2align 2 \n"
1091 "1: \n"
1092 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of UYVY.
1093 "subs %3, %3, #16 \n" // 16 pixels = 8 UVs.
1094 "vst1.8 {d0}, [%1]! \n" // store 8 U.
1095 "vst1.8 {d2}, [%2]! \n" // store 8 V.
1096 "bgt 1b \n"
1097 : "+r"(src_uyvy), // %0
1098 "+r"(dst_u), // %1
1099 "+r"(dst_v), // %2
1100 "+r"(pix) // %3
1101 :
1102 : "cc", "memory", "d0", "d1", "d2", "d3" // Clobber List
1103 );
1104 }
1105
1106 void YUY2ToUVRow_NEON(const uint8* src_yuy2, int stride_yuy2,
1107 uint8* dst_u, uint8* dst_v, int pix) {
1108 asm volatile (
1109 "add %1, %0, %1 \n" // stride + src_yuy2
1110 ".p2align 2 \n"
1111 "1: \n"
1112 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of YUY2.
1113 "subs %4, %4, #16 \n" // 16 pixels = 8 UVs.
1114 "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load next row YUY2.
1115 "vrhadd.u8 d1, d1, d5 \n" // average rows of U
1116 "vrhadd.u8 d3, d3, d7 \n" // average rows of V
1117 "vst1.8 {d1}, [%2]! \n" // store 8 U.
1118 "vst1.8 {d3}, [%3]! \n" // store 8 V.
1119 "bgt 1b \n"
1120 : "+r"(src_yuy2), // %0
1121 "+r"(stride_yuy2), // %1
1122 "+r"(dst_u), // %2
1123 "+r"(dst_v), // %3
1124 "+r"(pix) // %4
1125 :
1126 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7" // Clobber List
1127 );
1128 }
1129
1130 void UYVYToUVRow_NEON(const uint8* src_uyvy, int stride_uyvy,
1131 uint8* dst_u, uint8* dst_v, int pix) {
1132 asm volatile (
1133 "add %1, %0, %1 \n" // stride + src_uyvy
1134 ".p2align 2 \n"
1135 "1: \n"
1136 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 16 pixels of UYVY.
1137 "subs %4, %4, #16 \n" // 16 pixels = 8 UVs.
1138 "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load next row UYVY.
1139 "vrhadd.u8 d0, d0, d4 \n" // average rows of U
1140 "vrhadd.u8 d2, d2, d6 \n" // average rows of V
1141 "vst1.8 {d0}, [%2]! \n" // store 8 U.
1142 "vst1.8 {d2}, [%3]! \n" // store 8 V.
1143 "bgt 1b \n"
1144 : "+r"(src_uyvy), // %0
1145 "+r"(stride_uyvy), // %1
1146 "+r"(dst_u), // %2
1147 "+r"(dst_v), // %3
1148 "+r"(pix) // %4
1149 :
1150 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7" // Clobber List
1151 );
1152 }
1153
1154 void HalfRow_NEON(const uint8* src_uv, int src_uv_stride,
1155 uint8* dst_uv, int pix) {
1156 asm volatile (
1157 // change the stride to row 2 pointer
1158 "add %1, %0 \n"
1159 "1: \n"
1160 "vld1.8 {q0}, [%0]! \n" // load row 1 16 pixels.
1161 "subs %3, %3, #16 \n" // 16 processed per loop
1162 "vld1.8 {q1}, [%1]! \n" // load row 2 16 pixels.
1163 "vrhadd.u8 q0, q1 \n" // average row 1 and 2
1164 "vst1.8 {q0}, [%2]! \n"
1165 "bgt 1b \n"
1166 : "+r"(src_uv), // %0
1167 "+r"(src_uv_stride), // %1
1168 "+r"(dst_uv), // %2
1169 "+r"(pix) // %3
1170 :
1171 : "cc", "memory", "q0", "q1" // Clobber List
1172 );
1173 }
1174
1175 // Select 2 channels from ARGB on alternating pixels. e.g. BGBGBGBG
1176 void ARGBToBayerRow_NEON(const uint8* src_argb, uint8* dst_bayer,
1177 uint32 selector, int pix) {
1178 asm volatile (
1179 "vmov.u32 d6[0], %3 \n" // selector
1180 "1: \n"
1181 "vld1.8 {q0, q1}, [%0]! \n" // load row 8 pixels.
1182 "subs %2, %2, #8 \n" // 8 processed per loop
1183 "vtbl.8 d4, {d0, d1}, d6 \n" // look up 4 pixels
1184 "vtbl.8 d5, {d2, d3}, d6 \n" // look up 4 pixels
1185 "vtrn.u32 d4, d5 \n" // combine 8 pixels
1186 "vst1.8 {d4}, [%1]! \n" // store 8.
1187 "bgt 1b \n"
1188 : "+r"(src_argb), // %0
1189 "+r"(dst_bayer), // %1
1190 "+r"(pix) // %2
1191 : "r"(selector) // %3
1192 : "cc", "memory", "q0", "q1", "q2", "q3" // Clobber List
1193 );
1194 }
1195
1196 // Select G channels from ARGB. e.g. GGGGGGGG
1197 void ARGBToBayerGGRow_NEON(const uint8* src_argb, uint8* dst_bayer,
1198 uint32 /*selector*/, int pix) {
1199 asm volatile (
1200 "1: \n"
1201 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load row 8 pixels.
1202 "subs %2, %2, #8 \n" // 8 processed per loop
1203 "vst1.8 {d1}, [%1]! \n" // store 8 G's.
1204 "bgt 1b \n"
1205 : "+r"(src_argb), // %0
1206 "+r"(dst_bayer), // %1
1207 "+r"(pix) // %2
1208 :
1209 : "cc", "memory", "q0", "q1" // Clobber List
1210 );
1211 }
1212
1213 // For BGRAToARGB, ABGRToARGB, RGBAToARGB, and ARGBToRGBA.
1214 void ARGBShuffleRow_NEON(const uint8* src_argb, uint8* dst_argb,
1215 const uint8* shuffler, int pix) {
1216 asm volatile (
1217 "vld1.8 {q2}, [%3] \n" // shuffler
1218 "1: \n"
1219 "vld1.8 {q0}, [%0]! \n" // load 4 pixels.
1220 "subs %2, %2, #4 \n" // 4 processed per loop
1221 "vtbl.8 d2, {d0, d1}, d4 \n" // look up 2 first pixels
1222 "vtbl.8 d3, {d0, d1}, d5 \n" // look up 2 next pixels
1223 "vst1.8 {q1}, [%1]! \n" // store 4.
1224 "bgt 1b \n"
1225 : "+r"(src_argb), // %0
1226 "+r"(dst_argb), // %1
1227 "+r"(pix) // %2
1228 : "r"(shuffler) // %3
1229 : "cc", "memory", "q0", "q1", "q2" // Clobber List
1230 );
1231 }
1232
1233 void I422ToYUY2Row_NEON(const uint8* src_y,
1234 const uint8* src_u,
1235 const uint8* src_v,
1236 uint8* dst_yuy2, int width) {
1237 asm volatile (
1238 ".p2align 2 \n"
1239 "1: \n"
1240 "vld2.8 {d0, d2}, [%0]! \n" // load 16 Ys
1241 "vld1.8 {d1}, [%1]! \n" // load 8 Us
1242 "vld1.8 {d3}, [%2]! \n" // load 8 Vs
1243 "subs %4, %4, #16 \n" // 16 pixels
1244 "vst4.8 {d0, d1, d2, d3}, [%3]! \n" // Store 8 YUY2/16 pixels.
1245 "bgt 1b \n"
1246 : "+r"(src_y), // %0
1247 "+r"(src_u), // %1
1248 "+r"(src_v), // %2
1249 "+r"(dst_yuy2), // %3
1250 "+r"(width) // %4
1251 :
1252 : "cc", "memory", "d0", "d1", "d2", "d3"
1253 );
1254 }
1255
1256 void I422ToUYVYRow_NEON(const uint8* src_y,
1257 const uint8* src_u,
1258 const uint8* src_v,
1259 uint8* dst_uyvy, int width) {
1260 asm volatile (
1261 ".p2align 2 \n"
1262 "1: \n"
1263 "vld2.8 {d1, d3}, [%0]! \n" // load 16 Ys
1264 "vld1.8 {d0}, [%1]! \n" // load 8 Us
1265 "vld1.8 {d2}, [%2]! \n" // load 8 Vs
1266 "subs %4, %4, #16 \n" // 16 pixels
1267 "vst4.8 {d0, d1, d2, d3}, [%3]! \n" // Store 8 UYVY/16 pixels.
1268 "bgt 1b \n"
1269 : "+r"(src_y), // %0
1270 "+r"(src_u), // %1
1271 "+r"(src_v), // %2
1272 "+r"(dst_uyvy), // %3
1273 "+r"(width) // %4
1274 :
1275 : "cc", "memory", "d0", "d1", "d2", "d3"
1276 );
1277 }
1278
1279 void ARGBToRGB565Row_NEON(const uint8* src_argb, uint8* dst_rgb565, int pix) {
1280 asm volatile (
1281 ".p2align 2 \n"
1282 "1: \n"
1283 "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB.
1284 "subs %2, %2, #8 \n" // 8 processed per loop.
1285 ARGBTORGB565
1286 "vst1.8 {q0}, [%1]! \n" // store 8 pixels RGB565.
1287 "bgt 1b \n"
1288 : "+r"(src_argb), // %0
1289 "+r"(dst_rgb565), // %1
1290 "+r"(pix) // %2
1291 :
1292 : "cc", "memory", "q0", "q8", "q9", "q10", "q11"
1293 );
1294 }
1295
1296 void ARGBToARGB1555Row_NEON(const uint8* src_argb, uint8* dst_argb1555,
1297 int pix) {
1298 asm volatile (
1299 ".p2align 2 \n"
1300 "1: \n"
1301 "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB.
1302 "subs %2, %2, #8 \n" // 8 processed per loop.
1303 ARGBTOARGB1555
1304 "vst1.8 {q0}, [%1]! \n" // store 8 pixels ARGB1555.
1305 "bgt 1b \n"
1306 : "+r"(src_argb), // %0
1307 "+r"(dst_argb1555), // %1
1308 "+r"(pix) // %2
1309 :
1310 : "cc", "memory", "q0", "q8", "q9", "q10", "q11"
1311 );
1312 }
1313
1314 void ARGBToARGB4444Row_NEON(const uint8* src_argb, uint8* dst_argb4444,
1315 int pix) {
1316 asm volatile (
1317 "vmov.u8 d4, #0x0f \n" // bits to clear with vbic.
1318 ".p2align 2 \n"
1319 "1: \n"
1320 "vld4.8 {d20, d21, d22, d23}, [%0]! \n" // load 8 pixels of ARGB.
1321 "subs %2, %2, #8 \n" // 8 processed per loop.
1322 ARGBTOARGB4444
1323 "vst1.8 {q0}, [%1]! \n" // store 8 pixels ARGB4444.
1324 "bgt 1b \n"
1325 : "+r"(src_argb), // %0
1326 "+r"(dst_argb4444), // %1
1327 "+r"(pix) // %2
1328 :
1329 : "cc", "memory", "q0", "q8", "q9", "q10", "q11"
1330 );
1331 }
1332
1333 void ARGBToYRow_NEON(const uint8* src_argb, uint8* dst_y, int pix) {
1334 asm volatile (
1335 "vmov.u8 d24, #13 \n" // B * 0.1016 coefficient
1336 "vmov.u8 d25, #65 \n" // G * 0.5078 coefficient
1337 "vmov.u8 d26, #33 \n" // R * 0.2578 coefficient
1338 "vmov.u8 d27, #16 \n" // Add 16 constant
1339 ".p2align 2 \n"
1340 "1: \n"
1341 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
1342 "subs %2, %2, #8 \n" // 8 processed per loop.
1343 "vmull.u8 q2, d0, d24 \n" // B
1344 "vmlal.u8 q2, d1, d25 \n" // G
1345 "vmlal.u8 q2, d2, d26 \n" // R
1346 "vqrshrun.s16 d0, q2, #7 \n" // 16 bit to 8 bit Y
1347 "vqadd.u8 d0, d27 \n"
1348 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
1349 "bgt 1b \n"
1350 : "+r"(src_argb), // %0
1351 "+r"(dst_y), // %1
1352 "+r"(pix) // %2
1353 :
1354 : "cc", "memory", "q0", "q1", "q2", "q12", "q13"
1355 );
1356 }
1357
1358 void ARGBToYJRow_NEON(const uint8* src_argb, uint8* dst_y, int pix) {
1359 asm volatile (
1360 "vmov.u8 d24, #15 \n" // B * 0.11400 coefficient
1361 "vmov.u8 d25, #75 \n" // G * 0.58700 coefficient
1362 "vmov.u8 d26, #38 \n" // R * 0.29900 coefficient
1363 ".p2align 2 \n"
1364 "1: \n"
1365 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
1366 "subs %2, %2, #8 \n" // 8 processed per loop.
1367 "vmull.u8 q2, d0, d24 \n" // B
1368 "vmlal.u8 q2, d1, d25 \n" // G
1369 "vmlal.u8 q2, d2, d26 \n" // R
1370 "vqrshrun.s16 d0, q2, #7 \n" // 15 bit to 8 bit Y
1371 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
1372 "bgt 1b \n"
1373 : "+r"(src_argb), // %0
1374 "+r"(dst_y), // %1
1375 "+r"(pix) // %2
1376 :
1377 : "cc", "memory", "q0", "q1", "q2", "q12", "q13"
1378 );
1379 }
1380
1381 // 8x1 pixels.
1382 void ARGBToUV444Row_NEON(const uint8* src_argb, uint8* dst_u, uint8* dst_v,
1383 int pix) {
1384 asm volatile (
1385 "vmov.u8 d24, #112 \n" // UB / VR 0.875 coefficient
1386 "vmov.u8 d25, #74 \n" // UG -0.5781 coefficient
1387 "vmov.u8 d26, #38 \n" // UR -0.2969 coefficient
1388 "vmov.u8 d27, #18 \n" // VB -0.1406 coefficient
1389 "vmov.u8 d28, #94 \n" // VG -0.7344 coefficient
1390 "vmov.u16 q15, #0x8080 \n" // 128.5
1391 ".p2align 2 \n"
1392 "1: \n"
1393 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
1394 "subs %3, %3, #8 \n" // 8 processed per loop.
1395 "vmull.u8 q2, d0, d24 \n" // B
1396 "vmlsl.u8 q2, d1, d25 \n" // G
1397 "vmlsl.u8 q2, d2, d26 \n" // R
1398 "vadd.u16 q2, q2, q15 \n" // +128 -> unsigned
1399
1400 "vmull.u8 q3, d2, d24 \n" // R
1401 "vmlsl.u8 q3, d1, d28 \n" // G
1402 "vmlsl.u8 q3, d0, d27 \n" // B
1403 "vadd.u16 q3, q3, q15 \n" // +128 -> unsigned
1404
1405 "vqshrn.u16 d0, q2, #8 \n" // 16 bit to 8 bit U
1406 "vqshrn.u16 d1, q3, #8 \n" // 16 bit to 8 bit V
1407
1408 "vst1.8 {d0}, [%1]! \n" // store 8 pixels U.
1409 "vst1.8 {d1}, [%2]! \n" // store 8 pixels V.
1410 "bgt 1b \n"
1411 : "+r"(src_argb), // %0
1412 "+r"(dst_u), // %1
1413 "+r"(dst_v), // %2
1414 "+r"(pix) // %3
1415 :
1416 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q12", "q13", "q14", "q15"
1417 );
1418 }
1419
1420 // 16x1 pixels -> 8x1. pix is number of argb pixels. e.g. 16.
1421 void ARGBToUV422Row_NEON(const uint8* src_argb, uint8* dst_u, uint8* dst_v,
1422 int pix) {
1423 asm volatile (
1424 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1425 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1426 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1427 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1428 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1429 "vmov.u16 q15, #0x8080 \n" // 128.5
1430 ".p2align 2 \n"
1431 "1: \n"
1432 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels.
1433 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels.
1434
1435 "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts.
1436 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1437 "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts.
1438
1439 "subs %3, %3, #16 \n" // 16 processed per loop.
1440 "vmul.s16 q8, q0, q10 \n" // B
1441 "vmls.s16 q8, q1, q11 \n" // G
1442 "vmls.s16 q8, q2, q12 \n" // R
1443 "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned
1444
1445 "vmul.s16 q9, q2, q10 \n" // R
1446 "vmls.s16 q9, q1, q14 \n" // G
1447 "vmls.s16 q9, q0, q13 \n" // B
1448 "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned
1449
1450 "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U
1451 "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V
1452
1453 "vst1.8 {d0}, [%1]! \n" // store 8 pixels U.
1454 "vst1.8 {d1}, [%2]! \n" // store 8 pixels V.
1455 "bgt 1b \n"
1456 : "+r"(src_argb), // %0
1457 "+r"(dst_u), // %1
1458 "+r"(dst_v), // %2
1459 "+r"(pix) // %3
1460 :
1461 : "cc", "memory", "q0", "q1", "q2", "q3",
1462 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1463 );
1464 }
1465
1466 // 32x1 pixels -> 8x1. pix is number of argb pixels. e.g. 32.
1467 void ARGBToUV411Row_NEON(const uint8* src_argb, uint8* dst_u, uint8* dst_v,
1468 int pix) {
1469 asm volatile (
1470 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1471 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1472 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1473 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1474 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1475 "vmov.u16 q15, #0x8080 \n" // 128.5
1476 ".p2align 2 \n"
1477 "1: \n"
1478 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels.
1479 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels.
1480 "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts.
1481 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1482 "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts.
1483 "vld4.8 {d8, d10, d12, d14}, [%0]! \n" // load 8 more ARGB pixels.
1484 "vld4.8 {d9, d11, d13, d15}, [%0]! \n" // load last 8 ARGB pixels.
1485 "vpaddl.u8 q4, q4 \n" // B 16 bytes -> 8 shorts.
1486 "vpaddl.u8 q5, q5 \n" // G 16 bytes -> 8 shorts.
1487 "vpaddl.u8 q6, q6 \n" // R 16 bytes -> 8 shorts.
1488
1489 "vpadd.u16 d0, d0, d1 \n" // B 16 shorts -> 8 shorts.
1490 "vpadd.u16 d1, d8, d9 \n" // B
1491 "vpadd.u16 d2, d2, d3 \n" // G 16 shorts -> 8 shorts.
1492 "vpadd.u16 d3, d10, d11 \n" // G
1493 "vpadd.u16 d4, d4, d5 \n" // R 16 shorts -> 8 shorts.
1494 "vpadd.u16 d5, d12, d13 \n" // R
1495
1496 "vrshr.u16 q0, q0, #1 \n" // 2x average
1497 "vrshr.u16 q1, q1, #1 \n"
1498 "vrshr.u16 q2, q2, #1 \n"
1499
1500 "subs %3, %3, #32 \n" // 32 processed per loop.
1501 "vmul.s16 q8, q0, q10 \n" // B
1502 "vmls.s16 q8, q1, q11 \n" // G
1503 "vmls.s16 q8, q2, q12 \n" // R
1504 "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned
1505 "vmul.s16 q9, q2, q10 \n" // R
1506 "vmls.s16 q9, q1, q14 \n" // G
1507 "vmls.s16 q9, q0, q13 \n" // B
1508 "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned
1509 "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U
1510 "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V
1511 "vst1.8 {d0}, [%1]! \n" // store 8 pixels U.
1512 "vst1.8 {d1}, [%2]! \n" // store 8 pixels V.
1513 "bgt 1b \n"
1514 : "+r"(src_argb), // %0
1515 "+r"(dst_u), // %1
1516 "+r"(dst_v), // %2
1517 "+r"(pix) // %3
1518 :
1519 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1520 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1521 );
1522 }
1523
1524 // 16x2 pixels -> 8x1. pix is number of argb pixels. e.g. 16.
1525 #define RGBTOUV(QB, QG, QR) \
1526 "vmul.s16 q8, " #QB ", q10 \n" /* B */ \
1527 "vmls.s16 q8, " #QG ", q11 \n" /* G */ \
1528 "vmls.s16 q8, " #QR ", q12 \n" /* R */ \
1529 "vadd.u16 q8, q8, q15 \n" /* +128 -> unsigned */ \
1530 "vmul.s16 q9, " #QR ", q10 \n" /* R */ \
1531 "vmls.s16 q9, " #QG ", q14 \n" /* G */ \
1532 "vmls.s16 q9, " #QB ", q13 \n" /* B */ \
1533 "vadd.u16 q9, q9, q15 \n" /* +128 -> unsigned */ \
1534 "vqshrn.u16 d0, q8, #8 \n" /* 16 bit to 8 bit U */ \
1535 "vqshrn.u16 d1, q9, #8 \n" /* 16 bit to 8 bit V */
1536
1537 // TODO(fbarchard): Consider vhadd vertical, then vpaddl horizontal, avoid shr.
1538 void ARGBToUVRow_NEON(const uint8* src_argb, int src_stride_argb,
1539 uint8* dst_u, uint8* dst_v, int pix) {
1540 asm volatile (
1541 "add %1, %0, %1 \n" // src_stride + src_argb
1542 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1543 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1544 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1545 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1546 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1547 "vmov.u16 q15, #0x8080 \n" // 128.5
1548 ".p2align 2 \n"
1549 "1: \n"
1550 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels.
1551 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels.
1552 "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts.
1553 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1554 "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts.
1555 "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ARGB pixels.
1556 "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ARGB pixels.
1557 "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts.
1558 "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts.
1559 "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts.
1560
1561 "vrshr.u16 q0, q0, #1 \n" // 2x average
1562 "vrshr.u16 q1, q1, #1 \n"
1563 "vrshr.u16 q2, q2, #1 \n"
1564
1565 "subs %4, %4, #16 \n" // 32 processed per loop.
1566 RGBTOUV(q0, q1, q2)
1567 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1568 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1569 "bgt 1b \n"
1570 : "+r"(src_argb), // %0
1571 "+r"(src_stride_argb), // %1
1572 "+r"(dst_u), // %2
1573 "+r"(dst_v), // %3
1574 "+r"(pix) // %4
1575 :
1576 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1577 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1578 );
1579 }
1580
1581 // TODO(fbarchard): Subsample match C code.
1582 void ARGBToUVJRow_NEON(const uint8* src_argb, int src_stride_argb,
1583 uint8* dst_u, uint8* dst_v, int pix) {
1584 asm volatile (
1585 "add %1, %0, %1 \n" // src_stride + src_argb
1586 "vmov.s16 q10, #127 / 2 \n" // UB / VR 0.500 coefficient
1587 "vmov.s16 q11, #84 / 2 \n" // UG -0.33126 coefficient
1588 "vmov.s16 q12, #43 / 2 \n" // UR -0.16874 coefficient
1589 "vmov.s16 q13, #20 / 2 \n" // VB -0.08131 coefficient
1590 "vmov.s16 q14, #107 / 2 \n" // VG -0.41869 coefficient
1591 "vmov.u16 q15, #0x8080 \n" // 128.5
1592 ".p2align 2 \n"
1593 "1: \n"
1594 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels.
1595 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ARGB pixels.
1596 "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts.
1597 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1598 "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts.
1599 "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ARGB pixels.
1600 "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ARGB pixels.
1601 "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts.
1602 "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts.
1603 "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts.
1604
1605 "vrshr.u16 q0, q0, #1 \n" // 2x average
1606 "vrshr.u16 q1, q1, #1 \n"
1607 "vrshr.u16 q2, q2, #1 \n"
1608
1609 "subs %4, %4, #16 \n" // 32 processed per loop.
1610 RGBTOUV(q0, q1, q2)
1611 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1612 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1613 "bgt 1b \n"
1614 : "+r"(src_argb), // %0
1615 "+r"(src_stride_argb), // %1
1616 "+r"(dst_u), // %2
1617 "+r"(dst_v), // %3
1618 "+r"(pix) // %4
1619 :
1620 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1621 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1622 );
1623 }
1624
1625 void BGRAToUVRow_NEON(const uint8* src_bgra, int src_stride_bgra,
1626 uint8* dst_u, uint8* dst_v, int pix) {
1627 asm volatile (
1628 "add %1, %0, %1 \n" // src_stride + src_bgra
1629 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1630 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1631 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1632 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1633 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1634 "vmov.u16 q15, #0x8080 \n" // 128.5
1635 ".p2align 2 \n"
1636 "1: \n"
1637 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 BGRA pixels.
1638 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 BGRA pixels.
1639 "vpaddl.u8 q3, q3 \n" // B 16 bytes -> 8 shorts.
1640 "vpaddl.u8 q2, q2 \n" // G 16 bytes -> 8 shorts.
1641 "vpaddl.u8 q1, q1 \n" // R 16 bytes -> 8 shorts.
1642 "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more BGRA pixels.
1643 "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 BGRA pixels.
1644 "vpadal.u8 q3, q7 \n" // B 16 bytes -> 8 shorts.
1645 "vpadal.u8 q2, q6 \n" // G 16 bytes -> 8 shorts.
1646 "vpadal.u8 q1, q5 \n" // R 16 bytes -> 8 shorts.
1647
1648 "vrshr.u16 q1, q1, #1 \n" // 2x average
1649 "vrshr.u16 q2, q2, #1 \n"
1650 "vrshr.u16 q3, q3, #1 \n"
1651
1652 "subs %4, %4, #16 \n" // 32 processed per loop.
1653 RGBTOUV(q3, q2, q1)
1654 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1655 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1656 "bgt 1b \n"
1657 : "+r"(src_bgra), // %0
1658 "+r"(src_stride_bgra), // %1
1659 "+r"(dst_u), // %2
1660 "+r"(dst_v), // %3
1661 "+r"(pix) // %4
1662 :
1663 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1664 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1665 );
1666 }
1667
1668 void ABGRToUVRow_NEON(const uint8* src_abgr, int src_stride_abgr,
1669 uint8* dst_u, uint8* dst_v, int pix) {
1670 asm volatile (
1671 "add %1, %0, %1 \n" // src_stride + src_abgr
1672 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1673 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1674 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1675 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1676 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1677 "vmov.u16 q15, #0x8080 \n" // 128.5
1678 ".p2align 2 \n"
1679 "1: \n"
1680 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ABGR pixels.
1681 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 ABGR pixels.
1682 "vpaddl.u8 q2, q2 \n" // B 16 bytes -> 8 shorts.
1683 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1684 "vpaddl.u8 q0, q0 \n" // R 16 bytes -> 8 shorts.
1685 "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more ABGR pixels.
1686 "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 ABGR pixels.
1687 "vpadal.u8 q2, q6 \n" // B 16 bytes -> 8 shorts.
1688 "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts.
1689 "vpadal.u8 q0, q4 \n" // R 16 bytes -> 8 shorts.
1690
1691 "vrshr.u16 q0, q0, #1 \n" // 2x average
1692 "vrshr.u16 q1, q1, #1 \n"
1693 "vrshr.u16 q2, q2, #1 \n"
1694
1695 "subs %4, %4, #16 \n" // 32 processed per loop.
1696 RGBTOUV(q2, q1, q0)
1697 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1698 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1699 "bgt 1b \n"
1700 : "+r"(src_abgr), // %0
1701 "+r"(src_stride_abgr), // %1
1702 "+r"(dst_u), // %2
1703 "+r"(dst_v), // %3
1704 "+r"(pix) // %4
1705 :
1706 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1707 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1708 );
1709 }
1710
1711 void RGBAToUVRow_NEON(const uint8* src_rgba, int src_stride_rgba,
1712 uint8* dst_u, uint8* dst_v, int pix) {
1713 asm volatile (
1714 "add %1, %0, %1 \n" // src_stride + src_rgba
1715 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1716 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1717 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1718 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1719 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1720 "vmov.u16 q15, #0x8080 \n" // 128.5
1721 ".p2align 2 \n"
1722 "1: \n"
1723 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 RGBA pixels.
1724 "vld4.8 {d1, d3, d5, d7}, [%0]! \n" // load next 8 RGBA pixels.
1725 "vpaddl.u8 q0, q1 \n" // B 16 bytes -> 8 shorts.
1726 "vpaddl.u8 q1, q2 \n" // G 16 bytes -> 8 shorts.
1727 "vpaddl.u8 q2, q3 \n" // R 16 bytes -> 8 shorts.
1728 "vld4.8 {d8, d10, d12, d14}, [%1]! \n" // load 8 more RGBA pixels.
1729 "vld4.8 {d9, d11, d13, d15}, [%1]! \n" // load last 8 RGBA pixels.
1730 "vpadal.u8 q0, q5 \n" // B 16 bytes -> 8 shorts.
1731 "vpadal.u8 q1, q6 \n" // G 16 bytes -> 8 shorts.
1732 "vpadal.u8 q2, q7 \n" // R 16 bytes -> 8 shorts.
1733
1734 "vrshr.u16 q0, q0, #1 \n" // 2x average
1735 "vrshr.u16 q1, q1, #1 \n"
1736 "vrshr.u16 q2, q2, #1 \n"
1737
1738 "subs %4, %4, #16 \n" // 32 processed per loop.
1739 RGBTOUV(q0, q1, q2)
1740 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1741 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1742 "bgt 1b \n"
1743 : "+r"(src_rgba), // %0
1744 "+r"(src_stride_rgba), // %1
1745 "+r"(dst_u), // %2
1746 "+r"(dst_v), // %3
1747 "+r"(pix) // %4
1748 :
1749 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1750 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1751 );
1752 }
1753
1754 void RGB24ToUVRow_NEON(const uint8* src_rgb24, int src_stride_rgb24,
1755 uint8* dst_u, uint8* dst_v, int pix) {
1756 asm volatile (
1757 "add %1, %0, %1 \n" // src_stride + src_rgb24
1758 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1759 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1760 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1761 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1762 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1763 "vmov.u16 q15, #0x8080 \n" // 128.5
1764 ".p2align 2 \n"
1765 "1: \n"
1766 "vld3.8 {d0, d2, d4}, [%0]! \n" // load 8 RGB24 pixels.
1767 "vld3.8 {d1, d3, d5}, [%0]! \n" // load next 8 RGB24 pixels.
1768 "vpaddl.u8 q0, q0 \n" // B 16 bytes -> 8 shorts.
1769 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1770 "vpaddl.u8 q2, q2 \n" // R 16 bytes -> 8 shorts.
1771 "vld3.8 {d8, d10, d12}, [%1]! \n" // load 8 more RGB24 pixels.
1772 "vld3.8 {d9, d11, d13}, [%1]! \n" // load last 8 RGB24 pixels.
1773 "vpadal.u8 q0, q4 \n" // B 16 bytes -> 8 shorts.
1774 "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts.
1775 "vpadal.u8 q2, q6 \n" // R 16 bytes -> 8 shorts.
1776
1777 "vrshr.u16 q0, q0, #1 \n" // 2x average
1778 "vrshr.u16 q1, q1, #1 \n"
1779 "vrshr.u16 q2, q2, #1 \n"
1780
1781 "subs %4, %4, #16 \n" // 32 processed per loop.
1782 RGBTOUV(q0, q1, q2)
1783 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1784 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1785 "bgt 1b \n"
1786 : "+r"(src_rgb24), // %0
1787 "+r"(src_stride_rgb24), // %1
1788 "+r"(dst_u), // %2
1789 "+r"(dst_v), // %3
1790 "+r"(pix) // %4
1791 :
1792 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1793 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1794 );
1795 }
1796
1797 void RAWToUVRow_NEON(const uint8* src_raw, int src_stride_raw,
1798 uint8* dst_u, uint8* dst_v, int pix) {
1799 asm volatile (
1800 "add %1, %0, %1 \n" // src_stride + src_raw
1801 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1802 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1803 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1804 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1805 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1806 "vmov.u16 q15, #0x8080 \n" // 128.5
1807 ".p2align 2 \n"
1808 "1: \n"
1809 "vld3.8 {d0, d2, d4}, [%0]! \n" // load 8 RAW pixels.
1810 "vld3.8 {d1, d3, d5}, [%0]! \n" // load next 8 RAW pixels.
1811 "vpaddl.u8 q2, q2 \n" // B 16 bytes -> 8 shorts.
1812 "vpaddl.u8 q1, q1 \n" // G 16 bytes -> 8 shorts.
1813 "vpaddl.u8 q0, q0 \n" // R 16 bytes -> 8 shorts.
1814 "vld3.8 {d8, d10, d12}, [%1]! \n" // load 8 more RAW pixels.
1815 "vld3.8 {d9, d11, d13}, [%1]! \n" // load last 8 RAW pixels.
1816 "vpadal.u8 q2, q6 \n" // B 16 bytes -> 8 shorts.
1817 "vpadal.u8 q1, q5 \n" // G 16 bytes -> 8 shorts.
1818 "vpadal.u8 q0, q4 \n" // R 16 bytes -> 8 shorts.
1819
1820 "vrshr.u16 q0, q0, #1 \n" // 2x average
1821 "vrshr.u16 q1, q1, #1 \n"
1822 "vrshr.u16 q2, q2, #1 \n"
1823
1824 "subs %4, %4, #16 \n" // 32 processed per loop.
1825 RGBTOUV(q2, q1, q0)
1826 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1827 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1828 "bgt 1b \n"
1829 : "+r"(src_raw), // %0
1830 "+r"(src_stride_raw), // %1
1831 "+r"(dst_u), // %2
1832 "+r"(dst_v), // %3
1833 "+r"(pix) // %4
1834 :
1835 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1836 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1837 );
1838 }
1839
1840 // 16x2 pixels -> 8x1. pix is number of argb pixels. e.g. 16.
1841 void RGB565ToUVRow_NEON(const uint8* src_rgb565, int src_stride_rgb565,
1842 uint8* dst_u, uint8* dst_v, int pix) {
1843 asm volatile (
1844 "add %1, %0, %1 \n" // src_stride + src_argb
1845 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1846 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1847 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1848 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1849 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1850 "vmov.u16 q15, #0x8080 \n" // 128.5
1851 ".p2align 2 \n"
1852 "1: \n"
1853 "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels.
1854 RGB565TOARGB
1855 "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1856 "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1857 "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1858 "vld1.8 {q0}, [%0]! \n" // next 8 RGB565 pixels.
1859 RGB565TOARGB
1860 "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
1861 "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
1862 "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
1863
1864 "vld1.8 {q0}, [%1]! \n" // load 8 RGB565 pixels.
1865 RGB565TOARGB
1866 "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1867 "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1868 "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1869 "vld1.8 {q0}, [%1]! \n" // next 8 RGB565 pixels.
1870 RGB565TOARGB
1871 "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
1872 "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
1873 "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
1874
1875 "vrshr.u16 q4, q4, #1 \n" // 2x average
1876 "vrshr.u16 q5, q5, #1 \n"
1877 "vrshr.u16 q6, q6, #1 \n"
1878
1879 "subs %4, %4, #16 \n" // 16 processed per loop.
1880 "vmul.s16 q8, q4, q10 \n" // B
1881 "vmls.s16 q8, q5, q11 \n" // G
1882 "vmls.s16 q8, q6, q12 \n" // R
1883 "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned
1884 "vmul.s16 q9, q6, q10 \n" // R
1885 "vmls.s16 q9, q5, q14 \n" // G
1886 "vmls.s16 q9, q4, q13 \n" // B
1887 "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned
1888 "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U
1889 "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V
1890 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1891 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1892 "bgt 1b \n"
1893 : "+r"(src_rgb565), // %0
1894 "+r"(src_stride_rgb565), // %1
1895 "+r"(dst_u), // %2
1896 "+r"(dst_v), // %3
1897 "+r"(pix) // %4
1898 :
1899 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1900 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1901 );
1902 }
1903
1904 // 16x2 pixels -> 8x1. pix is number of argb pixels. e.g. 16.
1905 void ARGB1555ToUVRow_NEON(const uint8* src_argb1555, int src_stride_argb1555,
1906 uint8* dst_u, uint8* dst_v, int pix) {
1907 asm volatile (
1908 "add %1, %0, %1 \n" // src_stride + src_argb
1909 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1910 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1911 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1912 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1913 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1914 "vmov.u16 q15, #0x8080 \n" // 128.5
1915 ".p2align 2 \n"
1916 "1: \n"
1917 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels.
1918 RGB555TOARGB
1919 "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1920 "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1921 "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1922 "vld1.8 {q0}, [%0]! \n" // next 8 ARGB1555 pixels.
1923 RGB555TOARGB
1924 "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
1925 "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
1926 "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
1927
1928 "vld1.8 {q0}, [%1]! \n" // load 8 ARGB1555 pixels.
1929 RGB555TOARGB
1930 "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1931 "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1932 "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1933 "vld1.8 {q0}, [%1]! \n" // next 8 ARGB1555 pixels.
1934 RGB555TOARGB
1935 "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
1936 "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
1937 "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
1938
1939 "vrshr.u16 q4, q4, #1 \n" // 2x average
1940 "vrshr.u16 q5, q5, #1 \n"
1941 "vrshr.u16 q6, q6, #1 \n"
1942
1943 "subs %4, %4, #16 \n" // 16 processed per loop.
1944 "vmul.s16 q8, q4, q10 \n" // B
1945 "vmls.s16 q8, q5, q11 \n" // G
1946 "vmls.s16 q8, q6, q12 \n" // R
1947 "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned
1948 "vmul.s16 q9, q6, q10 \n" // R
1949 "vmls.s16 q9, q5, q14 \n" // G
1950 "vmls.s16 q9, q4, q13 \n" // B
1951 "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned
1952 "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U
1953 "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V
1954 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
1955 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
1956 "bgt 1b \n"
1957 : "+r"(src_argb1555), // %0
1958 "+r"(src_stride_argb1555), // %1
1959 "+r"(dst_u), // %2
1960 "+r"(dst_v), // %3
1961 "+r"(pix) // %4
1962 :
1963 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1964 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
1965 );
1966 }
1967
1968 // 16x2 pixels -> 8x1. pix is number of argb pixels. e.g. 16.
1969 void ARGB4444ToUVRow_NEON(const uint8* src_argb4444, int src_stride_argb4444,
1970 uint8* dst_u, uint8* dst_v, int pix) {
1971 asm volatile (
1972 "add %1, %0, %1 \n" // src_stride + src_argb
1973 "vmov.s16 q10, #112 / 2 \n" // UB / VR 0.875 coefficient
1974 "vmov.s16 q11, #74 / 2 \n" // UG -0.5781 coefficient
1975 "vmov.s16 q12, #38 / 2 \n" // UR -0.2969 coefficient
1976 "vmov.s16 q13, #18 / 2 \n" // VB -0.1406 coefficient
1977 "vmov.s16 q14, #94 / 2 \n" // VG -0.7344 coefficient
1978 "vmov.u16 q15, #0x8080 \n" // 128.5
1979 ".p2align 2 \n"
1980 "1: \n"
1981 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels.
1982 ARGB4444TOARGB
1983 "vpaddl.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1984 "vpaddl.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1985 "vpaddl.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1986 "vld1.8 {q0}, [%0]! \n" // next 8 ARGB4444 pixels.
1987 ARGB4444TOARGB
1988 "vpaddl.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
1989 "vpaddl.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
1990 "vpaddl.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
1991
1992 "vld1.8 {q0}, [%1]! \n" // load 8 ARGB4444 pixels.
1993 ARGB4444TOARGB
1994 "vpadal.u8 d8, d0 \n" // B 8 bytes -> 4 shorts.
1995 "vpadal.u8 d10, d1 \n" // G 8 bytes -> 4 shorts.
1996 "vpadal.u8 d12, d2 \n" // R 8 bytes -> 4 shorts.
1997 "vld1.8 {q0}, [%1]! \n" // next 8 ARGB4444 pixels.
1998 ARGB4444TOARGB
1999 "vpadal.u8 d9, d0 \n" // B 8 bytes -> 4 shorts.
2000 "vpadal.u8 d11, d1 \n" // G 8 bytes -> 4 shorts.
2001 "vpadal.u8 d13, d2 \n" // R 8 bytes -> 4 shorts.
2002
2003 "vrshr.u16 q4, q4, #1 \n" // 2x average
2004 "vrshr.u16 q5, q5, #1 \n"
2005 "vrshr.u16 q6, q6, #1 \n"
2006
2007 "subs %4, %4, #16 \n" // 16 processed per loop.
2008 "vmul.s16 q8, q4, q10 \n" // B
2009 "vmls.s16 q8, q5, q11 \n" // G
2010 "vmls.s16 q8, q6, q12 \n" // R
2011 "vadd.u16 q8, q8, q15 \n" // +128 -> unsigned
2012 "vmul.s16 q9, q6, q10 \n" // R
2013 "vmls.s16 q9, q5, q14 \n" // G
2014 "vmls.s16 q9, q4, q13 \n" // B
2015 "vadd.u16 q9, q9, q15 \n" // +128 -> unsigned
2016 "vqshrn.u16 d0, q8, #8 \n" // 16 bit to 8 bit U
2017 "vqshrn.u16 d1, q9, #8 \n" // 16 bit to 8 bit V
2018 "vst1.8 {d0}, [%2]! \n" // store 8 pixels U.
2019 "vst1.8 {d1}, [%3]! \n" // store 8 pixels V.
2020 "bgt 1b \n"
2021 : "+r"(src_argb4444), // %0
2022 "+r"(src_stride_argb4444), // %1
2023 "+r"(dst_u), // %2
2024 "+r"(dst_v), // %3
2025 "+r"(pix) // %4
2026 :
2027 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2028 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
2029 );
2030 }
2031
2032 void RGB565ToYRow_NEON(const uint8* src_rgb565, uint8* dst_y, int pix) {
2033 asm volatile (
2034 "vmov.u8 d24, #13 \n" // B * 0.1016 coefficient
2035 "vmov.u8 d25, #65 \n" // G * 0.5078 coefficient
2036 "vmov.u8 d26, #33 \n" // R * 0.2578 coefficient
2037 "vmov.u8 d27, #16 \n" // Add 16 constant
2038 ".p2align 2 \n"
2039 "1: \n"
2040 "vld1.8 {q0}, [%0]! \n" // load 8 RGB565 pixels.
2041 "subs %2, %2, #8 \n" // 8 processed per loop.
2042 RGB565TOARGB
2043 "vmull.u8 q2, d0, d24 \n" // B
2044 "vmlal.u8 q2, d1, d25 \n" // G
2045 "vmlal.u8 q2, d2, d26 \n" // R
2046 "vqrshrun.s16 d0, q2, #7 \n" // 16 bit to 8 bit Y
2047 "vqadd.u8 d0, d27 \n"
2048 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2049 "bgt 1b \n"
2050 : "+r"(src_rgb565), // %0
2051 "+r"(dst_y), // %1
2052 "+r"(pix) // %2
2053 :
2054 : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13"
2055 );
2056 }
2057
2058 void ARGB1555ToYRow_NEON(const uint8* src_argb1555, uint8* dst_y, int pix) {
2059 asm volatile (
2060 "vmov.u8 d24, #13 \n" // B * 0.1016 coefficient
2061 "vmov.u8 d25, #65 \n" // G * 0.5078 coefficient
2062 "vmov.u8 d26, #33 \n" // R * 0.2578 coefficient
2063 "vmov.u8 d27, #16 \n" // Add 16 constant
2064 ".p2align 2 \n"
2065 "1: \n"
2066 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB1555 pixels.
2067 "subs %2, %2, #8 \n" // 8 processed per loop.
2068 ARGB1555TOARGB
2069 "vmull.u8 q2, d0, d24 \n" // B
2070 "vmlal.u8 q2, d1, d25 \n" // G
2071 "vmlal.u8 q2, d2, d26 \n" // R
2072 "vqrshrun.s16 d0, q2, #7 \n" // 16 bit to 8 bit Y
2073 "vqadd.u8 d0, d27 \n"
2074 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2075 "bgt 1b \n"
2076 : "+r"(src_argb1555), // %0
2077 "+r"(dst_y), // %1
2078 "+r"(pix) // %2
2079 :
2080 : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13"
2081 );
2082 }
2083
2084 void ARGB4444ToYRow_NEON(const uint8* src_argb4444, uint8* dst_y, int pix) {
2085 asm volatile (
2086 "vmov.u8 d24, #13 \n" // B * 0.1016 coefficient
2087 "vmov.u8 d25, #65 \n" // G * 0.5078 coefficient
2088 "vmov.u8 d26, #33 \n" // R * 0.2578 coefficient
2089 "vmov.u8 d27, #16 \n" // Add 16 constant
2090 ".p2align 2 \n"
2091 "1: \n"
2092 "vld1.8 {q0}, [%0]! \n" // load 8 ARGB4444 pixels.
2093 "subs %2, %2, #8 \n" // 8 processed per loop.
2094 ARGB4444TOARGB
2095 "vmull.u8 q2, d0, d24 \n" // B
2096 "vmlal.u8 q2, d1, d25 \n" // G
2097 "vmlal.u8 q2, d2, d26 \n" // R
2098 "vqrshrun.s16 d0, q2, #7 \n" // 16 bit to 8 bit Y
2099 "vqadd.u8 d0, d27 \n"
2100 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2101 "bgt 1b \n"
2102 : "+r"(src_argb4444), // %0
2103 "+r"(dst_y), // %1
2104 "+r"(pix) // %2
2105 :
2106 : "cc", "memory", "q0", "q1", "q2", "q3", "q12", "q13"
2107 );
2108 }
2109
2110 void BGRAToYRow_NEON(const uint8* src_bgra, uint8* dst_y, int pix) {
2111 asm volatile (
2112 "vmov.u8 d4, #33 \n" // R * 0.2578 coefficient
2113 "vmov.u8 d5, #65 \n" // G * 0.5078 coefficient
2114 "vmov.u8 d6, #13 \n" // B * 0.1016 coefficient
2115 "vmov.u8 d7, #16 \n" // Add 16 constant
2116 ".p2align 2 \n"
2117 "1: \n"
2118 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of BGRA.
2119 "subs %2, %2, #8 \n" // 8 processed per loop.
2120 "vmull.u8 q8, d1, d4 \n" // R
2121 "vmlal.u8 q8, d2, d5 \n" // G
2122 "vmlal.u8 q8, d3, d6 \n" // B
2123 "vqrshrun.s16 d0, q8, #7 \n" // 16 bit to 8 bit Y
2124 "vqadd.u8 d0, d7 \n"
2125 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2126 "bgt 1b \n"
2127 : "+r"(src_bgra), // %0
2128 "+r"(dst_y), // %1
2129 "+r"(pix) // %2
2130 :
2131 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "q8"
2132 );
2133 }
2134
2135 void ABGRToYRow_NEON(const uint8* src_abgr, uint8* dst_y, int pix) {
2136 asm volatile (
2137 "vmov.u8 d4, #33 \n" // R * 0.2578 coefficient
2138 "vmov.u8 d5, #65 \n" // G * 0.5078 coefficient
2139 "vmov.u8 d6, #13 \n" // B * 0.1016 coefficient
2140 "vmov.u8 d7, #16 \n" // Add 16 constant
2141 ".p2align 2 \n"
2142 "1: \n"
2143 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ABGR.
2144 "subs %2, %2, #8 \n" // 8 processed per loop.
2145 "vmull.u8 q8, d0, d4 \n" // R
2146 "vmlal.u8 q8, d1, d5 \n" // G
2147 "vmlal.u8 q8, d2, d6 \n" // B
2148 "vqrshrun.s16 d0, q8, #7 \n" // 16 bit to 8 bit Y
2149 "vqadd.u8 d0, d7 \n"
2150 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2151 "bgt 1b \n"
2152 : "+r"(src_abgr), // %0
2153 "+r"(dst_y), // %1
2154 "+r"(pix) // %2
2155 :
2156 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "q8"
2157 );
2158 }
2159
2160 void RGBAToYRow_NEON(const uint8* src_rgba, uint8* dst_y, int pix) {
2161 asm volatile (
2162 "vmov.u8 d4, #13 \n" // B * 0.1016 coefficient
2163 "vmov.u8 d5, #65 \n" // G * 0.5078 coefficient
2164 "vmov.u8 d6, #33 \n" // R * 0.2578 coefficient
2165 "vmov.u8 d7, #16 \n" // Add 16 constant
2166 ".p2align 2 \n"
2167 "1: \n"
2168 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of RGBA.
2169 "subs %2, %2, #8 \n" // 8 processed per loop.
2170 "vmull.u8 q8, d1, d4 \n" // B
2171 "vmlal.u8 q8, d2, d5 \n" // G
2172 "vmlal.u8 q8, d3, d6 \n" // R
2173 "vqrshrun.s16 d0, q8, #7 \n" // 16 bit to 8 bit Y
2174 "vqadd.u8 d0, d7 \n"
2175 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2176 "bgt 1b \n"
2177 : "+r"(src_rgba), // %0
2178 "+r"(dst_y), // %1
2179 "+r"(pix) // %2
2180 :
2181 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "q8"
2182 );
2183 }
2184
2185 void RGB24ToYRow_NEON(const uint8* src_rgb24, uint8* dst_y, int pix) {
2186 asm volatile (
2187 "vmov.u8 d4, #13 \n" // B * 0.1016 coefficient
2188 "vmov.u8 d5, #65 \n" // G * 0.5078 coefficient
2189 "vmov.u8 d6, #33 \n" // R * 0.2578 coefficient
2190 "vmov.u8 d7, #16 \n" // Add 16 constant
2191 ".p2align 2 \n"
2192 "1: \n"
2193 "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RGB24.
2194 "subs %2, %2, #8 \n" // 8 processed per loop.
2195 "vmull.u8 q8, d0, d4 \n" // B
2196 "vmlal.u8 q8, d1, d5 \n" // G
2197 "vmlal.u8 q8, d2, d6 \n" // R
2198 "vqrshrun.s16 d0, q8, #7 \n" // 16 bit to 8 bit Y
2199 "vqadd.u8 d0, d7 \n"
2200 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2201 "bgt 1b \n"
2202 : "+r"(src_rgb24), // %0
2203 "+r"(dst_y), // %1
2204 "+r"(pix) // %2
2205 :
2206 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "q8"
2207 );
2208 }
2209
2210 void RAWToYRow_NEON(const uint8* src_raw, uint8* dst_y, int pix) {
2211 asm volatile (
2212 "vmov.u8 d4, #33 \n" // R * 0.2578 coefficient
2213 "vmov.u8 d5, #65 \n" // G * 0.5078 coefficient
2214 "vmov.u8 d6, #13 \n" // B * 0.1016 coefficient
2215 "vmov.u8 d7, #16 \n" // Add 16 constant
2216 ".p2align 2 \n"
2217 "1: \n"
2218 "vld3.8 {d0, d1, d2}, [%0]! \n" // load 8 pixels of RAW.
2219 "subs %2, %2, #8 \n" // 8 processed per loop.
2220 "vmull.u8 q8, d0, d4 \n" // B
2221 "vmlal.u8 q8, d1, d5 \n" // G
2222 "vmlal.u8 q8, d2, d6 \n" // R
2223 "vqrshrun.s16 d0, q8, #7 \n" // 16 bit to 8 bit Y
2224 "vqadd.u8 d0, d7 \n"
2225 "vst1.8 {d0}, [%1]! \n" // store 8 pixels Y.
2226 "bgt 1b \n"
2227 : "+r"(src_raw), // %0
2228 "+r"(dst_y), // %1
2229 "+r"(pix) // %2
2230 :
2231 : "cc", "memory", "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "q8"
2232 );
2233 }
2234
2235 // Bilinear filter 16x2 -> 16x1
2236 void InterpolateRow_NEON(uint8* dst_ptr,
2237 const uint8* src_ptr, ptrdiff_t src_stride,
2238 int dst_width, int source_y_fraction) {
2239 asm volatile (
2240 "cmp %4, #0 \n"
2241 "beq 100f \n"
2242 "add %2, %1 \n"
2243 "cmp %4, #64 \n"
2244 "beq 75f \n"
2245 "cmp %4, #128 \n"
2246 "beq 50f \n"
2247 "cmp %4, #192 \n"
2248 "beq 25f \n"
2249
2250 "vdup.8 d5, %4 \n"
2251 "rsb %4, #256 \n"
2252 "vdup.8 d4, %4 \n"
2253 // General purpose row blend.
2254 "1: \n"
2255 "vld1.8 {q0}, [%1]! \n"
2256 "vld1.8 {q1}, [%2]! \n"
2257 "subs %3, %3, #16 \n"
2258 "vmull.u8 q13, d0, d4 \n"
2259 "vmull.u8 q14, d1, d4 \n"
2260 "vmlal.u8 q13, d2, d5 \n"
2261 "vmlal.u8 q14, d3, d5 \n"
2262 "vrshrn.u16 d0, q13, #8 \n"
2263 "vrshrn.u16 d1, q14, #8 \n"
2264 "vst1.8 {q0}, [%0]! \n"
2265 "bgt 1b \n"
2266 "b 99f \n"
2267
2268 // Blend 25 / 75.
2269 "25: \n"
2270 "vld1.8 {q0}, [%1]! \n"
2271 "vld1.8 {q1}, [%2]! \n"
2272 "subs %3, %3, #16 \n"
2273 "vrhadd.u8 q0, q1 \n"
2274 "vrhadd.u8 q0, q1 \n"
2275 "vst1.8 {q0}, [%0]! \n"
2276 "bgt 25b \n"
2277 "b 99f \n"
2278
2279 // Blend 50 / 50.
2280 "50: \n"
2281 "vld1.8 {q0}, [%1]! \n"
2282 "vld1.8 {q1}, [%2]! \n"
2283 "subs %3, %3, #16 \n"
2284 "vrhadd.u8 q0, q1 \n"
2285 "vst1.8 {q0}, [%0]! \n"
2286 "bgt 50b \n"
2287 "b 99f \n"
2288
2289 // Blend 75 / 25.
2290 "75: \n"
2291 "vld1.8 {q1}, [%1]! \n"
2292 "vld1.8 {q0}, [%2]! \n"
2293 "subs %3, %3, #16 \n"
2294 "vrhadd.u8 q0, q1 \n"
2295 "vrhadd.u8 q0, q1 \n"
2296 "vst1.8 {q0}, [%0]! \n"
2297 "bgt 75b \n"
2298 "b 99f \n"
2299
2300 // Blend 100 / 0 - Copy row unchanged.
2301 "100: \n"
2302 "vld1.8 {q0}, [%1]! \n"
2303 "subs %3, %3, #16 \n"
2304 "vst1.8 {q0}, [%0]! \n"
2305 "bgt 100b \n"
2306
2307 "99: \n"
2308 : "+r"(dst_ptr), // %0
2309 "+r"(src_ptr), // %1
2310 "+r"(src_stride), // %2
2311 "+r"(dst_width), // %3
2312 "+r"(source_y_fraction) // %4
2313 :
2314 : "cc", "memory", "q0", "q1", "d4", "d5", "q13", "q14"
2315 );
2316 }
2317
2318 // dr * (256 - sa) / 256 + sr = dr - dr * sa / 256 + sr
2319 void ARGBBlendRow_NEON(const uint8* src_argb0, const uint8* src_argb1,
2320 uint8* dst_argb, int width) {
2321 asm volatile (
2322 "subs %3, #8 \n"
2323 "blt 89f \n"
2324 // Blend 8 pixels.
2325 "8: \n"
2326 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ARGB0.
2327 "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 pixels of ARGB1.
2328 "subs %3, %3, #8 \n" // 8 processed per loop.
2329 "vmull.u8 q10, d4, d3 \n" // db * a
2330 "vmull.u8 q11, d5, d3 \n" // dg * a
2331 "vmull.u8 q12, d6, d3 \n" // dr * a
2332 "vqrshrn.u16 d20, q10, #8 \n" // db >>= 8
2333 "vqrshrn.u16 d21, q11, #8 \n" // dg >>= 8
2334 "vqrshrn.u16 d22, q12, #8 \n" // dr >>= 8
2335 "vqsub.u8 q2, q2, q10 \n" // dbg - dbg * a / 256
2336 "vqsub.u8 d6, d6, d22 \n" // dr - dr * a / 256
2337 "vqadd.u8 q0, q0, q2 \n" // + sbg
2338 "vqadd.u8 d2, d2, d6 \n" // + sr
2339 "vmov.u8 d3, #255 \n" // a = 255
2340 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 pixels of ARGB.
2341 "bge 8b \n"
2342
2343 "89: \n"
2344 "adds %3, #8-1 \n"
2345 "blt 99f \n"
2346
2347 // Blend 1 pixels.
2348 "1: \n"
2349 "vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [%0]! \n" // load 1 pixel ARGB0.
2350 "vld4.8 {d4[0],d5[0],d6[0],d7[0]}, [%1]! \n" // load 1 pixel ARGB1.
2351 "subs %3, %3, #1 \n" // 1 processed per loop.
2352 "vmull.u8 q10, d4, d3 \n" // db * a
2353 "vmull.u8 q11, d5, d3 \n" // dg * a
2354 "vmull.u8 q12, d6, d3 \n" // dr * a
2355 "vqrshrn.u16 d20, q10, #8 \n" // db >>= 8
2356 "vqrshrn.u16 d21, q11, #8 \n" // dg >>= 8
2357 "vqrshrn.u16 d22, q12, #8 \n" // dr >>= 8
2358 "vqsub.u8 q2, q2, q10 \n" // dbg - dbg * a / 256
2359 "vqsub.u8 d6, d6, d22 \n" // dr - dr * a / 256
2360 "vqadd.u8 q0, q0, q2 \n" // + sbg
2361 "vqadd.u8 d2, d2, d6 \n" // + sr
2362 "vmov.u8 d3, #255 \n" // a = 255
2363 "vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [%2]! \n" // store 1 pixel.
2364 "bge 1b \n"
2365
2366 "99: \n"
2367
2368 : "+r"(src_argb0), // %0
2369 "+r"(src_argb1), // %1
2370 "+r"(dst_argb), // %2
2371 "+r"(width) // %3
2372 :
2373 : "cc", "memory", "q0", "q1", "q2", "q3", "q10", "q11", "q12"
2374 );
2375 }
2376
2377 // Attenuate 8 pixels at a time.
2378 void ARGBAttenuateRow_NEON(const uint8* src_argb, uint8* dst_argb, int width) {
2379 asm volatile (
2380 // Attenuate 8 pixels.
2381 "1: \n"
2382 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 pixels of ARGB.
2383 "subs %2, %2, #8 \n" // 8 processed per loop.
2384 "vmull.u8 q10, d0, d3 \n" // b * a
2385 "vmull.u8 q11, d1, d3 \n" // g * a
2386 "vmull.u8 q12, d2, d3 \n" // r * a
2387 "vqrshrn.u16 d0, q10, #8 \n" // b >>= 8
2388 "vqrshrn.u16 d1, q11, #8 \n" // g >>= 8
2389 "vqrshrn.u16 d2, q12, #8 \n" // r >>= 8
2390 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 pixels of ARGB.
2391 "bgt 1b \n"
2392 : "+r"(src_argb), // %0
2393 "+r"(dst_argb), // %1
2394 "+r"(width) // %2
2395 :
2396 : "cc", "memory", "q0", "q1", "q10", "q11", "q12"
2397 );
2398 }
2399
2400 // Quantize 8 ARGB pixels (32 bytes).
2401 // dst = (dst * scale >> 16) * interval_size + interval_offset;
2402 void ARGBQuantizeRow_NEON(uint8* dst_argb, int scale, int interval_size,
2403 int interval_offset, int width) {
2404 asm volatile (
2405 "vdup.u16 q8, %2 \n"
2406 "vshr.u16 q8, q8, #1 \n" // scale >>= 1
2407 "vdup.u16 q9, %3 \n" // interval multiply.
2408 "vdup.u16 q10, %4 \n" // interval add
2409
2410 // 8 pixel loop.
2411 ".p2align 2 \n"
2412 "1: \n"
2413 "vld4.8 {d0, d2, d4, d6}, [%0] \n" // load 8 pixels of ARGB.
2414 "subs %1, %1, #8 \n" // 8 processed per loop.
2415 "vmovl.u8 q0, d0 \n" // b (0 .. 255)
2416 "vmovl.u8 q1, d2 \n"
2417 "vmovl.u8 q2, d4 \n"
2418 "vqdmulh.s16 q0, q0, q8 \n" // b * scale
2419 "vqdmulh.s16 q1, q1, q8 \n" // g
2420 "vqdmulh.s16 q2, q2, q8 \n" // r
2421 "vmul.u16 q0, q0, q9 \n" // b * interval_size
2422 "vmul.u16 q1, q1, q9 \n" // g
2423 "vmul.u16 q2, q2, q9 \n" // r
2424 "vadd.u16 q0, q0, q10 \n" // b + interval_offset
2425 "vadd.u16 q1, q1, q10 \n" // g
2426 "vadd.u16 q2, q2, q10 \n" // r
2427 "vqmovn.u16 d0, q0 \n"
2428 "vqmovn.u16 d2, q1 \n"
2429 "vqmovn.u16 d4, q2 \n"
2430 "vst4.8 {d0, d2, d4, d6}, [%0]! \n" // store 8 pixels of ARGB.
2431 "bgt 1b \n"
2432 : "+r"(dst_argb), // %0
2433 "+r"(width) // %1
2434 : "r"(scale), // %2
2435 "r"(interval_size), // %3
2436 "r"(interval_offset) // %4
2437 : "cc", "memory", "q0", "q1", "q2", "q3", "q8", "q9", "q10"
2438 );
2439 }
2440
2441 // Shade 8 pixels at a time by specified value.
2442 // NOTE vqrdmulh.s16 q10, q10, d0[0] must use a scaler register from 0 to 8.
2443 // Rounding in vqrdmulh does +1 to high if high bit of low s16 is set.
2444 void ARGBShadeRow_NEON(const uint8* src_argb, uint8* dst_argb, int width,
2445 uint32 value) {
2446 asm volatile (
2447 "vdup.u32 q0, %3 \n" // duplicate scale value.
2448 "vzip.u8 d0, d1 \n" // d0 aarrggbb.
2449 "vshr.u16 q0, q0, #1 \n" // scale / 2.
2450
2451 // 8 pixel loop.
2452 ".p2align 2 \n"
2453 "1: \n"
2454 "vld4.8 {d20, d22, d24, d26}, [%0]! \n" // load 8 pixels of ARGB.
2455 "subs %2, %2, #8 \n" // 8 processed per loop.
2456 "vmovl.u8 q10, d20 \n" // b (0 .. 255)
2457 "vmovl.u8 q11, d22 \n"
2458 "vmovl.u8 q12, d24 \n"
2459 "vmovl.u8 q13, d26 \n"
2460 "vqrdmulh.s16 q10, q10, d0[0] \n" // b * scale * 2
2461 "vqrdmulh.s16 q11, q11, d0[1] \n" // g
2462 "vqrdmulh.s16 q12, q12, d0[2] \n" // r
2463 "vqrdmulh.s16 q13, q13, d0[3] \n" // a
2464 "vqmovn.u16 d20, q10 \n"
2465 "vqmovn.u16 d22, q11 \n"
2466 "vqmovn.u16 d24, q12 \n"
2467 "vqmovn.u16 d26, q13 \n"
2468 "vst4.8 {d20, d22, d24, d26}, [%1]! \n" // store 8 pixels of ARGB.
2469 "bgt 1b \n"
2470 : "+r"(src_argb), // %0
2471 "+r"(dst_argb), // %1
2472 "+r"(width) // %2
2473 : "r"(value) // %3
2474 : "cc", "memory", "q0", "q10", "q11", "q12", "q13"
2475 );
2476 }
2477
2478 // Convert 8 ARGB pixels (64 bytes) to 8 Gray ARGB pixels
2479 // Similar to ARGBToYJ but stores ARGB.
2480 // C code is (15 * b + 75 * g + 38 * r + 64) >> 7;
2481 void ARGBGrayRow_NEON(const uint8* src_argb, uint8* dst_argb, int width) {
2482 asm volatile (
2483 "vmov.u8 d24, #15 \n" // B * 0.11400 coefficient
2484 "vmov.u8 d25, #75 \n" // G * 0.58700 coefficient
2485 "vmov.u8 d26, #38 \n" // R * 0.29900 coefficient
2486 ".p2align 2 \n"
2487 "1: \n"
2488 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
2489 "subs %2, %2, #8 \n" // 8 processed per loop.
2490 "vmull.u8 q2, d0, d24 \n" // B
2491 "vmlal.u8 q2, d1, d25 \n" // G
2492 "vmlal.u8 q2, d2, d26 \n" // R
2493 "vqrshrun.s16 d0, q2, #7 \n" // 15 bit to 8 bit B
2494 "vmov d1, d0 \n" // G
2495 "vmov d2, d0 \n" // R
2496 "vst4.8 {d0, d1, d2, d3}, [%1]! \n" // store 8 ARGB pixels.
2497 "bgt 1b \n"
2498 : "+r"(src_argb), // %0
2499 "+r"(dst_argb), // %1
2500 "+r"(width) // %2
2501 :
2502 : "cc", "memory", "q0", "q1", "q2", "q12", "q13"
2503 );
2504 }
2505
2506 // Convert 8 ARGB pixels (32 bytes) to 8 Sepia ARGB pixels.
2507 // b = (r * 35 + g * 68 + b * 17) >> 7
2508 // g = (r * 45 + g * 88 + b * 22) >> 7
2509 // r = (r * 50 + g * 98 + b * 24) >> 7
2510 void ARGBSepiaRow_NEON(uint8* dst_argb, int width) {
2511 asm volatile (
2512 "vmov.u8 d20, #17 \n" // BB coefficient
2513 "vmov.u8 d21, #68 \n" // BG coefficient
2514 "vmov.u8 d22, #35 \n" // BR coefficient
2515 "vmov.u8 d24, #22 \n" // GB coefficient
2516 "vmov.u8 d25, #88 \n" // GG coefficient
2517 "vmov.u8 d26, #45 \n" // GR coefficient
2518 "vmov.u8 d28, #24 \n" // BB coefficient
2519 "vmov.u8 d29, #98 \n" // BG coefficient
2520 "vmov.u8 d30, #50 \n" // BR coefficient
2521 ".p2align 2 \n"
2522 "1: \n"
2523 "vld4.8 {d0, d1, d2, d3}, [%0] \n" // load 8 ARGB pixels.
2524 "subs %1, %1, #8 \n" // 8 processed per loop.
2525 "vmull.u8 q2, d0, d20 \n" // B to Sepia B
2526 "vmlal.u8 q2, d1, d21 \n" // G
2527 "vmlal.u8 q2, d2, d22 \n" // R
2528 "vmull.u8 q3, d0, d24 \n" // B to Sepia G
2529 "vmlal.u8 q3, d1, d25 \n" // G
2530 "vmlal.u8 q3, d2, d26 \n" // R
2531 "vmull.u8 q8, d0, d28 \n" // B to Sepia R
2532 "vmlal.u8 q8, d1, d29 \n" // G
2533 "vmlal.u8 q8, d2, d30 \n" // R
2534 "vqshrn.u16 d0, q2, #7 \n" // 16 bit to 8 bit B
2535 "vqshrn.u16 d1, q3, #7 \n" // 16 bit to 8 bit G
2536 "vqshrn.u16 d2, q8, #7 \n" // 16 bit to 8 bit R
2537 "vst4.8 {d0, d1, d2, d3}, [%0]! \n" // store 8 ARGB pixels.
2538 "bgt 1b \n"
2539 : "+r"(dst_argb), // %0
2540 "+r"(width) // %1
2541 :
2542 : "cc", "memory", "q0", "q1", "q2", "q3",
2543 "q10", "q11", "q12", "q13", "q14", "q15"
2544 );
2545 }
2546
2547 // Tranform 8 ARGB pixels (32 bytes) with color matrix.
2548 // TODO(fbarchard): Was same as Sepia except matrix is provided. This function
2549 // needs to saturate. Consider doing a non-saturating version.
2550 void ARGBColorMatrixRow_NEON(const uint8* src_argb, uint8* dst_argb,
2551 const int8* matrix_argb, int width) {
2552 asm volatile (
2553 "vld1.8 {q2}, [%3] \n" // load 3 ARGB vectors.
2554 "vmovl.s8 q0, d4 \n" // B,G coefficients s16.
2555 "vmovl.s8 q1, d5 \n" // R,A coefficients s16.
2556
2557 ".p2align 2 \n"
2558 "1: \n"
2559 "vld4.8 {d16, d18, d20, d22}, [%0]! \n" // load 8 ARGB pixels.
2560 "subs %2, %2, #8 \n" // 8 processed per loop.
2561 "vmovl.u8 q8, d16 \n" // b (0 .. 255) 16 bit
2562 "vmovl.u8 q9, d18 \n" // g
2563 "vmovl.u8 q10, d20 \n" // r
2564 "vmovl.u8 q15, d22 \n" // a
2565 "vmul.s16 q12, q8, d0[0] \n" // B = B * Matrix B
2566 "vmul.s16 q13, q8, d1[0] \n" // G = B * Matrix G
2567 "vmul.s16 q14, q8, d2[0] \n" // R = B * Matrix R
2568 "vmul.s16 q15, q8, d3[0] \n" // A = B * Matrix A
2569 "vmul.s16 q4, q9, d0[1] \n" // B += G * Matrix B
2570 "vmul.s16 q5, q9, d1[1] \n" // G += G * Matrix G
2571 "vmul.s16 q6, q9, d2[1] \n" // R += G * Matrix R
2572 "vmul.s16 q7, q9, d3[1] \n" // A += G * Matrix A
2573 "vqadd.s16 q12, q12, q4 \n" // Accumulate B
2574 "vqadd.s16 q13, q13, q5 \n" // Accumulate G
2575 "vqadd.s16 q14, q14, q6 \n" // Accumulate R
2576 "vqadd.s16 q15, q15, q7 \n" // Accumulate A
2577 "vmul.s16 q4, q10, d0[2] \n" // B += R * Matrix B
2578 "vmul.s16 q5, q10, d1[2] \n" // G += R * Matrix G
2579 "vmul.s16 q6, q10, d2[2] \n" // R += R * Matrix R
2580 "vmul.s16 q7, q10, d3[2] \n" // A += R * Matrix A
2581 "vqadd.s16 q12, q12, q4 \n" // Accumulate B
2582 "vqadd.s16 q13, q13, q5 \n" // Accumulate G
2583 "vqadd.s16 q14, q14, q6 \n" // Accumulate R
2584 "vqadd.s16 q15, q15, q7 \n" // Accumulate A
2585 "vmul.s16 q4, q15, d0[3] \n" // B += A * Matrix B
2586 "vmul.s16 q5, q15, d1[3] \n" // G += A * Matrix G
2587 "vmul.s16 q6, q15, d2[3] \n" // R += A * Matrix R
2588 "vmul.s16 q7, q15, d3[3] \n" // A += A * Matrix A
2589 "vqadd.s16 q12, q12, q4 \n" // Accumulate B
2590 "vqadd.s16 q13, q13, q5 \n" // Accumulate G
2591 "vqadd.s16 q14, q14, q6 \n" // Accumulate R
2592 "vqadd.s16 q15, q15, q7 \n" // Accumulate A
2593 "vqshrun.s16 d16, q12, #6 \n" // 16 bit to 8 bit B
2594 "vqshrun.s16 d18, q13, #6 \n" // 16 bit to 8 bit G
2595 "vqshrun.s16 d20, q14, #6 \n" // 16 bit to 8 bit R
2596 "vqshrun.s16 d22, q15, #6 \n" // 16 bit to 8 bit A
2597 "vst4.8 {d16, d18, d20, d22}, [%1]! \n" // store 8 ARGB pixels.
2598 "bgt 1b \n"
2599 : "+r"(src_argb), // %0
2600 "+r"(dst_argb), // %1
2601 "+r"(width) // %2
2602 : "r"(matrix_argb) // %3
2603 : "cc", "memory", "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7", "q8", "q9",
2604 "q10", "q11", "q12", "q13", "q14", "q15"
2605 );
2606 }
2607
2608 // TODO(fbarchard): fix vqshrun in ARGBMultiplyRow_NEON and reenable.
2609 #ifdef HAS_ARGBMULTIPLYROW_NEON
2610 // Multiply 2 rows of ARGB pixels together, 8 pixels at a time.
2611 void ARGBMultiplyRow_NEON(const uint8* src_argb0, const uint8* src_argb1,
2612 uint8* dst_argb, int width) {
2613 asm volatile (
2614 // 8 pixel loop.
2615 ".p2align 2 \n"
2616 "1: \n"
2617 "vld4.8 {d0, d2, d4, d6}, [%0]! \n" // load 8 ARGB pixels.
2618 "vld4.8 {d1, d3, d5, d7}, [%1]! \n" // load 8 more ARGB pixels.
2619 "subs %3, %3, #8 \n" // 8 processed per loop.
2620 "vmull.u8 q0, d0, d1 \n" // multiply B
2621 "vmull.u8 q1, d2, d3 \n" // multiply G
2622 "vmull.u8 q2, d4, d5 \n" // multiply R
2623 "vmull.u8 q3, d6, d7 \n" // multiply A
2624 "vrshrn.u16 d0, q0, #8 \n" // 16 bit to 8 bit B
2625 "vrshrn.u16 d1, q1, #8 \n" // 16 bit to 8 bit G
2626 "vrshrn.u16 d2, q2, #8 \n" // 16 bit to 8 bit R
2627 "vrshrn.u16 d3, q3, #8 \n" // 16 bit to 8 bit A
2628 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels.
2629 "bgt 1b \n"
2630
2631 : "+r"(src_argb0), // %0
2632 "+r"(src_argb1), // %1
2633 "+r"(dst_argb), // %2
2634 "+r"(width) // %3
2635 :
2636 : "cc", "memory", "q0", "q1", "q2", "q3"
2637 );
2638 }
2639 #endif // HAS_ARGBMULTIPLYROW_NEON
2640
2641 // Add 2 rows of ARGB pixels together, 8 pixels at a time.
2642 void ARGBAddRow_NEON(const uint8* src_argb0, const uint8* src_argb1,
2643 uint8* dst_argb, int width) {
2644 asm volatile (
2645 // 8 pixel loop.
2646 ".p2align 2 \n"
2647 "1: \n"
2648 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
2649 "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 more ARGB pixels.
2650 "subs %3, %3, #8 \n" // 8 processed per loop.
2651 "vqadd.u8 q0, q0, q2 \n" // add B, G
2652 "vqadd.u8 q1, q1, q3 \n" // add R, A
2653 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels.
2654 "bgt 1b \n"
2655
2656 : "+r"(src_argb0), // %0
2657 "+r"(src_argb1), // %1
2658 "+r"(dst_argb), // %2
2659 "+r"(width) // %3
2660 :
2661 : "cc", "memory", "q0", "q1", "q2", "q3"
2662 );
2663 }
2664
2665 // Subtract 2 rows of ARGB pixels, 8 pixels at a time.
2666 void ARGBSubtractRow_NEON(const uint8* src_argb0, const uint8* src_argb1,
2667 uint8* dst_argb, int width) {
2668 asm volatile (
2669 // 8 pixel loop.
2670 ".p2align 2 \n"
2671 "1: \n"
2672 "vld4.8 {d0, d1, d2, d3}, [%0]! \n" // load 8 ARGB pixels.
2673 "vld4.8 {d4, d5, d6, d7}, [%1]! \n" // load 8 more ARGB pixels.
2674 "subs %3, %3, #8 \n" // 8 processed per loop.
2675 "vqsub.u8 q0, q0, q2 \n" // subtract B, G
2676 "vqsub.u8 q1, q1, q3 \n" // subtract R, A
2677 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels.
2678 "bgt 1b \n"
2679
2680 : "+r"(src_argb0), // %0
2681 "+r"(src_argb1), // %1
2682 "+r"(dst_argb), // %2
2683 "+r"(width) // %3
2684 :
2685 : "cc", "memory", "q0", "q1", "q2", "q3"
2686 );
2687 }
2688
2689 // Adds Sobel X and Sobel Y and stores Sobel into ARGB.
2690 // A = 255
2691 // R = Sobel
2692 // G = Sobel
2693 // B = Sobel
2694 void SobelRow_NEON(const uint8* src_sobelx, const uint8* src_sobely,
2695 uint8* dst_argb, int width) {
2696 asm volatile (
2697 "vmov.u8 d3, #255 \n" // alpha
2698 // 8 pixel loop.
2699 ".p2align 2 \n"
2700 "1: \n"
2701 "vld1.8 {d0}, [%0]! \n" // load 8 sobelx.
2702 "vld1.8 {d1}, [%1]! \n" // load 8 sobely.
2703 "subs %3, %3, #8 \n" // 8 processed per loop.
2704 "vqadd.u8 d0, d0, d1 \n" // add
2705 "vmov.u8 d1, d0 \n"
2706 "vmov.u8 d2, d0 \n"
2707 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels.
2708 "bgt 1b \n"
2709 : "+r"(src_sobelx), // %0
2710 "+r"(src_sobely), // %1
2711 "+r"(dst_argb), // %2
2712 "+r"(width) // %3
2713 :
2714 : "cc", "memory", "q0", "q1"
2715 );
2716 }
2717
2718 // Adds Sobel X and Sobel Y and stores Sobel into plane.
2719 void SobelToPlaneRow_NEON(const uint8* src_sobelx, const uint8* src_sobely,
2720 uint8* dst_y, int width) {
2721 asm volatile (
2722 // 16 pixel loop.
2723 ".p2align 2 \n"
2724 "1: \n"
2725 "vld1.8 {q0}, [%0]! \n" // load 16 sobelx.
2726 "vld1.8 {q1}, [%1]! \n" // load 16 sobely.
2727 "subs %3, %3, #16 \n" // 16 processed per loop.
2728 "vqadd.u8 q0, q0, q1 \n" // add
2729 "vst1.8 {q0}, [%2]! \n" // store 16 pixels.
2730 "bgt 1b \n"
2731 : "+r"(src_sobelx), // %0
2732 "+r"(src_sobely), // %1
2733 "+r"(dst_y), // %2
2734 "+r"(width) // %3
2735 :
2736 : "cc", "memory", "q0", "q1"
2737 );
2738 }
2739
2740 // Mixes Sobel X, Sobel Y and Sobel into ARGB.
2741 // A = 255
2742 // R = Sobel X
2743 // G = Sobel
2744 // B = Sobel Y
2745 void SobelXYRow_NEON(const uint8* src_sobelx, const uint8* src_sobely,
2746 uint8* dst_argb, int width) {
2747 asm volatile (
2748 "vmov.u8 d3, #255 \n" // alpha
2749 // 8 pixel loop.
2750 ".p2align 2 \n"
2751 "1: \n"
2752 "vld1.8 {d2}, [%0]! \n" // load 8 sobelx.
2753 "vld1.8 {d0}, [%1]! \n" // load 8 sobely.
2754 "subs %3, %3, #8 \n" // 8 processed per loop.
2755 "vqadd.u8 d1, d0, d2 \n" // add
2756 "vst4.8 {d0, d1, d2, d3}, [%2]! \n" // store 8 ARGB pixels.
2757 "bgt 1b \n"
2758 : "+r"(src_sobelx), // %0
2759 "+r"(src_sobely), // %1
2760 "+r"(dst_argb), // %2
2761 "+r"(width) // %3
2762 :
2763 : "cc", "memory", "q0", "q1"
2764 );
2765 }
2766
2767 // SobelX as a matrix is
2768 // -1 0 1
2769 // -2 0 2
2770 // -1 0 1
2771 void SobelXRow_NEON(const uint8* src_y0, const uint8* src_y1,
2772 const uint8* src_y2, uint8* dst_sobelx, int width) {
2773 asm volatile (
2774 ".p2align 2 \n"
2775 "1: \n"
2776 "vld1.8 {d0}, [%0],%5 \n" // top
2777 "vld1.8 {d1}, [%0],%6 \n"
2778 "vsubl.u8 q0, d0, d1 \n"
2779 "vld1.8 {d2}, [%1],%5 \n" // center * 2
2780 "vld1.8 {d3}, [%1],%6 \n"
2781 "vsubl.u8 q1, d2, d3 \n"
2782 "vadd.s16 q0, q0, q1 \n"
2783 "vadd.s16 q0, q0, q1 \n"
2784 "vld1.8 {d2}, [%2],%5 \n" // bottom
2785 "vld1.8 {d3}, [%2],%6 \n"
2786 "subs %4, %4, #8 \n" // 8 pixels
2787 "vsubl.u8 q1, d2, d3 \n"
2788 "vadd.s16 q0, q0, q1 \n"
2789 "vabs.s16 q0, q0 \n"
2790 "vqmovn.u16 d0, q0 \n"
2791 "vst1.8 {d0}, [%3]! \n" // store 8 sobelx
2792 "bgt 1b \n"
2793 : "+r"(src_y0), // %0
2794 "+r"(src_y1), // %1
2795 "+r"(src_y2), // %2
2796 "+r"(dst_sobelx), // %3
2797 "+r"(width) // %4
2798 : "r"(2), // %5
2799 "r"(6) // %6
2800 : "cc", "memory", "q0", "q1" // Clobber List
2801 );
2802 }
2803
2804 // SobelY as a matrix is
2805 // -1 -2 -1
2806 // 0 0 0
2807 // 1 2 1
2808 void SobelYRow_NEON(const uint8* src_y0, const uint8* src_y1,
2809 uint8* dst_sobely, int width) {
2810 asm volatile (
2811 ".p2align 2 \n"
2812 "1: \n"
2813 "vld1.8 {d0}, [%0],%4 \n" // left
2814 "vld1.8 {d1}, [%1],%4 \n"
2815 "vsubl.u8 q0, d0, d1 \n"
2816 "vld1.8 {d2}, [%0],%4 \n" // center * 2
2817 "vld1.8 {d3}, [%1],%4 \n"
2818 "vsubl.u8 q1, d2, d3 \n"
2819 "vadd.s16 q0, q0, q1 \n"
2820 "vadd.s16 q0, q0, q1 \n"
2821 "vld1.8 {d2}, [%0],%5 \n" // right
2822 "vld1.8 {d3}, [%1],%5 \n"
2823 "subs %3, %3, #8 \n" // 8 pixels
2824 "vsubl.u8 q1, d2, d3 \n"
2825 "vadd.s16 q0, q0, q1 \n"
2826 "vabs.s16 q0, q0 \n"
2827 "vqmovn.u16 d0, q0 \n"
2828 "vst1.8 {d0}, [%2]! \n" // store 8 sobely
2829 "bgt 1b \n"
2830 : "+r"(src_y0), // %0
2831 "+r"(src_y1), // %1
2832 "+r"(dst_sobely), // %2
2833 "+r"(width) // %3
2834 : "r"(1), // %4
2835 "r"(6) // %5
2836 : "cc", "memory", "q0", "q1" // Clobber List
2837 );
2838 }
2839 #endif // __ARM_NEON__
2840
2841 #ifdef __cplusplus
2842 } // extern "C"
2843 } // namespace libyuv
2844 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial