src/lib/engines/common_16/evas_soft16_image_unscaled.c

   1 #include "evas_common_soft16.h"
   2 #include "evas_soft16_scanline_blend.c"
   3
   4 static void
   5 _soft16_image_draw_unscaled_solid_solid(Soft16_Image *src, Soft16_Image *dst,
   6                                         RGBA_Draw_Context *dc,
   7                                         int src_offset, int dst_offset,
   8                                         int w, int h)
   9 {
  10    DATA16 *src_itr, *dst_itr;
  11    int y;
  12
  13    src_itr = src->pixels + src_offset;
  14    dst_itr = dst->pixels + dst_offset;
  15
  16    for (y = 0; y < h; y++)
  17      {
  18         _soft16_scanline_blend_solid_solid(src_itr, dst_itr, w);
  19         src_itr += src->stride;
  20         dst_itr += dst->stride;
  21      }
  22 }
  23
  24 static void
  25 _soft16_image_draw_unscaled_transp_solid(Soft16_Image *src, Soft16_Image *dst,
  26                                          RGBA_Draw_Context *dc,
  27                                          int src_offset, int dst_offset,
  28                                          int w, int h)
  29
  30 {
  31    DATA16 *src_itr, *dst_itr;
  32    DATA8 *alpha_itr;
  33    int y;
  34
  35    src_itr = src->pixels + src_offset;
  36    alpha_itr = src->alpha + src_offset;
  37    dst_itr = dst->pixels + dst_offset;
  38
  39    for (y = 0; y < h; y++)
  40      {
  41         _soft16_scanline_blend_transp_solid(src_itr, alpha_itr, dst_itr, w);
  42         src_itr += src->stride;
  43         alpha_itr += src->stride;
  44         dst_itr += dst->stride;
  45      }
  46 }
  47
  48 static inline void
  49 _soft16_image_draw_unscaled_no_mul(Soft16_Image *src, Soft16_Image *dst,
  50                                    RGBA_Draw_Context *dc,
  51                                    int src_offset, int dst_offset,
  52                                    int width, int height)
  53 {
  54    if (src->cache_entry.flags.alpha && (!dst->cache_entry.flags.alpha))
  55       _soft16_image_draw_unscaled_transp_solid(src, dst, dc,
  56                                                src_offset, dst_offset,
  57                                                width, height);
  58    else if ((!src->cache_entry.flags.alpha) && (!dst->cache_entry.flags.alpha))
  59       _soft16_image_draw_unscaled_solid_solid(src, dst, dc,
  60                                               src_offset, dst_offset,
  61                                               width, height);
  62    else
  63       fprintf(stderr,
  64               "Unsupported draw of unscaled images src->cache_entry.flags.alpha=%d, "
  65               "dst->cache_entry.flags.alpha=%d, WITHOUT COLOR MUL\n",
  66               src->cache_entry.flags.alpha, dst->cache_entry.flags.alpha);
  67 }
  68
  69 static void
  70 _soft16_image_draw_unscaled_solid_solid_mul_alpha(Soft16_Image *src,
  71                                                   Soft16_Image *dst,
  72                                                   RGBA_Draw_Context *dc,
  73                                                   int src_offset,
  74                                                   int dst_offset,
  75                                                   int w, int h, DATA8 a)
  76 {
  77    DATA16 *src_itr, *dst_itr;
  78    int y;
  79
  80    src_itr = src->pixels + src_offset;
  81    dst_itr = dst->pixels + dst_offset;
  82
  83    for (y = 0; y < h; y++)
  84      {
  85         _soft16_scanline_blend_solid_solid_mul_alpha(src_itr, dst_itr, w, a);
  86         src_itr += src->stride;
  87         dst_itr += dst->stride;
  88      }
  89 }
  90
  91 static void
  92 _soft16_image_draw_unscaled_transp_solid_mul_alpha(Soft16_Image *src,
  93                                                    Soft16_Image *dst,
  94                                                    RGBA_Draw_Context *dc,
  95                                                    int src_offset,
  96                                                    int dst_offset,
  97                                                    int w, int h, DATA8 a)
  98
  99 {
 100    DATA16 *src_itr, *dst_itr;
 101    DATA8 *alpha_itr;
 102    int y;
 103
 104    src_itr = src->pixels + src_offset;
 105    alpha_itr = src->alpha + src_offset;
 106    dst_itr = dst->pixels + dst_offset;
 107
 108    for (y = 0; y < h; y++)
 109      {
 110         _soft16_scanline_blend_transp_solid_mul_alpha(src_itr, alpha_itr,
 111                                                       dst_itr, w, a);
 112         src_itr += src->stride;
 113         alpha_itr += src->stride;
 114         dst_itr += dst->stride;
 115      }
 116 }
 117
 118 static inline void
 119 _soft16_image_draw_unscaled_mul_alpha(Soft16_Image *src, Soft16_Image *dst,
 120                                       RGBA_Draw_Context *dc,
 121                                       int src_offset, int dst_offset,
 122                                       int width, int height, DATA8 a)
 123 {
 124    if (src->cache_entry.flags.alpha && (!dst->cache_entry.flags.alpha))
 125       _soft16_image_draw_unscaled_transp_solid_mul_alpha
 126          (src, dst, dc, src_offset, dst_offset, width, height, a);
 127    else if ((!src->cache_entry.flags.alpha) && (!dst->cache_entry.flags.alpha))
 128       _soft16_image_draw_unscaled_solid_solid_mul_alpha
 129          (src, dst, dc, src_offset, dst_offset, width, height, a);
 130    else
 131       fprintf(stderr,
 132               "Unsupported draw of unscaled images src->cache_entry.flags.alpha=%d, "
 133               "dst->cache_entry.flags.alpha=%d, WITH ALPHA MUL %d\n",
 134               src->cache_entry.flags.alpha, dst->cache_entry.flags.alpha, A_VAL(&dc->mul.col));
 135 }
 136
 137 static void
 138 _soft16_image_draw_unscaled_solid_solid_mul_color(Soft16_Image *src,
 139                                                   Soft16_Image *dst,
 140                                                   RGBA_Draw_Context *dc,
 141                                                   int src_offset,
 142                                                   int dst_offset,
 143                                                   int w, int h, DATA8 r,
 144                                                   DATA8 g, DATA8 b, DATA8 a)
 145 {
 146    DATA16 *src_itr, *dst_itr;
 147    int y;
 148
 149    src_itr = src->pixels + src_offset;
 150    dst_itr = dst->pixels + dst_offset;
 151
 152    if (a == 31)
 153       for (y = 0; y < h; y++)
 154          {
 155             _soft16_scanline_blend_solid_solid_mul_color_solid
 156                (src_itr, dst_itr, w, r, g, b);
 157             src_itr += src->stride;
 158             dst_itr += dst->stride;
 159          }
 160    else
 161       for (y = 0; y < h; y++)
 162          {
 163             _soft16_scanline_blend_solid_solid_mul_color_transp
 164                (src_itr, dst_itr, w, a, r, g, b);
 165             src_itr += src->stride;
 166             dst_itr += dst->stride;
 167          }
 168 }
 169
 170 static void
 171 _soft16_image_draw_unscaled_transp_solid_mul_color(Soft16_Image *src,
 172                                                    Soft16_Image *dst,
 173                                                    RGBA_Draw_Context *dc,
 174                                                    int src_offset,
 175                                                    int dst_offset,
 176                                                    int w, int h, DATA8 r,
 177                                                    DATA8 g, DATA8 b, DATA8 a)
 178
 179 {
 180    DATA16 *src_itr, *dst_itr;
 181    DATA8 *alpha_itr;
 182    int y;
 183
 184    src_itr = src->pixels + src_offset;
 185    alpha_itr = src->alpha + src_offset;
 186    dst_itr = dst->pixels + dst_offset;
 187
 188    if (a == 31)
 189       for (y = 0; y < h; y++)
 190          {
 191             _soft16_scanline_blend_transp_solid_mul_color_solid
 192                (src_itr, alpha_itr, dst_itr, w, r, g, b);
 193             src_itr += src->stride;
 194             alpha_itr += src->stride;
 195             dst_itr += dst->stride;
 196          }
 197    else
 198       for (y = 0; y < h; y++)
 199          {
 200             _soft16_scanline_blend_transp_solid_mul_color_transp
 201                (src_itr, alpha_itr, dst_itr, w, a, r, g, b);
 202             src_itr += src->stride;
 203             alpha_itr += src->stride;
 204             dst_itr += dst->stride;
 205          }
 206 }
 207
 208 static inline void
 209 _soft16_image_draw_unscaled_mul_color(Soft16_Image *src, Soft16_Image *dst,
 210                                       RGBA_Draw_Context *dc,
 211                                       int src_offset, int dst_offset,
 212                                       int width, int height,
 213                                       DATA8 r, DATA8 g, DATA8 b, DATA8 a)
 214 {
 215    if (src->cache_entry.flags.alpha && (!dst->cache_entry.flags.alpha))
 216      _soft16_image_draw_unscaled_transp_solid_mul_color
 217         (src, dst, dc, src_offset, dst_offset, width, height, r, g, b, a);
 218    else if ((!src->cache_entry.flags.alpha) && (!dst->cache_entry.flags.alpha))
 219      _soft16_image_draw_unscaled_solid_solid_mul_color
 220        (src, dst, dc, src_offset, dst_offset, width, height, r, g, b, a);
 221    else
 222       fprintf(stderr,
 223               "Unsupported draw of unscaled images src->cache_entry.flags.alpha=%d, "
 224               "dst->cache_entry.flags.alpha=%d, WITH COLOR MUL 0x%08x\n",
 225               src->cache_entry.flags.alpha, dst->cache_entry.flags.alpha, dc->mul.col);
 226 }
 227
 228 static inline void
 229 _soft16_image_draw_unscaled_mul(Soft16_Image *src, Soft16_Image *dst,
 230                                 RGBA_Draw_Context *dc,
 231                                 int src_offset, int dst_offset,
 232                                 int width, int height, DATA8 r, DATA8 g,
 233                                 DATA8 b, DATA8 a)
 234 {
 235    if ((a == r) && (a == (g >> 1)) && (a == b))
 236       _soft16_image_draw_unscaled_mul_alpha(src, dst, dc, src_offset,
 237                                             dst_offset, width, height, a);
 238    else
 239       _soft16_image_draw_unscaled_mul_color(src, dst, dc, src_offset,
 240                                             dst_offset, width, height,
 241                                             r, g, b, a);
 242 }
 243
 244 void
 245 soft16_image_draw_unscaled(Soft16_Image *src, Soft16_Image *dst,
 246                            RGBA_Draw_Context *dc,
 247                            const Evas_Rectangle sr,
 248                            const Evas_Rectangle dr,
 249                            const Evas_Rectangle cr)
 250 {
 251    int src_offset_rows, src_offset, dst_offset;
 252    DATA16 mul_rgb565;
 253    DATA8 r, g, b, a;
 254
 255    if (!dc->mul.use)
 256      {
 257         r = b = a = 31;
 258         g = 63;
 259         mul_rgb565 = 0xffff;
 260      }
 261    else
 262      {
 263         a = A_VAL(&dc->mul.col) >> 3;
 264         if (a == 0)
 265           return;
 266
 267         r = R_VAL(&dc->mul.col) >> 3;
 268         g = G_VAL(&dc->mul.col) >> 2;
 269         b = B_VAL(&dc->mul.col) >> 3;
 270
 271         if (r > a) r = a;
 272         if (g > (a << 1)) g = (a << 1);
 273         if (b > a) b = a;
 274
 275         mul_rgb565 = (r << 11) || (g << 5) | b;
 276      }
 277
 278
 279    src_offset_rows = (cr.y - dr.y) + sr.y;
 280    src_offset = (src_offset_rows * src->stride) + (cr.x - dr.x) + sr.x;
 281
 282    dst_offset = cr.x + (cr.y * dst->stride);
 283
 284    if (mul_rgb565 == 0xffff)
 285        _soft16_image_draw_unscaled_no_mul(src, dst, dc, src_offset, dst_offset,
 286                                           cr.w, cr.h);
 287    else
 288        _soft16_image_draw_unscaled_mul(src, dst, dc, src_offset, dst_offset,
 289                                        cr.w, cr.h, r, g, b, a);
 290 }