The Tor Browser / file comparison

comparison: gfx/cairo/libpixman/src/pixman-arm-neon-asm-bilinear.S

gfx/cairo/libpixman/src/pixman-arm-neon-asm-bilinear.S

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:45cdd2fc7dd6
1 /*
2 * Copyright © 2011 SCore Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 * Author: Siarhei Siamashka (siarhei.siamashka@nokia.com)
24 * Author: Taekyun Kim (tkq.kim@samsung.com)
25 */
26
27 /*
28 * This file contains scaled bilinear scanline functions implemented
29 * using older siarhei's bilinear macro template.
30 *
31 * << General scanline function procedures >>
32 * 1. bilinear interpolate source pixels
33 * 2. load mask pixels
34 * 3. load destination pixels
35 * 4. duplicate mask to fill whole register
36 * 5. interleave source & destination pixels
37 * 6. apply mask to source pixels
38 * 7. combine source & destination pixels
39 * 8, Deinterleave final result
40 * 9. store destination pixels
41 *
42 * All registers with single number (i.e. src0, tmp0) are 64-bits registers.
43 * Registers with double numbers(src01, dst01) are 128-bits registers.
44 * All temp registers can be used freely outside the code block.
45 * Assume that symbol(register .req) OUT and MASK are defined at caller of these macro blocks.
46 *
47 * Remarks
48 * There can be lots of pipeline stalls inside code block and between code blocks.
49 * Further optimizations will be done by new macro templates using head/tail_head/tail scheme.
50 */
51
52 /* Prevent the stack from becoming executable for no reason... */
53 #if defined(__linux__) && defined (__ELF__)
54 .section .note.GNU-stack,"",%progbits
55 #endif
56
57 .text
58 .fpu neon
59 .arch armv7a
60 .object_arch armv4
61 .eabi_attribute 10, 0
62 .eabi_attribute 12, 0
63 .arm
64 .altmacro
65 .p2align 2
66
67 #include "pixman-private.h"
68 #include "pixman-arm-neon-asm.h"
69
70 /*
71 * Bilinear macros from pixman-arm-neon-asm.S
72 */
73
74 /* Supplementary macro for setting function attributes */
75 .macro pixman_asm_function fname
76 .func fname
77 .global fname
78 #ifdef __ELF__
79 .hidden fname
80 .type fname, %function
81 #endif
82 fname:
83 .endm
84
85 /*
86 * Bilinear scaling support code which tries to provide pixel fetching, color
87 * format conversion, and interpolation as separate macros which can be used
88 * as the basic building blocks for constructing bilinear scanline functions.
89 */
90
91 .macro bilinear_load_8888 reg1, reg2, tmp
92 mov TMP1, X, asr #16
93 add X, X, UX
94 add TMP1, TOP, TMP1, asl #2
95 vld1.32 {reg1}, [TMP1], STRIDE
96 vld1.32 {reg2}, [TMP1]
97 .endm
98
99 .macro bilinear_load_0565 reg1, reg2, tmp
100 mov TMP1, X, asr #16
101 add X, X, UX
102 add TMP1, TOP, TMP1, asl #1
103 vld1.32 {reg2[0]}, [TMP1], STRIDE
104 vld1.32 {reg2[1]}, [TMP1]
105 convert_four_0565_to_x888_packed reg2, reg1, reg2, tmp
106 .endm
107
108 .macro bilinear_load_and_vertical_interpolate_two_8888 \
109 acc1, acc2, reg1, reg2, reg3, reg4, tmp1, tmp2
110
111 bilinear_load_8888 reg1, reg2, tmp1
112 vmull.u8 acc1, reg1, d28
113 vmlal.u8 acc1, reg2, d29
114 bilinear_load_8888 reg3, reg4, tmp2
115 vmull.u8 acc2, reg3, d28
116 vmlal.u8 acc2, reg4, d29
117 .endm
118
119 .macro bilinear_load_and_vertical_interpolate_four_8888 \
120 xacc1, xacc2, xreg1, xreg2, xreg3, xreg4, xacc2lo, xacc2hi \
121 yacc1, yacc2, yreg1, yreg2, yreg3, yreg4, yacc2lo, yacc2hi
122
123 bilinear_load_and_vertical_interpolate_two_8888 \
124 xacc1, xacc2, xreg1, xreg2, xreg3, xreg4, xacc2lo, xacc2hi
125 bilinear_load_and_vertical_interpolate_two_8888 \
126 yacc1, yacc2, yreg1, yreg2, yreg3, yreg4, yacc2lo, yacc2hi
127 .endm
128
129 .macro bilinear_load_and_vertical_interpolate_two_0565 \
130 acc1, acc2, reg1, reg2, reg3, reg4, acc2lo, acc2hi
131
132 mov TMP1, X, asr #16
133 add X, X, UX
134 add TMP1, TOP, TMP1, asl #1
135 mov TMP2, X, asr #16
136 add X, X, UX
137 add TMP2, TOP, TMP2, asl #1
138 vld1.32 {acc2lo[0]}, [TMP1], STRIDE
139 vld1.32 {acc2hi[0]}, [TMP2], STRIDE
140 vld1.32 {acc2lo[1]}, [TMP1]
141 vld1.32 {acc2hi[1]}, [TMP2]
142 convert_0565_to_x888 acc2, reg3, reg2, reg1
143 vzip.u8 reg1, reg3
144 vzip.u8 reg2, reg4
145 vzip.u8 reg3, reg4
146 vzip.u8 reg1, reg2
147 vmull.u8 acc1, reg1, d28
148 vmlal.u8 acc1, reg2, d29
149 vmull.u8 acc2, reg3, d28
150 vmlal.u8 acc2, reg4, d29
151 .endm
152
153 .macro bilinear_load_and_vertical_interpolate_four_0565 \
154 xacc1, xacc2, xreg1, xreg2, xreg3, xreg4, xacc2lo, xacc2hi \
155 yacc1, yacc2, yreg1, yreg2, yreg3, yreg4, yacc2lo, yacc2hi
156
157 mov TMP1, X, asr #16
158 add X, X, UX
159 add TMP1, TOP, TMP1, asl #1
160 mov TMP2, X, asr #16
161 add X, X, UX
162 add TMP2, TOP, TMP2, asl #1
163 vld1.32 {xacc2lo[0]}, [TMP1], STRIDE
164 vld1.32 {xacc2hi[0]}, [TMP2], STRIDE
165 vld1.32 {xacc2lo[1]}, [TMP1]
166 vld1.32 {xacc2hi[1]}, [TMP2]
167 convert_0565_to_x888 xacc2, xreg3, xreg2, xreg1
168 mov TMP1, X, asr #16
169 add X, X, UX
170 add TMP1, TOP, TMP1, asl #1
171 mov TMP2, X, asr #16
172 add X, X, UX
173 add TMP2, TOP, TMP2, asl #1
174 vld1.32 {yacc2lo[0]}, [TMP1], STRIDE
175 vzip.u8 xreg1, xreg3
176 vld1.32 {yacc2hi[0]}, [TMP2], STRIDE
177 vzip.u8 xreg2, xreg4
178 vld1.32 {yacc2lo[1]}, [TMP1]
179 vzip.u8 xreg3, xreg4
180 vld1.32 {yacc2hi[1]}, [TMP2]
181 vzip.u8 xreg1, xreg2
182 convert_0565_to_x888 yacc2, yreg3, yreg2, yreg1
183 vmull.u8 xacc1, xreg1, d28
184 vzip.u8 yreg1, yreg3
185 vmlal.u8 xacc1, xreg2, d29
186 vzip.u8 yreg2, yreg4
187 vmull.u8 xacc2, xreg3, d28
188 vzip.u8 yreg3, yreg4
189 vmlal.u8 xacc2, xreg4, d29
190 vzip.u8 yreg1, yreg2
191 vmull.u8 yacc1, yreg1, d28
192 vmlal.u8 yacc1, yreg2, d29
193 vmull.u8 yacc2, yreg3, d28
194 vmlal.u8 yacc2, yreg4, d29
195 .endm
196
197 .macro bilinear_store_8888 numpix, tmp1, tmp2
198 .if numpix == 4
199 vst1.32 {d0, d1}, [OUT]!
200 .elseif numpix == 2
201 vst1.32 {d0}, [OUT]!
202 .elseif numpix == 1
203 vst1.32 {d0[0]}, [OUT, :32]!
204 .else
205 .error bilinear_store_8888 numpix is unsupported
206 .endif
207 .endm
208
209 .macro bilinear_store_0565 numpix, tmp1, tmp2
210 vuzp.u8 d0, d1
211 vuzp.u8 d2, d3
212 vuzp.u8 d1, d3
213 vuzp.u8 d0, d2
214 convert_8888_to_0565 d2, d1, d0, q1, tmp1, tmp2
215 .if numpix == 4
216 vst1.16 {d2}, [OUT]!
217 .elseif numpix == 2
218 vst1.32 {d2[0]}, [OUT]!
219 .elseif numpix == 1
220 vst1.16 {d2[0]}, [OUT]!
221 .else
222 .error bilinear_store_0565 numpix is unsupported
223 .endif
224 .endm
225
226
227 /*
228 * Macros for loading mask pixels into register 'mask'.
229 * vdup must be done in somewhere else.
230 */
231 .macro bilinear_load_mask_x numpix, mask
232 .endm
233
234 .macro bilinear_load_mask_8 numpix, mask
235 .if numpix == 4
236 vld1.32 {mask[0]}, [MASK]!
237 .elseif numpix == 2
238 vld1.16 {mask[0]}, [MASK]!
239 .elseif numpix == 1
240 vld1.8 {mask[0]}, [MASK]!
241 .else
242 .error bilinear_load_mask_8 numpix is unsupported
243 .endif
244 pld [MASK, #prefetch_offset]
245 .endm
246
247 .macro bilinear_load_mask mask_fmt, numpix, mask
248 bilinear_load_mask_&mask_fmt numpix, mask
249 .endm
250
251
252 /*
253 * Macros for loading destination pixels into register 'dst0' and 'dst1'.
254 * Interleave should be done somewhere else.
255 */
256 .macro bilinear_load_dst_0565_src numpix, dst0, dst1, dst01
257 .endm
258
259 .macro bilinear_load_dst_8888_src numpix, dst0, dst1, dst01
260 .endm
261
262 .macro bilinear_load_dst_8888 numpix, dst0, dst1, dst01
263 .if numpix == 4
264 vld1.32 {dst0, dst1}, [OUT]
265 .elseif numpix == 2
266 vld1.32 {dst0}, [OUT]
267 .elseif numpix == 1
268 vld1.32 {dst0[0]}, [OUT]
269 .else
270 .error bilinear_load_dst_8888 numpix is unsupported
271 .endif
272 pld [OUT, #(prefetch_offset * 4)]
273 .endm
274
275 .macro bilinear_load_dst_8888_over numpix, dst0, dst1, dst01
276 bilinear_load_dst_8888 numpix, dst0, dst1, dst01
277 .endm
278
279 .macro bilinear_load_dst_8888_add numpix, dst0, dst1, dst01
280 bilinear_load_dst_8888 numpix, dst0, dst1, dst01
281 .endm
282
283 .macro bilinear_load_dst dst_fmt, op, numpix, dst0, dst1, dst01
284 bilinear_load_dst_&dst_fmt&_&op numpix, dst0, dst1, dst01
285 .endm
286
287 /*
288 * Macros for duplicating partially loaded mask to fill entire register.
289 * We will apply mask to interleaved source pixels, that is
290 * (r0, r1, r2, r3, g0, g1, g2, g3) x (m0, m1, m2, m3, m0, m1, m2, m3)
291 * (b0, b1, b2, b3, a0, a1, a2, a3) x (m0, m1, m2, m3, m0, m1, m2, m3)
292 * So, we need to duplicate loaded mask into whole register.
293 *
294 * For two pixel case
295 * (r0, r1, x, x, g0, g1, x, x) x (m0, m1, m0, m1, m0, m1, m0, m1)
296 * (b0, b1, x, x, a0, a1, x, x) x (m0, m1, m0, m1, m0, m1, m0, m1)
297 * We can do some optimizations for this including last pixel cases.
298 */
299 .macro bilinear_duplicate_mask_x numpix, mask
300 .endm
301
302 .macro bilinear_duplicate_mask_8 numpix, mask
303 .if numpix == 4
304 vdup.32 mask, mask[0]
305 .elseif numpix == 2
306 vdup.16 mask, mask[0]
307 .elseif numpix == 1
308 vdup.8 mask, mask[0]
309 .else
310 .error bilinear_duplicate_mask_8 is unsupported
311 .endif
312 .endm
313
314 .macro bilinear_duplicate_mask mask_fmt, numpix, mask
315 bilinear_duplicate_mask_&mask_fmt numpix, mask
316 .endm
317
318 /*
319 * Macros for interleaving src and dst pixels to rrrr gggg bbbb aaaa form.
320 * Interleave should be done when maks is enabled or operator is 'over'.
321 */
322 .macro bilinear_interleave src0, src1, dst0, dst1
323 vuzp.8 src0, src1
324 vuzp.8 dst0, dst1
325 vuzp.8 src0, src1
326 vuzp.8 dst0, dst1
327 .endm
328
329 .macro bilinear_interleave_src_dst_x_src \
330 numpix, src0, src1, src01, dst0, dst1, dst01
331 .endm
332
333 .macro bilinear_interleave_src_dst_x_over \
334 numpix, src0, src1, src01, dst0, dst1, dst01
335
336 bilinear_interleave src0, src1, dst0, dst1
337 .endm
338
339 .macro bilinear_interleave_src_dst_x_add \
340 numpix, src0, src1, src01, dst0, dst1, dst01
341 .endm
342
343 .macro bilinear_interleave_src_dst_8_src \
344 numpix, src0, src1, src01, dst0, dst1, dst01
345
346 bilinear_interleave src0, src1, dst0, dst1
347 .endm
348
349 .macro bilinear_interleave_src_dst_8_over \
350 numpix, src0, src1, src01, dst0, dst1, dst01
351
352 bilinear_interleave src0, src1, dst0, dst1
353 .endm
354
355 .macro bilinear_interleave_src_dst_8_add \
356 numpix, src0, src1, src01, dst0, dst1, dst01
357
358 bilinear_interleave src0, src1, dst0, dst1
359 .endm
360
361 .macro bilinear_interleave_src_dst \
362 mask_fmt, op, numpix, src0, src1, src01, dst0, dst1, dst01
363
364 bilinear_interleave_src_dst_&mask_fmt&_&op \
365 numpix, src0, src1, src01, dst0, dst1, dst01
366 .endm
367
368
369 /*
370 * Macros for applying masks to src pixels. (see combine_mask_u() function)
371 * src, dst should be in interleaved form.
372 * mask register should be in form (m0, m1, m2, m3).
373 */
374 .macro bilinear_apply_mask_to_src_x \
375 numpix, src0, src1, src01, mask, \
376 tmp01, tmp23, tmp45, tmp67
377 .endm
378
379 .macro bilinear_apply_mask_to_src_8 \
380 numpix, src0, src1, src01, mask, \
381 tmp01, tmp23, tmp45, tmp67
382
383 vmull.u8 tmp01, src0, mask
384 vmull.u8 tmp23, src1, mask
385 /* bubbles */
386 vrshr.u16 tmp45, tmp01, #8
387 vrshr.u16 tmp67, tmp23, #8
388 /* bubbles */
389 vraddhn.u16 src0, tmp45, tmp01
390 vraddhn.u16 src1, tmp67, tmp23
391 .endm
392
393 .macro bilinear_apply_mask_to_src \
394 mask_fmt, numpix, src0, src1, src01, mask, \
395 tmp01, tmp23, tmp45, tmp67
396
397 bilinear_apply_mask_to_src_&mask_fmt \
398 numpix, src0, src1, src01, mask, \
399 tmp01, tmp23, tmp45, tmp67
400 .endm
401
402
403 /*
404 * Macros for combining src and destination pixels.
405 * Interleave or not is depending on operator 'op'.
406 */
407 .macro bilinear_combine_src \
408 numpix, src0, src1, src01, dst0, dst1, dst01, \
409 tmp01, tmp23, tmp45, tmp67, tmp8
410 .endm
411
412 .macro bilinear_combine_over \
413 numpix, src0, src1, src01, dst0, dst1, dst01, \
414 tmp01, tmp23, tmp45, tmp67, tmp8
415
416 vdup.32 tmp8, src1[1]
417 /* bubbles */
418 vmvn.8 tmp8, tmp8
419 /* bubbles */
420 vmull.u8 tmp01, dst0, tmp8
421 /* bubbles */
422 vmull.u8 tmp23, dst1, tmp8
423 /* bubbles */
424 vrshr.u16 tmp45, tmp01, #8
425 vrshr.u16 tmp67, tmp23, #8
426 /* bubbles */
427 vraddhn.u16 dst0, tmp45, tmp01
428 vraddhn.u16 dst1, tmp67, tmp23
429 /* bubbles */
430 vqadd.u8 src01, dst01, src01
431 .endm
432
433 .macro bilinear_combine_add \
434 numpix, src0, src1, src01, dst0, dst1, dst01, \
435 tmp01, tmp23, tmp45, tmp67, tmp8
436
437 vqadd.u8 src01, dst01, src01
438 .endm
439
440 .macro bilinear_combine \
441 op, numpix, src0, src1, src01, dst0, dst1, dst01, \
442 tmp01, tmp23, tmp45, tmp67, tmp8
443
444 bilinear_combine_&op \
445 numpix, src0, src1, src01, dst0, dst1, dst01, \
446 tmp01, tmp23, tmp45, tmp67, tmp8
447 .endm
448
449 /*
450 * Macros for final deinterleaving of destination pixels if needed.
451 */
452 .macro bilinear_deinterleave numpix, dst0, dst1, dst01
453 vuzp.8 dst0, dst1
454 /* bubbles */
455 vuzp.8 dst0, dst1
456 .endm
457
458 .macro bilinear_deinterleave_dst_x_src numpix, dst0, dst1, dst01
459 .endm
460
461 .macro bilinear_deinterleave_dst_x_over numpix, dst0, dst1, dst01
462 bilinear_deinterleave numpix, dst0, dst1, dst01
463 .endm
464
465 .macro bilinear_deinterleave_dst_x_add numpix, dst0, dst1, dst01
466 .endm
467
468 .macro bilinear_deinterleave_dst_8_src numpix, dst0, dst1, dst01
469 bilinear_deinterleave numpix, dst0, dst1, dst01
470 .endm
471
472 .macro bilinear_deinterleave_dst_8_over numpix, dst0, dst1, dst01
473 bilinear_deinterleave numpix, dst0, dst1, dst01
474 .endm
475
476 .macro bilinear_deinterleave_dst_8_add numpix, dst0, dst1, dst01
477 bilinear_deinterleave numpix, dst0, dst1, dst01
478 .endm
479
480 .macro bilinear_deinterleave_dst mask_fmt, op, numpix, dst0, dst1, dst01
481 bilinear_deinterleave_dst_&mask_fmt&_&op numpix, dst0, dst1, dst01
482 .endm
483
484
485 .macro bilinear_interpolate_last_pixel src_fmt, mask_fmt, dst_fmt, op
486 bilinear_load_&src_fmt d0, d1, d2
487 bilinear_load_mask mask_fmt, 1, d4
488 bilinear_load_dst dst_fmt, op, 1, d18, d19, q9
489 vmull.u8 q1, d0, d28
490 vmlal.u8 q1, d1, d29
491 /* 5 cycles bubble */
492 vshll.u16 q0, d2, #BILINEAR_INTERPOLATION_BITS
493 vmlsl.u16 q0, d2, d30
494 vmlal.u16 q0, d3, d30
495 /* 5 cycles bubble */
496 bilinear_duplicate_mask mask_fmt, 1, d4
497 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
498 /* 3 cycles bubble */
499 vmovn.u16 d0, q0
500 /* 1 cycle bubble */
501 bilinear_interleave_src_dst \
502 mask_fmt, op, 1, d0, d1, q0, d18, d19, q9
503 bilinear_apply_mask_to_src \
504 mask_fmt, 1, d0, d1, q0, d4, \
505 q3, q8, q10, q11
506 bilinear_combine \
507 op, 1, d0, d1, q0, d18, d19, q9, \
508 q3, q8, q10, q11, d5
509 bilinear_deinterleave_dst mask_fmt, op, 1, d0, d1, q0
510 bilinear_store_&dst_fmt 1, q2, q3
511 .endm
512
513 .macro bilinear_interpolate_two_pixels src_fmt, mask_fmt, dst_fmt, op
514 bilinear_load_and_vertical_interpolate_two_&src_fmt \
515 q1, q11, d0, d1, d20, d21, d22, d23
516 bilinear_load_mask mask_fmt, 2, d4
517 bilinear_load_dst dst_fmt, op, 2, d18, d19, q9
518 vshll.u16 q0, d2, #BILINEAR_INTERPOLATION_BITS
519 vmlsl.u16 q0, d2, d30
520 vmlal.u16 q0, d3, d30
521 vshll.u16 q10, d22, #BILINEAR_INTERPOLATION_BITS
522 vmlsl.u16 q10, d22, d31
523 vmlal.u16 q10, d23, d31
524 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
525 vshrn.u32 d1, q10, #(2 * BILINEAR_INTERPOLATION_BITS)
526 bilinear_duplicate_mask mask_fmt, 2, d4
527 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
528 vadd.u16 q12, q12, q13
529 vmovn.u16 d0, q0
530 bilinear_interleave_src_dst \
531 mask_fmt, op, 2, d0, d1, q0, d18, d19, q9
532 bilinear_apply_mask_to_src \
533 mask_fmt, 2, d0, d1, q0, d4, \
534 q3, q8, q10, q11
535 bilinear_combine \
536 op, 2, d0, d1, q0, d18, d19, q9, \
537 q3, q8, q10, q11, d5
538 bilinear_deinterleave_dst mask_fmt, op, 2, d0, d1, q0
539 bilinear_store_&dst_fmt 2, q2, q3
540 .endm
541
542 .macro bilinear_interpolate_four_pixels src_fmt, mask_fmt, dst_fmt, op
543 bilinear_load_and_vertical_interpolate_four_&src_fmt \
544 q1, q11, d0, d1, d20, d21, d22, d23 \
545 q3, q9, d4, d5, d16, d17, d18, d19
546 pld [TMP1, PF_OFFS]
547 sub TMP1, TMP1, STRIDE
548 vshll.u16 q0, d2, #BILINEAR_INTERPOLATION_BITS
549 vmlsl.u16 q0, d2, d30
550 vmlal.u16 q0, d3, d30
551 vshll.u16 q10, d22, #BILINEAR_INTERPOLATION_BITS
552 vmlsl.u16 q10, d22, d31
553 vmlal.u16 q10, d23, d31
554 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
555 vshll.u16 q2, d6, #BILINEAR_INTERPOLATION_BITS
556 vmlsl.u16 q2, d6, d30
557 vmlal.u16 q2, d7, d30
558 vshll.u16 q8, d18, #BILINEAR_INTERPOLATION_BITS
559 bilinear_load_mask mask_fmt, 4, d22
560 bilinear_load_dst dst_fmt, op, 4, d2, d3, q1
561 pld [TMP1, PF_OFFS]
562 vmlsl.u16 q8, d18, d31
563 vmlal.u16 q8, d19, d31
564 vadd.u16 q12, q12, q13
565 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
566 vshrn.u32 d1, q10, #(2 * BILINEAR_INTERPOLATION_BITS)
567 vshrn.u32 d4, q2, #(2 * BILINEAR_INTERPOLATION_BITS)
568 vshrn.u32 d5, q8, #(2 * BILINEAR_INTERPOLATION_BITS)
569 bilinear_duplicate_mask mask_fmt, 4, d22
570 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
571 vmovn.u16 d0, q0
572 vmovn.u16 d1, q2
573 vadd.u16 q12, q12, q13
574 bilinear_interleave_src_dst \
575 mask_fmt, op, 4, d0, d1, q0, d2, d3, q1
576 bilinear_apply_mask_to_src \
577 mask_fmt, 4, d0, d1, q0, d22, \
578 q3, q8, q9, q10
579 bilinear_combine \
580 op, 4, d0, d1, q0, d2, d3, q1, \
581 q3, q8, q9, q10, d23
582 bilinear_deinterleave_dst mask_fmt, op, 4, d0, d1, q0
583 bilinear_store_&dst_fmt 4, q2, q3
584 .endm
585
586 .set BILINEAR_FLAG_USE_MASK, 1
587 .set BILINEAR_FLAG_USE_ALL_NEON_REGS, 2
588
589 /*
590 * Main template macro for generating NEON optimized bilinear scanline functions.
591 *
592 * Bilinear scanline generator macro take folling arguments:
593 * fname - name of the function to generate
594 * src_fmt - source color format (8888 or 0565)
595 * dst_fmt - destination color format (8888 or 0565)
596 * src/dst_bpp_shift - (1 << bpp_shift) is the size of src/dst pixel in bytes
597 * process_last_pixel - code block that interpolate one pixel and does not
598 * update horizontal weight
599 * process_two_pixels - code block that interpolate two pixels and update
600 * horizontal weight
601 * process_four_pixels - code block that interpolate four pixels and update
602 * horizontal weight
603 * process_pixblock_head - head part of middle loop
604 * process_pixblock_tail - tail part of middle loop
605 * process_pixblock_tail_head - tail_head of middle loop
606 * pixblock_size - number of pixels processed in a single middle loop
607 * prefetch_distance - prefetch in the source image by that many pixels ahead
608 */
609
610 .macro generate_bilinear_scanline_func \
611 fname, \
612 src_fmt, dst_fmt, src_bpp_shift, dst_bpp_shift, \
613 bilinear_process_last_pixel, \
614 bilinear_process_two_pixels, \
615 bilinear_process_four_pixels, \
616 bilinear_process_pixblock_head, \
617 bilinear_process_pixblock_tail, \
618 bilinear_process_pixblock_tail_head, \
619 pixblock_size, \
620 prefetch_distance, \
621 flags
622
623 pixman_asm_function fname
624 .if pixblock_size == 8
625 .elseif pixblock_size == 4
626 .else
627 .error unsupported pixblock size
628 .endif
629
630 .if ((flags) & BILINEAR_FLAG_USE_MASK) == 0
631 OUT .req r0
632 TOP .req r1
633 BOTTOM .req r2
634 WT .req r3
635 WB .req r4
636 X .req r5
637 UX .req r6
638 WIDTH .req ip
639 TMP1 .req r3
640 TMP2 .req r4
641 PF_OFFS .req r7
642 TMP3 .req r8
643 TMP4 .req r9
644 STRIDE .req r2
645
646 mov ip, sp
647 push {r4, r5, r6, r7, r8, r9}
648 mov PF_OFFS, #prefetch_distance
649 ldmia ip, {WB, X, UX, WIDTH}
650 .else
651 OUT .req r0
652 MASK .req r1
653 TOP .req r2
654 BOTTOM .req r3
655 WT .req r4
656 WB .req r5
657 X .req r6
658 UX .req r7
659 WIDTH .req ip
660 TMP1 .req r4
661 TMP2 .req r5
662 PF_OFFS .req r8
663 TMP3 .req r9
664 TMP4 .req r10
665 STRIDE .req r3
666
667 .set prefetch_offset, prefetch_distance
668
669 mov ip, sp
670 push {r4, r5, r6, r7, r8, r9, r10, ip}
671 mov PF_OFFS, #prefetch_distance
672 ldmia ip, {WT, WB, X, UX, WIDTH}
673 .endif
674
675 mul PF_OFFS, PF_OFFS, UX
676
677 .if ((flags) & BILINEAR_FLAG_USE_ALL_NEON_REGS) != 0
678 vpush {d8-d15}
679 .endif
680
681 sub STRIDE, BOTTOM, TOP
682 .unreq BOTTOM
683
684 cmp WIDTH, #0
685 ble 3f
686
687 vdup.u16 q12, X
688 vdup.u16 q13, UX
689 vdup.u8 d28, WT
690 vdup.u8 d29, WB
691 vadd.u16 d25, d25, d26
692
693 /* ensure good destination alignment */
694 cmp WIDTH, #1
695 blt 0f
696 tst OUT, #(1 << dst_bpp_shift)
697 beq 0f
698 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
699 vadd.u16 q12, q12, q13
700 bilinear_process_last_pixel
701 sub WIDTH, WIDTH, #1
702 0:
703 vadd.u16 q13, q13, q13
704 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
705 vadd.u16 q12, q12, q13
706
707 cmp WIDTH, #2
708 blt 0f
709 tst OUT, #(1 << (dst_bpp_shift + 1))
710 beq 0f
711 bilinear_process_two_pixels
712 sub WIDTH, WIDTH, #2
713 0:
714 .if pixblock_size == 8
715 cmp WIDTH, #4
716 blt 0f
717 tst OUT, #(1 << (dst_bpp_shift + 2))
718 beq 0f
719 bilinear_process_four_pixels
720 sub WIDTH, WIDTH, #4
721 0:
722 .endif
723 subs WIDTH, WIDTH, #pixblock_size
724 blt 1f
725 mov PF_OFFS, PF_OFFS, asr #(16 - src_bpp_shift)
726 bilinear_process_pixblock_head
727 subs WIDTH, WIDTH, #pixblock_size
728 blt 5f
729 0:
730 bilinear_process_pixblock_tail_head
731 subs WIDTH, WIDTH, #pixblock_size
732 bge 0b
733 5:
734 bilinear_process_pixblock_tail
735 1:
736 .if pixblock_size == 8
737 tst WIDTH, #4
738 beq 2f
739 bilinear_process_four_pixels
740 2:
741 .endif
742 /* handle the remaining trailing pixels */
743 tst WIDTH, #2
744 beq 2f
745 bilinear_process_two_pixels
746 2:
747 tst WIDTH, #1
748 beq 3f
749 bilinear_process_last_pixel
750 3:
751 .if ((flags) & BILINEAR_FLAG_USE_ALL_NEON_REGS) != 0
752 vpop {d8-d15}
753 .endif
754
755 .if ((flags) & BILINEAR_FLAG_USE_MASK) == 0
756 pop {r4, r5, r6, r7, r8, r9}
757 .else
758 pop {r4, r5, r6, r7, r8, r9, r10, ip}
759 .endif
760 bx lr
761
762 .unreq OUT
763 .unreq TOP
764 .unreq WT
765 .unreq WB
766 .unreq X
767 .unreq UX
768 .unreq WIDTH
769 .unreq TMP1
770 .unreq TMP2
771 .unreq PF_OFFS
772 .unreq TMP3
773 .unreq TMP4
774 .unreq STRIDE
775 .if ((flags) & BILINEAR_FLAG_USE_MASK) != 0
776 .unreq MASK
777 .endif
778
779 .endfunc
780
781 .endm
782
783 /* src_8888_8_8888 */
784 .macro bilinear_src_8888_8_8888_process_last_pixel
785 bilinear_interpolate_last_pixel 8888, 8, 8888, src
786 .endm
787
788 .macro bilinear_src_8888_8_8888_process_two_pixels
789 bilinear_interpolate_two_pixels 8888, 8, 8888, src
790 .endm
791
792 .macro bilinear_src_8888_8_8888_process_four_pixels
793 bilinear_interpolate_four_pixels 8888, 8, 8888, src
794 .endm
795
796 .macro bilinear_src_8888_8_8888_process_pixblock_head
797 bilinear_src_8888_8_8888_process_four_pixels
798 .endm
799
800 .macro bilinear_src_8888_8_8888_process_pixblock_tail
801 .endm
802
803 .macro bilinear_src_8888_8_8888_process_pixblock_tail_head
804 bilinear_src_8888_8_8888_process_pixblock_tail
805 bilinear_src_8888_8_8888_process_pixblock_head
806 .endm
807
808 /* src_8888_8_0565 */
809 .macro bilinear_src_8888_8_0565_process_last_pixel
810 bilinear_interpolate_last_pixel 8888, 8, 0565, src
811 .endm
812
813 .macro bilinear_src_8888_8_0565_process_two_pixels
814 bilinear_interpolate_two_pixels 8888, 8, 0565, src
815 .endm
816
817 .macro bilinear_src_8888_8_0565_process_four_pixels
818 bilinear_interpolate_four_pixels 8888, 8, 0565, src
819 .endm
820
821 .macro bilinear_src_8888_8_0565_process_pixblock_head
822 bilinear_src_8888_8_0565_process_four_pixels
823 .endm
824
825 .macro bilinear_src_8888_8_0565_process_pixblock_tail
826 .endm
827
828 .macro bilinear_src_8888_8_0565_process_pixblock_tail_head
829 bilinear_src_8888_8_0565_process_pixblock_tail
830 bilinear_src_8888_8_0565_process_pixblock_head
831 .endm
832
833 /* src_0565_8_x888 */
834 .macro bilinear_src_0565_8_x888_process_last_pixel
835 bilinear_interpolate_last_pixel 0565, 8, 8888, src
836 .endm
837
838 .macro bilinear_src_0565_8_x888_process_two_pixels
839 bilinear_interpolate_two_pixels 0565, 8, 8888, src
840 .endm
841
842 .macro bilinear_src_0565_8_x888_process_four_pixels
843 bilinear_interpolate_four_pixels 0565, 8, 8888, src
844 .endm
845
846 .macro bilinear_src_0565_8_x888_process_pixblock_head
847 bilinear_src_0565_8_x888_process_four_pixels
848 .endm
849
850 .macro bilinear_src_0565_8_x888_process_pixblock_tail
851 .endm
852
853 .macro bilinear_src_0565_8_x888_process_pixblock_tail_head
854 bilinear_src_0565_8_x888_process_pixblock_tail
855 bilinear_src_0565_8_x888_process_pixblock_head
856 .endm
857
858 /* src_0565_8_0565 */
859 .macro bilinear_src_0565_8_0565_process_last_pixel
860 bilinear_interpolate_last_pixel 0565, 8, 0565, src
861 .endm
862
863 .macro bilinear_src_0565_8_0565_process_two_pixels
864 bilinear_interpolate_two_pixels 0565, 8, 0565, src
865 .endm
866
867 .macro bilinear_src_0565_8_0565_process_four_pixels
868 bilinear_interpolate_four_pixels 0565, 8, 0565, src
869 .endm
870
871 .macro bilinear_src_0565_8_0565_process_pixblock_head
872 bilinear_src_0565_8_0565_process_four_pixels
873 .endm
874
875 .macro bilinear_src_0565_8_0565_process_pixblock_tail
876 .endm
877
878 .macro bilinear_src_0565_8_0565_process_pixblock_tail_head
879 bilinear_src_0565_8_0565_process_pixblock_tail
880 bilinear_src_0565_8_0565_process_pixblock_head
881 .endm
882
883 /* over_8888_8888 */
884 .macro bilinear_over_8888_8888_process_last_pixel
885 bilinear_interpolate_last_pixel 8888, x, 8888, over
886 .endm
887
888 .macro bilinear_over_8888_8888_process_two_pixels
889 bilinear_interpolate_two_pixels 8888, x, 8888, over
890 .endm
891
892 .macro bilinear_over_8888_8888_process_four_pixels
893 bilinear_interpolate_four_pixels 8888, x, 8888, over
894 .endm
895
896 .macro bilinear_over_8888_8888_process_pixblock_head
897 mov TMP1, X, asr #16
898 add X, X, UX
899 add TMP1, TOP, TMP1, asl #2
900 mov TMP2, X, asr #16
901 add X, X, UX
902 add TMP2, TOP, TMP2, asl #2
903
904 vld1.32 {d22}, [TMP1], STRIDE
905 vld1.32 {d23}, [TMP1]
906 mov TMP3, X, asr #16
907 add X, X, UX
908 add TMP3, TOP, TMP3, asl #2
909 vmull.u8 q8, d22, d28
910 vmlal.u8 q8, d23, d29
911
912 vld1.32 {d22}, [TMP2], STRIDE
913 vld1.32 {d23}, [TMP2]
914 mov TMP4, X, asr #16
915 add X, X, UX
916 add TMP4, TOP, TMP4, asl #2
917 vmull.u8 q9, d22, d28
918 vmlal.u8 q9, d23, d29
919
920 vld1.32 {d22}, [TMP3], STRIDE
921 vld1.32 {d23}, [TMP3]
922 vmull.u8 q10, d22, d28
923 vmlal.u8 q10, d23, d29
924
925 vshll.u16 q0, d16, #BILINEAR_INTERPOLATION_BITS
926 vmlsl.u16 q0, d16, d30
927 vmlal.u16 q0, d17, d30
928
929 pld [TMP4, PF_OFFS]
930 vld1.32 {d16}, [TMP4], STRIDE
931 vld1.32 {d17}, [TMP4]
932 pld [TMP4, PF_OFFS]
933 vmull.u8 q11, d16, d28
934 vmlal.u8 q11, d17, d29
935
936 vshll.u16 q1, d18, #BILINEAR_INTERPOLATION_BITS
937 vmlsl.u16 q1, d18, d31
938 vmlal.u16 q1, d19, d31
939 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
940 vadd.u16 q12, q12, q13
941 .endm
942
943 .macro bilinear_over_8888_8888_process_pixblock_tail
944 vshll.u16 q2, d20, #BILINEAR_INTERPOLATION_BITS
945 vmlsl.u16 q2, d20, d30
946 vmlal.u16 q2, d21, d30
947 vshll.u16 q3, d22, #BILINEAR_INTERPOLATION_BITS
948 vmlsl.u16 q3, d22, d31
949 vmlal.u16 q3, d23, d31
950 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
951 vshrn.u32 d1, q1, #(2 * BILINEAR_INTERPOLATION_BITS)
952 vld1.32 {d2, d3}, [OUT, :128]
953 pld [OUT, #(prefetch_offset * 4)]
954 vshrn.u32 d4, q2, #(2 * BILINEAR_INTERPOLATION_BITS)
955 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
956 vshrn.u32 d5, q3, #(2 * BILINEAR_INTERPOLATION_BITS)
957 vmovn.u16 d6, q0
958 vmovn.u16 d7, q2
959 vuzp.8 d6, d7
960 vuzp.8 d2, d3
961 vuzp.8 d6, d7
962 vuzp.8 d2, d3
963 vdup.32 d4, d7[1]
964 vmvn.8 d4, d4
965 vmull.u8 q11, d2, d4
966 vmull.u8 q2, d3, d4
967 vrshr.u16 q1, q11, #8
968 vrshr.u16 q10, q2, #8
969 vraddhn.u16 d2, q1, q11
970 vraddhn.u16 d3, q10, q2
971 vqadd.u8 q3, q1, q3
972 vuzp.8 d6, d7
973 vuzp.8 d6, d7
974 vadd.u16 q12, q12, q13
975 vst1.32 {d6, d7}, [OUT, :128]!
976 .endm
977
978 .macro bilinear_over_8888_8888_process_pixblock_tail_head
979 vshll.u16 q2, d20, #BILINEAR_INTERPOLATION_BITS
980 mov TMP1, X, asr #16
981 add X, X, UX
982 add TMP1, TOP, TMP1, asl #2
983 vmlsl.u16 q2, d20, d30
984 mov TMP2, X, asr #16
985 add X, X, UX
986 add TMP2, TOP, TMP2, asl #2
987 vmlal.u16 q2, d21, d30
988 vshll.u16 q3, d22, #BILINEAR_INTERPOLATION_BITS
989 vld1.32 {d20}, [TMP1], STRIDE
990 vmlsl.u16 q3, d22, d31
991 vmlal.u16 q3, d23, d31
992 vld1.32 {d21}, [TMP1]
993 vmull.u8 q8, d20, d28
994 vmlal.u8 q8, d21, d29
995 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
996 vshrn.u32 d1, q1, #(2 * BILINEAR_INTERPOLATION_BITS)
997 vld1.32 {d2, d3}, [OUT, :128]
998 pld [OUT, PF_OFFS]
999 vshrn.u32 d4, q2, #(2 * BILINEAR_INTERPOLATION_BITS)
1000 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1001 vld1.32 {d22}, [TMP2], STRIDE
1002 vshrn.u32 d5, q3, #(2 * BILINEAR_INTERPOLATION_BITS)
1003 vmovn.u16 d6, q0
1004 vld1.32 {d23}, [TMP2]
1005 vmull.u8 q9, d22, d28
1006 mov TMP3, X, asr #16
1007 add X, X, UX
1008 add TMP3, TOP, TMP3, asl #2
1009 mov TMP4, X, asr #16
1010 add X, X, UX
1011 add TMP4, TOP, TMP4, asl #2
1012 vmlal.u8 q9, d23, d29
1013 vmovn.u16 d7, q2
1014 vld1.32 {d22}, [TMP3], STRIDE
1015 vuzp.8 d6, d7
1016 vuzp.8 d2, d3
1017 vuzp.8 d6, d7
1018 vuzp.8 d2, d3
1019 vdup.32 d4, d7[1]
1020 vld1.32 {d23}, [TMP3]
1021 vmvn.8 d4, d4
1022 vmull.u8 q10, d22, d28
1023 vmlal.u8 q10, d23, d29
1024 vmull.u8 q11, d2, d4
1025 vmull.u8 q2, d3, d4
1026 vshll.u16 q0, d16, #BILINEAR_INTERPOLATION_BITS
1027 vmlsl.u16 q0, d16, d30
1028 vrshr.u16 q1, q11, #8
1029 vmlal.u16 q0, d17, d30
1030 vrshr.u16 q8, q2, #8
1031 vraddhn.u16 d2, q1, q11
1032 vraddhn.u16 d3, q8, q2
1033 pld [TMP4, PF_OFFS]
1034 vld1.32 {d16}, [TMP4], STRIDE
1035 vqadd.u8 q3, q1, q3
1036 vld1.32 {d17}, [TMP4]
1037 pld [TMP4, PF_OFFS]
1038 vmull.u8 q11, d16, d28
1039 vmlal.u8 q11, d17, d29
1040 vuzp.8 d6, d7
1041 vshll.u16 q1, d18, #BILINEAR_INTERPOLATION_BITS
1042 vuzp.8 d6, d7
1043 vmlsl.u16 q1, d18, d31
1044 vadd.u16 q12, q12, q13
1045 vmlal.u16 q1, d19, d31
1046 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1047 vadd.u16 q12, q12, q13
1048 vst1.32 {d6, d7}, [OUT, :128]!
1049 .endm
1050
1051 /* over_8888_8_8888 */
1052 .macro bilinear_over_8888_8_8888_process_last_pixel
1053 bilinear_interpolate_last_pixel 8888, 8, 8888, over
1054 .endm
1055
1056 .macro bilinear_over_8888_8_8888_process_two_pixels
1057 bilinear_interpolate_two_pixels 8888, 8, 8888, over
1058 .endm
1059
1060 .macro bilinear_over_8888_8_8888_process_four_pixels
1061 bilinear_interpolate_four_pixels 8888, 8, 8888, over
1062 .endm
1063
1064 .macro bilinear_over_8888_8_8888_process_pixblock_head
1065 mov TMP1, X, asr #16
1066 add X, X, UX
1067 add TMP1, TOP, TMP1, asl #2
1068 vld1.32 {d0}, [TMP1], STRIDE
1069 mov TMP2, X, asr #16
1070 add X, X, UX
1071 add TMP2, TOP, TMP2, asl #2
1072 vld1.32 {d1}, [TMP1]
1073 mov TMP3, X, asr #16
1074 add X, X, UX
1075 add TMP3, TOP, TMP3, asl #2
1076 vld1.32 {d2}, [TMP2], STRIDE
1077 mov TMP4, X, asr #16
1078 add X, X, UX
1079 add TMP4, TOP, TMP4, asl #2
1080 vld1.32 {d3}, [TMP2]
1081 vmull.u8 q2, d0, d28
1082 vmull.u8 q3, d2, d28
1083 vmlal.u8 q2, d1, d29
1084 vmlal.u8 q3, d3, d29
1085 vshll.u16 q0, d4, #BILINEAR_INTERPOLATION_BITS
1086 vshll.u16 q1, d6, #BILINEAR_INTERPOLATION_BITS
1087 vmlsl.u16 q0, d4, d30
1088 vmlsl.u16 q1, d6, d31
1089 vmlal.u16 q0, d5, d30
1090 vmlal.u16 q1, d7, d31
1091 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
1092 vshrn.u32 d1, q1, #(2 * BILINEAR_INTERPOLATION_BITS)
1093 vld1.32 {d2}, [TMP3], STRIDE
1094 vld1.32 {d3}, [TMP3]
1095 pld [TMP4, PF_OFFS]
1096 vld1.32 {d4}, [TMP4], STRIDE
1097 vld1.32 {d5}, [TMP4]
1098 pld [TMP4, PF_OFFS]
1099 vmull.u8 q3, d2, d28
1100 vmlal.u8 q3, d3, d29
1101 vmull.u8 q1, d4, d28
1102 vmlal.u8 q1, d5, d29
1103 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1104 vld1.32 {d22[0]}, [MASK]!
1105 pld [MASK, #prefetch_offset]
1106 vadd.u16 q12, q12, q13
1107 vmovn.u16 d16, q0
1108 .endm
1109
1110 .macro bilinear_over_8888_8_8888_process_pixblock_tail
1111 vshll.u16 q9, d6, #BILINEAR_INTERPOLATION_BITS
1112 vshll.u16 q10, d2, #BILINEAR_INTERPOLATION_BITS
1113 vmlsl.u16 q9, d6, d30
1114 vmlsl.u16 q10, d2, d31
1115 vmlal.u16 q9, d7, d30
1116 vmlal.u16 q10, d3, d31
1117 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1118 vadd.u16 q12, q12, q13
1119 vdup.32 d22, d22[0]
1120 vshrn.u32 d18, q9, #(2 * BILINEAR_INTERPOLATION_BITS)
1121 vshrn.u32 d19, q10, #(2 * BILINEAR_INTERPOLATION_BITS)
1122 vmovn.u16 d17, q9
1123 vld1.32 {d18, d19}, [OUT, :128]
1124 pld [OUT, PF_OFFS]
1125 vuzp.8 d16, d17
1126 vuzp.8 d18, d19
1127 vuzp.8 d16, d17
1128 vuzp.8 d18, d19
1129 vmull.u8 q10, d16, d22
1130 vmull.u8 q11, d17, d22
1131 vrsra.u16 q10, q10, #8
1132 vrsra.u16 q11, q11, #8
1133 vrshrn.u16 d16, q10, #8
1134 vrshrn.u16 d17, q11, #8
1135 vdup.32 d22, d17[1]
1136 vmvn.8 d22, d22
1137 vmull.u8 q10, d18, d22
1138 vmull.u8 q11, d19, d22
1139 vrshr.u16 q9, q10, #8
1140 vrshr.u16 q0, q11, #8
1141 vraddhn.u16 d18, q9, q10
1142 vraddhn.u16 d19, q0, q11
1143 vqadd.u8 q9, q8, q9
1144 vuzp.8 d18, d19
1145 vuzp.8 d18, d19
1146 vst1.32 {d18, d19}, [OUT, :128]!
1147 .endm
1148
1149 .macro bilinear_over_8888_8_8888_process_pixblock_tail_head
1150 vshll.u16 q9, d6, #BILINEAR_INTERPOLATION_BITS
1151 mov TMP1, X, asr #16
1152 add X, X, UX
1153 add TMP1, TOP, TMP1, asl #2
1154 vshll.u16 q10, d2, #BILINEAR_INTERPOLATION_BITS
1155 vld1.32 {d0}, [TMP1], STRIDE
1156 mov TMP2, X, asr #16
1157 add X, X, UX
1158 add TMP2, TOP, TMP2, asl #2
1159 vmlsl.u16 q9, d6, d30
1160 vmlsl.u16 q10, d2, d31
1161 vld1.32 {d1}, [TMP1]
1162 mov TMP3, X, asr #16
1163 add X, X, UX
1164 add TMP3, TOP, TMP3, asl #2
1165 vmlal.u16 q9, d7, d30
1166 vmlal.u16 q10, d3, d31
1167 vld1.32 {d2}, [TMP2], STRIDE
1168 mov TMP4, X, asr #16
1169 add X, X, UX
1170 add TMP4, TOP, TMP4, asl #2
1171 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1172 vadd.u16 q12, q12, q13
1173 vld1.32 {d3}, [TMP2]
1174 vdup.32 d22, d22[0]
1175 vshrn.u32 d18, q9, #(2 * BILINEAR_INTERPOLATION_BITS)
1176 vshrn.u32 d19, q10, #(2 * BILINEAR_INTERPOLATION_BITS)
1177 vmull.u8 q2, d0, d28
1178 vmull.u8 q3, d2, d28
1179 vmovn.u16 d17, q9
1180 vld1.32 {d18, d19}, [OUT, :128]
1181 pld [OUT, #(prefetch_offset * 4)]
1182 vmlal.u8 q2, d1, d29
1183 vmlal.u8 q3, d3, d29
1184 vuzp.8 d16, d17
1185 vuzp.8 d18, d19
1186 vshll.u16 q0, d4, #BILINEAR_INTERPOLATION_BITS
1187 vshll.u16 q1, d6, #BILINEAR_INTERPOLATION_BITS
1188 vuzp.8 d16, d17
1189 vuzp.8 d18, d19
1190 vmlsl.u16 q0, d4, d30
1191 vmlsl.u16 q1, d6, d31
1192 vmull.u8 q10, d16, d22
1193 vmull.u8 q11, d17, d22
1194 vmlal.u16 q0, d5, d30
1195 vmlal.u16 q1, d7, d31
1196 vrsra.u16 q10, q10, #8
1197 vrsra.u16 q11, q11, #8
1198 vshrn.u32 d0, q0, #(2 * BILINEAR_INTERPOLATION_BITS)
1199 vshrn.u32 d1, q1, #(2 * BILINEAR_INTERPOLATION_BITS)
1200 vrshrn.u16 d16, q10, #8
1201 vrshrn.u16 d17, q11, #8
1202 vld1.32 {d2}, [TMP3], STRIDE
1203 vdup.32 d22, d17[1]
1204 vld1.32 {d3}, [TMP3]
1205 vmvn.8 d22, d22
1206 pld [TMP4, PF_OFFS]
1207 vld1.32 {d4}, [TMP4], STRIDE
1208 vmull.u8 q10, d18, d22
1209 vmull.u8 q11, d19, d22
1210 vld1.32 {d5}, [TMP4]
1211 pld [TMP4, PF_OFFS]
1212 vmull.u8 q3, d2, d28
1213 vrshr.u16 q9, q10, #8
1214 vrshr.u16 q15, q11, #8
1215 vmlal.u8 q3, d3, d29
1216 vmull.u8 q1, d4, d28
1217 vraddhn.u16 d18, q9, q10
1218 vraddhn.u16 d19, q15, q11
1219 vmlal.u8 q1, d5, d29
1220 vshr.u16 q15, q12, #(16 - BILINEAR_INTERPOLATION_BITS)
1221 vqadd.u8 q9, q8, q9
1222 vld1.32 {d22[0]}, [MASK]!
1223 vuzp.8 d18, d19
1224 vadd.u16 q12, q12, q13
1225 vuzp.8 d18, d19
1226 vmovn.u16 d16, q0
1227 vst1.32 {d18, d19}, [OUT, :128]!
1228 .endm
1229
1230 /* add_8888_8888 */
1231 .macro bilinear_add_8888_8888_process_last_pixel
1232 bilinear_interpolate_last_pixel 8888, x, 8888, add
1233 .endm
1234
1235 .macro bilinear_add_8888_8888_process_two_pixels
1236 bilinear_interpolate_two_pixels 8888, x, 8888, add
1237 .endm
1238
1239 .macro bilinear_add_8888_8888_process_four_pixels
1240 bilinear_interpolate_four_pixels 8888, x, 8888, add
1241 .endm
1242
1243 .macro bilinear_add_8888_8888_process_pixblock_head
1244 bilinear_add_8888_8888_process_four_pixels
1245 .endm
1246
1247 .macro bilinear_add_8888_8888_process_pixblock_tail
1248 .endm
1249
1250 .macro bilinear_add_8888_8888_process_pixblock_tail_head
1251 bilinear_add_8888_8888_process_pixblock_tail
1252 bilinear_add_8888_8888_process_pixblock_head
1253 .endm
1254
1255 /* add_8888_8_8888 */
1256 .macro bilinear_add_8888_8_8888_process_last_pixel
1257 bilinear_interpolate_last_pixel 8888, 8, 8888, add
1258 .endm
1259
1260 .macro bilinear_add_8888_8_8888_process_two_pixels
1261 bilinear_interpolate_two_pixels 8888, 8, 8888, add
1262 .endm
1263
1264 .macro bilinear_add_8888_8_8888_process_four_pixels
1265 bilinear_interpolate_four_pixels 8888, 8, 8888, add
1266 .endm
1267
1268 .macro bilinear_add_8888_8_8888_process_pixblock_head
1269 bilinear_add_8888_8_8888_process_four_pixels
1270 .endm
1271
1272 .macro bilinear_add_8888_8_8888_process_pixblock_tail
1273 .endm
1274
1275 .macro bilinear_add_8888_8_8888_process_pixblock_tail_head
1276 bilinear_add_8888_8_8888_process_pixblock_tail
1277 bilinear_add_8888_8_8888_process_pixblock_head
1278 .endm
1279
1280
1281 /* Bilinear scanline functions */
1282 generate_bilinear_scanline_func \
1283 pixman_scaled_bilinear_scanline_8888_8_8888_SRC_asm_neon, \
1284 8888, 8888, 2, 2, \
1285 bilinear_src_8888_8_8888_process_last_pixel, \
1286 bilinear_src_8888_8_8888_process_two_pixels, \
1287 bilinear_src_8888_8_8888_process_four_pixels, \
1288 bilinear_src_8888_8_8888_process_pixblock_head, \
1289 bilinear_src_8888_8_8888_process_pixblock_tail, \
1290 bilinear_src_8888_8_8888_process_pixblock_tail_head, \
1291 4, 28, BILINEAR_FLAG_USE_MASK
1292
1293 generate_bilinear_scanline_func \
1294 pixman_scaled_bilinear_scanline_8888_8_0565_SRC_asm_neon, \
1295 8888, 0565, 2, 1, \
1296 bilinear_src_8888_8_0565_process_last_pixel, \
1297 bilinear_src_8888_8_0565_process_two_pixels, \
1298 bilinear_src_8888_8_0565_process_four_pixels, \
1299 bilinear_src_8888_8_0565_process_pixblock_head, \
1300 bilinear_src_8888_8_0565_process_pixblock_tail, \
1301 bilinear_src_8888_8_0565_process_pixblock_tail_head, \
1302 4, 28, BILINEAR_FLAG_USE_MASK
1303
1304 generate_bilinear_scanline_func \
1305 pixman_scaled_bilinear_scanline_0565_8_x888_SRC_asm_neon, \
1306 0565, 8888, 1, 2, \
1307 bilinear_src_0565_8_x888_process_last_pixel, \
1308 bilinear_src_0565_8_x888_process_two_pixels, \
1309 bilinear_src_0565_8_x888_process_four_pixels, \
1310 bilinear_src_0565_8_x888_process_pixblock_head, \
1311 bilinear_src_0565_8_x888_process_pixblock_tail, \
1312 bilinear_src_0565_8_x888_process_pixblock_tail_head, \
1313 4, 28, BILINEAR_FLAG_USE_MASK
1314
1315 generate_bilinear_scanline_func \
1316 pixman_scaled_bilinear_scanline_0565_8_0565_SRC_asm_neon, \
1317 0565, 0565, 1, 1, \
1318 bilinear_src_0565_8_0565_process_last_pixel, \
1319 bilinear_src_0565_8_0565_process_two_pixels, \
1320 bilinear_src_0565_8_0565_process_four_pixels, \
1321 bilinear_src_0565_8_0565_process_pixblock_head, \
1322 bilinear_src_0565_8_0565_process_pixblock_tail, \
1323 bilinear_src_0565_8_0565_process_pixblock_tail_head, \
1324 4, 28, BILINEAR_FLAG_USE_MASK
1325
1326 generate_bilinear_scanline_func \
1327 pixman_scaled_bilinear_scanline_8888_8888_OVER_asm_neon, \
1328 8888, 8888, 2, 2, \
1329 bilinear_over_8888_8888_process_last_pixel, \
1330 bilinear_over_8888_8888_process_two_pixels, \
1331 bilinear_over_8888_8888_process_four_pixels, \
1332 bilinear_over_8888_8888_process_pixblock_head, \
1333 bilinear_over_8888_8888_process_pixblock_tail, \
1334 bilinear_over_8888_8888_process_pixblock_tail_head, \
1335 4, 28, 0
1336
1337 generate_bilinear_scanline_func \
1338 pixman_scaled_bilinear_scanline_8888_8_8888_OVER_asm_neon, \
1339 8888, 8888, 2, 2, \
1340 bilinear_over_8888_8_8888_process_last_pixel, \
1341 bilinear_over_8888_8_8888_process_two_pixels, \
1342 bilinear_over_8888_8_8888_process_four_pixels, \
1343 bilinear_over_8888_8_8888_process_pixblock_head, \
1344 bilinear_over_8888_8_8888_process_pixblock_tail, \
1345 bilinear_over_8888_8_8888_process_pixblock_tail_head, \
1346 4, 28, BILINEAR_FLAG_USE_MASK
1347
1348 generate_bilinear_scanline_func \
1349 pixman_scaled_bilinear_scanline_8888_8888_ADD_asm_neon, \
1350 8888, 8888, 2, 2, \
1351 bilinear_add_8888_8888_process_last_pixel, \
1352 bilinear_add_8888_8888_process_two_pixels, \
1353 bilinear_add_8888_8888_process_four_pixels, \
1354 bilinear_add_8888_8888_process_pixblock_head, \
1355 bilinear_add_8888_8888_process_pixblock_tail, \
1356 bilinear_add_8888_8888_process_pixblock_tail_head, \
1357 4, 28, 0
1358
1359 generate_bilinear_scanline_func \
1360 pixman_scaled_bilinear_scanline_8888_8_8888_ADD_asm_neon, \
1361 8888, 8888, 2, 2, \
1362 bilinear_add_8888_8_8888_process_last_pixel, \
1363 bilinear_add_8888_8_8888_process_two_pixels, \
1364 bilinear_add_8888_8_8888_process_four_pixels, \
1365 bilinear_add_8888_8_8888_process_pixblock_head, \
1366 bilinear_add_8888_8_8888_process_pixblock_tail, \
1367 bilinear_add_8888_8_8888_process_pixblock_tail_head, \
1368 4, 28, BILINEAR_FLAG_USE_MASK

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial