| blob | 57b38359e37ed425a5d13cdece0dbbc9d669ded9 |
1 /*
2 * Copyright (c) 2012
3 * MIPS Technologies, Inc., California.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * Author: Nemanja Lukic (nemanja.lukic@rt-rk.com)
30 */
32 #ifndef PIXMAN_MIPS_DSPR2_H
33 #define PIXMAN_MIPS_DSPR2_H
38 #define SKIP_ZERO_SRC 1
39 #define SKIP_ZERO_MASK 2
40 #define DO_FAST_MEMCPY 3
42 void
44 void
46 void
49 /****************************************************************/
51 #define PIXMAN_MIPS_BIND_FAST_PATH_SRC_DST(flags, name, \
52 src_type, src_cnt, \
53 dst_type, dst_cnt) \
54 void \
55 pixman_composite_##name##_asm_mips (dst_type *dst, \
56 src_type *src, \
57 int32_t w); \
58 \
59 static void \
60 mips_composite_##name (pixman_implementation_t *imp, \
61 pixman_composite_info_t *info) \
62 { \
63 PIXMAN_COMPOSITE_ARGS (info); \
64 dst_type *dst_line, *dst; \
65 src_type *src_line, *src; \
66 int32_t dst_stride, src_stride; \
67 int bpp = PIXMAN_FORMAT_BPP (dest_image->bits.format) / 8; \
68 \
69 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type, \
70 src_stride, src_line, src_cnt); \
71 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type, \
72 dst_stride, dst_line, dst_cnt); \
73 \
74 while (height--) \
75 { \
76 dst = dst_line; \
77 dst_line += dst_stride; \
78 src = src_line; \
79 src_line += src_stride; \
80 \
81 if (flags == DO_FAST_MEMCPY) \
82 pixman_mips_fast_memcpy (dst, src, width * bpp); \
83 else \
84 pixman_composite_##name##_asm_mips (dst, src, width); \
85 } \
86 }
88 /****************************************************************/
90 #define PIXMAN_MIPS_BIND_FAST_PATH_N_DST(flags, name, \
91 dst_type, dst_cnt) \
92 void \
93 pixman_composite_##name##_asm_mips (dst_type *dst, \
94 uint32_t src, \
95 int32_t w); \
96 \
97 static void \
98 mips_composite_##name (pixman_implementation_t *imp, \
99 pixman_composite_info_t *info) \
100 { \
101 PIXMAN_COMPOSITE_ARGS (info); \
102 dst_type *dst_line, *dst; \
103 int32_t dst_stride; \
104 uint32_t src; \
105 \
106 src = _pixman_image_get_solid ( \
107 imp, src_image, dest_image->bits.format); \
108 \
109 if ((flags & SKIP_ZERO_SRC) && src == 0) \
110 return; \
111 \
112 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type, \
113 dst_stride, dst_line, dst_cnt); \
114 \
115 while (height--) \
116 { \
117 dst = dst_line; \
118 dst_line += dst_stride; \
119 \
120 pixman_composite_##name##_asm_mips (dst, src, width); \
121 } \
122 }
124 /*******************************************************************/
126 #define PIXMAN_MIPS_BIND_FAST_PATH_N_MASK_DST(flags, name, \
127 mask_type, mask_cnt, \
128 dst_type, dst_cnt) \
129 void \
130 pixman_composite_##name##_asm_mips (dst_type *dst, \
131 uint32_t src, \
132 mask_type *mask, \
133 int32_t w); \
134 \
135 static void \
136 mips_composite_##name (pixman_implementation_t *imp, \
137 pixman_composite_info_t *info) \
138 { \
139 PIXMAN_COMPOSITE_ARGS (info); \
140 dst_type *dst_line, *dst; \
141 mask_type *mask_line, *mask; \
142 int32_t dst_stride, mask_stride; \
143 uint32_t src; \
144 \
145 src = _pixman_image_get_solid ( \
146 imp, src_image, dest_image->bits.format); \
147 \
148 if ((flags & SKIP_ZERO_SRC) && src == 0) \
149 return; \
150 \
151 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type, \
152 dst_stride, dst_line, dst_cnt); \
153 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type, \
154 mask_stride, mask_line, mask_cnt); \
155 \
156 while (height--) \
157 { \
158 dst = dst_line; \
159 dst_line += dst_stride; \
160 mask = mask_line; \
161 mask_line += mask_stride; \
162 pixman_composite_##name##_asm_mips (dst, src, mask, width); \
163 } \
164 }
166 /*******************************************************************/
168 #define PIXMAN_MIPS_BIND_FAST_PATH_SRC_N_DST(flags, name, \
169 src_type, src_cnt, \
170 dst_type, dst_cnt) \
171 void \
172 pixman_composite_##name##_asm_mips (dst_type *dst, \
173 src_type *src, \
174 uint32_t mask, \
175 int32_t w); \
176 \
177 static void \
178 mips_composite_##name (pixman_implementation_t *imp, \
179 pixman_composite_info_t *info) \
180 { \
181 PIXMAN_COMPOSITE_ARGS (info); \
182 dst_type *dst_line, *dst; \
183 src_type *src_line, *src; \
184 int32_t dst_stride, src_stride; \
185 uint32_t mask; \
186 \
187 mask = _pixman_image_get_solid ( \
188 imp, mask_image, dest_image->bits.format); \
189 \
190 if ((flags & SKIP_ZERO_MASK) && mask == 0) \
191 return; \
192 \
193 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type, \
194 dst_stride, dst_line, dst_cnt); \
195 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type, \
196 src_stride, src_line, src_cnt); \
197 \
198 while (height--) \
199 { \
200 dst = dst_line; \
201 dst_line += dst_stride; \
202 src = src_line; \
203 src_line += src_stride; \
204 \
205 pixman_composite_##name##_asm_mips (dst, src, mask, width); \
206 } \
207 }
209 /************************************************************************/
211 #define PIXMAN_MIPS_BIND_FAST_PATH_SRC_MASK_DST(name, src_type, src_cnt, \
212 mask_type, mask_cnt, \
213 dst_type, dst_cnt) \
214 void \
215 pixman_composite_##name##_asm_mips (dst_type *dst, \
216 src_type *src, \
217 mask_type *mask, \
218 int32_t w); \
219 \
220 static void \
221 mips_composite_##name (pixman_implementation_t *imp, \
222 pixman_composite_info_t *info) \
223 { \
224 PIXMAN_COMPOSITE_ARGS (info); \
225 dst_type *dst_line, *dst; \
226 src_type *src_line, *src; \
227 mask_type *mask_line, *mask; \
228 int32_t dst_stride, src_stride, mask_stride; \
229 \
230 PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type, \
231 dst_stride, dst_line, dst_cnt); \
232 PIXMAN_IMAGE_GET_LINE (src_image, src_x, src_y, src_type, \
233 src_stride, src_line, src_cnt); \
234 PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type, \
235 mask_stride, mask_line, mask_cnt); \
236 \
237 while (height--) \
238 { \
239 dst = dst_line; \
240 dst_line += dst_stride; \
241 mask = mask_line; \
242 mask_line += mask_stride; \
243 src = src_line; \
244 src_line += src_stride; \
245 pixman_composite_##name##_asm_mips (dst, src, mask, width); \
246 } \
247 }
249 /****************************************************************************/
251 #define PIXMAN_MIPS_BIND_SCALED_NEAREST_SRC_DST(name, op, \
252 src_type, dst_type) \
253 void \
254 pixman_scaled_nearest_scanline_##name##_##op##_asm_mips ( \
255 dst_type * dst, \
256 const src_type * src, \
257 int32_t w, \
258 pixman_fixed_t vx, \
259 pixman_fixed_t unit_x); \
260 \
261 static force_inline void \
262 scaled_nearest_scanline_mips_##name##_##op (dst_type * pd, \
263 const src_type * ps, \
264 int32_t w, \
265 pixman_fixed_t vx, \
266 pixman_fixed_t unit_x, \
267 pixman_fixed_t max_vx, \
268 pixman_bool_t zero_src) \
269 { \
270 pixman_scaled_nearest_scanline_##name##_##op##_asm_mips (pd, ps, w, \
271 vx, unit_x); \
272 } \
273 \
274 FAST_NEAREST_MAINLOOP (mips_##name##_cover_##op, \
275 scaled_nearest_scanline_mips_##name##_##op, \
276 src_type, dst_type, COVER) \
277 FAST_NEAREST_MAINLOOP (mips_##name##_none_##op, \
278 scaled_nearest_scanline_mips_##name##_##op, \
279 src_type, dst_type, NONE) \
280 FAST_NEAREST_MAINLOOP (mips_##name##_pad_##op, \
281 scaled_nearest_scanline_mips_##name##_##op, \
282 src_type, dst_type, PAD)
284 /* Provide entries for the fast path table */
285 #define PIXMAN_MIPS_SIMPLE_NEAREST_FAST_PATH(op,s,d,func) \
286 SIMPLE_NEAREST_FAST_PATH_COVER (op,s,d,func), \
287 SIMPLE_NEAREST_FAST_PATH_NONE (op,s,d,func), \
288 SIMPLE_NEAREST_FAST_PATH_PAD (op,s,d,func)
291 /*****************************************************************************/
293 #define PIXMAN_MIPS_BIND_SCALED_NEAREST_SRC_A8_DST(flags, name, op, \
294 src_type, dst_type) \
295 void \
296 pixman_scaled_nearest_scanline_##name##_##op##_asm_mips ( \
297 dst_type * dst, \
298 const src_type * src, \
299 const uint8_t * mask, \
300 int32_t w, \
301 pixman_fixed_t vx, \
302 pixman_fixed_t unit_x); \
303 \
304 static force_inline void \
305 scaled_nearest_scanline_mips_##name##_##op (const uint8_t * mask, \
306 dst_type * pd, \
307 const src_type * ps, \
308 int32_t w, \
309 pixman_fixed_t vx, \
310 pixman_fixed_t unit_x, \
311 pixman_fixed_t max_vx, \
312 pixman_bool_t zero_src) \
313 { \
314 if ((flags & SKIP_ZERO_SRC) && zero_src) \
315 return; \
316 pixman_scaled_nearest_scanline_##name##_##op##_asm_mips (pd, ps, \
317 mask, w, \
318 vx, unit_x); \
319 } \
320 \
321 FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_cover_##op, \
322 scaled_nearest_scanline_mips_##name##_##op, \
323 src_type, uint8_t, dst_type, COVER, TRUE, FALSE)\
324 FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_none_##op, \
325 scaled_nearest_scanline_mips_##name##_##op, \
326 src_type, uint8_t, dst_type, NONE, TRUE, FALSE) \
327 FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_pad_##op, \
328 scaled_nearest_scanline_mips_##name##_##op, \
329 src_type, uint8_t, dst_type, PAD, TRUE, FALSE)
331 /****************************************************************************/
333 #define PIXMAN_MIPS_BIND_SCALED_BILINEAR_SRC_DST(flags, name, op, \
334 src_type, dst_type) \
335 void \
336 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips( \
337 dst_type * dst, \
338 const src_type * src_top, \
339 const src_type * src_bottom, \
340 int32_t w, \
341 int wt, \
342 int wb, \
343 pixman_fixed_t vx, \
344 pixman_fixed_t unit_x); \
345 static force_inline void \
346 scaled_bilinear_scanline_mips_##name##_##op (dst_type * dst, \
347 const uint32_t * mask, \
348 const src_type * src_top, \
349 const src_type * src_bottom, \
350 int32_t w, \
351 int wt, \
352 int wb, \
353 pixman_fixed_t vx, \
354 pixman_fixed_t unit_x, \
355 pixman_fixed_t max_vx, \
356 pixman_bool_t zero_src) \
357 { \
358 if ((flags & SKIP_ZERO_SRC) && zero_src) \
359 return; \
360 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips (dst, src_top, \
361 src_bottom, w, \
362 wt, wb, \
363 vx, unit_x); \
364 } \
365 \
366 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_cover_##op, \
367 scaled_bilinear_scanline_mips_##name##_##op, \
368 src_type, uint32_t, dst_type, COVER, FLAG_NONE) \
369 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_none_##op, \
370 scaled_bilinear_scanline_mips_##name##_##op, \
371 src_type, uint32_t, dst_type, NONE, FLAG_NONE) \
372 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_pad_##op, \
373 scaled_bilinear_scanline_mips_##name##_##op, \
374 src_type, uint32_t, dst_type, PAD, FLAG_NONE) \
375 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_normal_##op, \
376 scaled_bilinear_scanline_mips_##name##_##op, \
377 src_type, uint32_t, dst_type, NORMAL, \
378 FLAG_NONE)
380 /*****************************************************************************/
382 #define PIXMAN_MIPS_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, name, op, \
383 src_type, dst_type) \
384 void \
385 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips ( \
386 dst_type * dst, \
387 const uint8_t * mask, \
388 const src_type * top, \
389 const src_type * bottom, \
390 int wt, \
391 int wb, \
392 pixman_fixed_t x, \
393 pixman_fixed_t ux, \
394 int width); \
395 \
396 static force_inline void \
397 scaled_bilinear_scanline_mips_##name##_##op (dst_type * dst, \
398 const uint8_t * mask, \
399 const src_type * src_top, \
400 const src_type * src_bottom, \
401 int32_t w, \
402 int wt, \
403 int wb, \
404 pixman_fixed_t vx, \
405 pixman_fixed_t unit_x, \
406 pixman_fixed_t max_vx, \
407 pixman_bool_t zero_src) \
408 { \
409 if ((flags & SKIP_ZERO_SRC) && zero_src) \
410 return; \
411 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips ( \
412 dst, mask, src_top, src_bottom, wt, wb, vx, unit_x, w); \
413 } \
414 \
415 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_cover_##op, \
416 scaled_bilinear_scanline_mips_##name##_##op, \
417 src_type, uint8_t, dst_type, COVER, \
418 FLAG_HAVE_NON_SOLID_MASK) \
419 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_none_##op, \
420 scaled_bilinear_scanline_mips_##name##_##op, \
421 src_type, uint8_t, dst_type, NONE, \
422 FLAG_HAVE_NON_SOLID_MASK) \
423 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_pad_##op, \
424 scaled_bilinear_scanline_mips_##name##_##op, \
425 src_type, uint8_t, dst_type, PAD, \
426 FLAG_HAVE_NON_SOLID_MASK) \
427 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_normal_##op, \
428 scaled_bilinear_scanline_mips_##name##_##op, \
429 src_type, uint8_t, dst_type, NORMAL, \
430 FLAG_HAVE_NON_SOLID_MASK)