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 (nlukic@mips.com) 30 */ 31 32#ifndef PIXMAN_MIPS_DSPR2_H 33#define PIXMAN_MIPS_DSPR2_H 34 35#include "pixman-private.h" 36#include "pixman-inlines.h" 37 38#define SKIP_ZERO_SRC 1 39#define SKIP_ZERO_MASK 2 40#define DO_FAST_MEMCPY 3 41 42void 43pixman_mips_fast_memcpy (void *dst, void *src, uint32_t n_bytes); 44void 45pixman_fill_buff16_mips (void *dst, uint32_t n_bytes, uint16_t value); 46void 47pixman_fill_buff32_mips (void *dst, uint32_t n_bytes, uint32_t value); 48 49/****************************************************************/ 50 51#define PIXMAN_MIPS_BIND_FAST_PATH_SRC_DST(flags, name, \ 52 src_type, src_cnt, \ 53 dst_type, dst_cnt) \ 54void \ 55pixman_composite_##name##_asm_mips (dst_type *dst, \ 56 src_type *src, \ 57 int32_t w); \ 58 \ 59static void \ 60mips_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} 87 88/****************************************************************/ 89 90#define PIXMAN_MIPS_BIND_FAST_PATH_N_DST(flags, name, \ 91 dst_type, dst_cnt) \ 92void \ 93pixman_composite_##name##_asm_mips (dst_type *dst, \ 94 uint32_t src, \ 95 int32_t w); \ 96 \ 97static void \ 98mips_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} 123 124/*******************************************************************/ 125 126#define PIXMAN_MIPS_BIND_FAST_PATH_N_MASK_DST(flags, name, \ 127 mask_type, mask_cnt, \ 128 dst_type, dst_cnt) \ 129void \ 130pixman_composite_##name##_asm_mips (dst_type *dst, \ 131 uint32_t src, \ 132 mask_type *mask, \ 133 int32_t w); \ 134 \ 135static void \ 136mips_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} 165 166/*******************************************************************/ 167 168#define PIXMAN_MIPS_BIND_FAST_PATH_SRC_N_DST(flags, name, \ 169 src_type, src_cnt, \ 170 dst_type, dst_cnt) \ 171void \ 172pixman_composite_##name##_asm_mips (dst_type *dst, \ 173 src_type *src, \ 174 uint32_t mask, \ 175 int32_t w); \ 176 \ 177static void \ 178mips_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} 208 209/************************************************************************/ 210 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) \ 214void \ 215pixman_composite_##name##_asm_mips (dst_type *dst, \ 216 src_type *src, \ 217 mask_type *mask, \ 218 int32_t w); \ 219 \ 220static void \ 221mips_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} 248 249/****************************************************************************/ 250 251#define PIXMAN_MIPS_BIND_SCALED_NEAREST_SRC_DST(name, op, \ 252 src_type, dst_type) \ 253void \ 254pixman_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 \ 261static force_inline void \ 262scaled_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 \ 274FAST_NEAREST_MAINLOOP (mips_##name##_cover_##op, \ 275 scaled_nearest_scanline_mips_##name##_##op, \ 276 src_type, dst_type, COVER) \ 277FAST_NEAREST_MAINLOOP (mips_##name##_none_##op, \ 278 scaled_nearest_scanline_mips_##name##_##op, \ 279 src_type, dst_type, NONE) \ 280FAST_NEAREST_MAINLOOP (mips_##name##_pad_##op, \ 281 scaled_nearest_scanline_mips_##name##_##op, \ 282 src_type, dst_type, PAD) 283 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) 289 290 291/*****************************************************************************/ 292 293#define PIXMAN_MIPS_BIND_SCALED_NEAREST_SRC_A8_DST(flags, name, op, \ 294 src_type, dst_type) \ 295void \ 296pixman_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 \ 304static force_inline void \ 305scaled_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 \ 321FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_cover_##op, \ 322 scaled_nearest_scanline_mips_##name##_##op, \ 323 src_type, uint8_t, dst_type, COVER, TRUE, FALSE)\ 324FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_none_##op, \ 325 scaled_nearest_scanline_mips_##name##_##op, \ 326 src_type, uint8_t, dst_type, NONE, TRUE, FALSE) \ 327FAST_NEAREST_MAINLOOP_COMMON (mips_##name##_pad_##op, \ 328 scaled_nearest_scanline_mips_##name##_##op, \ 329 src_type, uint8_t, dst_type, PAD, TRUE, FALSE) 330 331/* Provide entries for the fast path table */ 332#define PIXMAN_MIPS_SIMPLE_NEAREST_A8_MASK_FAST_PATH(op,s,d,func) \ 333 SIMPLE_NEAREST_A8_MASK_FAST_PATH_COVER (op,s,d,func), \ 334 SIMPLE_NEAREST_A8_MASK_FAST_PATH_NONE (op,s,d,func), \ 335 SIMPLE_NEAREST_A8_MASK_FAST_PATH_PAD (op,s,d,func) 336 337/****************************************************************************/ 338 339#define PIXMAN_MIPS_BIND_SCALED_BILINEAR_SRC_DST(flags, name, op, \ 340 src_type, dst_type) \ 341void \ 342pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips( \ 343 dst_type * dst, \ 344 const src_type * src_top, \ 345 const src_type * src_bottom, \ 346 int32_t w, \ 347 int wt, \ 348 int wb, \ 349 pixman_fixed_t vx, \ 350 pixman_fixed_t unit_x); \ 351static force_inline void \ 352scaled_bilinear_scanline_mips_##name##_##op (dst_type * dst, \ 353 const uint32_t * mask, \ 354 const src_type * src_top, \ 355 const src_type * src_bottom, \ 356 int32_t w, \ 357 int wt, \ 358 int wb, \ 359 pixman_fixed_t vx, \ 360 pixman_fixed_t unit_x, \ 361 pixman_fixed_t max_vx, \ 362 pixman_bool_t zero_src) \ 363{ \ 364 if ((flags & SKIP_ZERO_SRC) && zero_src) \ 365 return; \ 366 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips (dst, src_top, \ 367 src_bottom, w, \ 368 wt, wb, \ 369 vx, unit_x); \ 370} \ 371 \ 372FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_cover_##op, \ 373 scaled_bilinear_scanline_mips_##name##_##op, \ 374 src_type, uint32_t, dst_type, COVER, FLAG_NONE) \ 375FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_none_##op, \ 376 scaled_bilinear_scanline_mips_##name##_##op, \ 377 src_type, uint32_t, dst_type, NONE, FLAG_NONE) \ 378FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_pad_##op, \ 379 scaled_bilinear_scanline_mips_##name##_##op, \ 380 src_type, uint32_t, dst_type, PAD, FLAG_NONE) \ 381FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_normal_##op, \ 382 scaled_bilinear_scanline_mips_##name##_##op, \ 383 src_type, uint32_t, dst_type, NORMAL, \ 384 FLAG_NONE) 385 386/*****************************************************************************/ 387 388#define PIXMAN_MIPS_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, name, op, \ 389 src_type, dst_type) \ 390void \ 391pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips ( \ 392 dst_type * dst, \ 393 const uint8_t * mask, \ 394 const src_type * top, \ 395 const src_type * bottom, \ 396 int wt, \ 397 int wb, \ 398 pixman_fixed_t x, \ 399 pixman_fixed_t ux, \ 400 int width); \ 401 \ 402static force_inline void \ 403scaled_bilinear_scanline_mips_##name##_##op (dst_type * dst, \ 404 const uint8_t * mask, \ 405 const src_type * src_top, \ 406 const src_type * src_bottom, \ 407 int32_t w, \ 408 int wt, \ 409 int wb, \ 410 pixman_fixed_t vx, \ 411 pixman_fixed_t unit_x, \ 412 pixman_fixed_t max_vx, \ 413 pixman_bool_t zero_src) \ 414{ \ 415 if ((flags & SKIP_ZERO_SRC) && zero_src) \ 416 return; \ 417 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips ( \ 418 dst, mask, src_top, src_bottom, wt, wb, vx, unit_x, w); \ 419} \ 420 \ 421FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_cover_##op, \ 422 scaled_bilinear_scanline_mips_##name##_##op, \ 423 src_type, uint8_t, dst_type, COVER, \ 424 FLAG_HAVE_NON_SOLID_MASK) \ 425FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_none_##op, \ 426 scaled_bilinear_scanline_mips_##name##_##op, \ 427 src_type, uint8_t, dst_type, NONE, \ 428 FLAG_HAVE_NON_SOLID_MASK) \ 429FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_pad_##op, \ 430 scaled_bilinear_scanline_mips_##name##_##op, \ 431 src_type, uint8_t, dst_type, PAD, \ 432 FLAG_HAVE_NON_SOLID_MASK) \ 433FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_normal_##op, \ 434 scaled_bilinear_scanline_mips_##name##_##op, \ 435 src_type, uint8_t, dst_type, NORMAL, \ 436 FLAG_HAVE_NON_SOLID_MASK) 437 438#endif //PIXMAN_MIPS_DSPR2_H 439