pixman/pixman-mips-dspr2.h

   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
  42 void
  43 pixman_mips_fast_memcpy (void *dst, void *src, uint32_t n_bytes);
  44 void
  45 pixman_fill_buff16_mips (void *dst, uint32_t n_bytes, uint16_t value);
  46 void
  47 pixman_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)    \
  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 }
  87
  88 /*******************************************************************/
  89
  90 #define PIXMAN_MIPS_BIND_FAST_PATH_N_MASK_DST(flags, name,          \
  91                                               mask_type, mask_cnt,  \
  92                                               dst_type, dst_cnt)    \
  93 void                                                                \
  94 pixman_composite_##name##_asm_mips (dst_type  *dst,                 \
  95                                     uint32_t  src,                  \
  96                                     mask_type *mask,                \
  97                                     int32_t   w);                   \
  98                                                                     \
  99 static void                                                         \
 100 mips_composite_##name (pixman_implementation_t *imp,                \
 101                        pixman_composite_info_t *info)               \
 102 {                                                                   \
 103     PIXMAN_COMPOSITE_ARGS (info);                                   \
 104     dst_type  *dst_line, *dst;                                      \
 105     mask_type *mask_line, *mask;                                    \
 106     int32_t    dst_stride, mask_stride;                             \
 107     uint32_t   src;                                                 \
 108                                                                     \
 109     src = _pixman_image_get_solid (                                 \
 110         imp, src_image, dest_image->bits.format);                   \
 111                                                                     \
 112     if ((flags & SKIP_ZERO_SRC) && src == 0)                        \
 113         return;                                                     \
 114                                                                     \
 115     PIXMAN_IMAGE_GET_LINE (dest_image, dest_x, dest_y, dst_type,    \
 116                            dst_stride, dst_line, dst_cnt);          \
 117     PIXMAN_IMAGE_GET_LINE (mask_image, mask_x, mask_y, mask_type,   \
 118                            mask_stride, mask_line, mask_cnt);       \
 119                                                                     \
 120     while (height--)                                                \
 121     {                                                               \
 122         dst = dst_line;                                             \
 123         dst_line += dst_stride;                                     \
 124         mask = mask_line;                                           \
 125         mask_line += mask_stride;                                   \
 126         pixman_composite_##name##_asm_mips (dst, src, mask, width); \
 127     }                                                               \
 128 }
 129
 130 /*****************************************************************************/
 131
 132 #define PIXMAN_MIPS_BIND_SCALED_BILINEAR_SRC_A8_DST(flags, name, op,          \
 133                                                 src_type, dst_type)           \
 134 void                                                                          \
 135 pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips (                    \
 136                                              dst_type *       dst,            \
 137                                              const uint8_t *  mask,           \
 138                                              const src_type * top,            \
 139                                              const src_type * bottom,         \
 140                                              int              wt,             \
 141                                              int              wb,             \
 142                                              pixman_fixed_t   x,              \
 143                                              pixman_fixed_t   ux,             \
 144                                              int              width);         \
 145                                                                               \
 146 static force_inline void                                                      \
 147 scaled_bilinear_scanline_mips_##name##_##op (dst_type *       dst,            \
 148                                              const uint8_t *  mask,           \
 149                                              const src_type * src_top,        \
 150                                              const src_type * src_bottom,     \
 151                                              int32_t          w,              \
 152                                              int              wt,             \
 153                                              int              wb,             \
 154                                              pixman_fixed_t   vx,             \
 155                                              pixman_fixed_t   unit_x,         \
 156                                              pixman_fixed_t   max_vx,         \
 157                                              pixman_bool_t    zero_src)       \
 158 {                                                                             \
 159     if ((flags & SKIP_ZERO_SRC) && zero_src)                                  \
 160         return;                                                               \
 161     pixman_scaled_bilinear_scanline_##name##_##op##_asm_mips (                \
 162                       dst, mask, src_top, src_bottom, wt, wb, vx, unit_x, w); \
 163 }                                                                             \
 164                                                                               \
 165 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_cover_##op,                      \
 166                        scaled_bilinear_scanline_mips_##name##_##op,           \
 167                        src_type, uint8_t, dst_type, COVER,                    \
 168                        FLAG_HAVE_NON_SOLID_MASK)                              \
 169 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_none_##op,                       \
 170                        scaled_bilinear_scanline_mips_##name##_##op,           \
 171                        src_type, uint8_t, dst_type, NONE,                     \
 172                        FLAG_HAVE_NON_SOLID_MASK)                              \
 173 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_pad_##op,                        \
 174                        scaled_bilinear_scanline_mips_##name##_##op,           \
 175                        src_type, uint8_t, dst_type, PAD,                      \
 176                        FLAG_HAVE_NON_SOLID_MASK)                              \
 177 FAST_BILINEAR_MAINLOOP_COMMON (mips_##name##_normal_##op,                     \
 178                        scaled_bilinear_scanline_mips_##name##_##op,           \
 179                        src_type, uint8_t, dst_type, NORMAL,                   \
 180                        FLAG_HAVE_NON_SOLID_MASK)
 181
 182 #endif //PIXMAN_MIPS_DSPR2_H