Line data    Source code

       1             : /*
       2             :  * Copyright 2009 The Android Open Source Project
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : 
       9             : #include "SkColorPriv.h"
      10             : 
      11             : /*
      12             :     Filter_32_opaque
      13             : 
      14             :     There is no hard-n-fast rule that the filtering must produce
      15             :     exact results for the color components, but if the 4 incoming colors are
      16             :     all opaque, then the output color must also be opaque. Subsequent parts of
      17             :     the drawing pipeline may rely on this (e.g. which blitrow proc to use).
      18             :  */
      19             : 
      20           0 : static inline void Filter_32_opaque(unsigned x, unsigned y,
      21             :                                     SkPMColor a00, SkPMColor a01,
      22             :                                     SkPMColor a10, SkPMColor a11,
      23             :                                     SkPMColor* dstColor) {
      24           0 :     SkASSERT((unsigned)x <= 0xF);
      25           0 :     SkASSERT((unsigned)y <= 0xF);
      26             : 
      27           0 :     int xy = x * y;
      28           0 :     const uint32_t mask = 0xFF00FF;
      29             : 
      30           0 :     int scale = 256 - 16*y - 16*x + xy;
      31           0 :     uint32_t lo = (a00 & mask) * scale;
      32           0 :     uint32_t hi = ((a00 >> 8) & mask) * scale;
      33             : 
      34           0 :     scale = 16*x - xy;
      35           0 :     lo += (a01 & mask) * scale;
      36           0 :     hi += ((a01 >> 8) & mask) * scale;
      37             : 
      38           0 :     scale = 16*y - xy;
      39           0 :     lo += (a10 & mask) * scale;
      40           0 :     hi += ((a10 >> 8) & mask) * scale;
      41             : 
      42           0 :     lo += (a11 & mask) * xy;
      43           0 :     hi += ((a11 >> 8) & mask) * xy;
      44             : 
      45           0 :     *dstColor = ((lo >> 8) & mask) | (hi & ~mask);
      46           0 : }
      47             : 
      48           0 : static inline void Filter_32_alpha(unsigned x, unsigned y,
      49             :                                    SkPMColor a00, SkPMColor a01,
      50             :                                    SkPMColor a10, SkPMColor a11,
      51             :                                    SkPMColor* dstColor,
      52             :                                    unsigned alphaScale) {
      53           0 :     SkASSERT((unsigned)x <= 0xF);
      54           0 :     SkASSERT((unsigned)y <= 0xF);
      55           0 :     SkASSERT(alphaScale <= 256);
      56             : 
      57           0 :     int xy = x * y;
      58           0 :     const uint32_t mask = 0xFF00FF;
      59             : 
      60           0 :     int scale = 256 - 16*y - 16*x + xy;
      61           0 :     uint32_t lo = (a00 & mask) * scale;
      62           0 :     uint32_t hi = ((a00 >> 8) & mask) * scale;
      63             : 
      64           0 :     scale = 16*x - xy;
      65           0 :     lo += (a01 & mask) * scale;
      66           0 :     hi += ((a01 >> 8) & mask) * scale;
      67             : 
      68           0 :     scale = 16*y - xy;
      69           0 :     lo += (a10 & mask) * scale;
      70           0 :     hi += ((a10 >> 8) & mask) * scale;
      71             : 
      72           0 :     lo += (a11 & mask) * xy;
      73           0 :     hi += ((a11 >> 8) & mask) * xy;
      74             : 
      75           0 :     lo = ((lo >> 8) & mask) * alphaScale;
      76           0 :     hi = ((hi >> 8) & mask) * alphaScale;
      77             : 
      78           0 :     *dstColor = ((lo >> 8) & mask) | (hi & ~mask);
      79           0 : }
      80             : 
      81             : // Two color version, where we filter only along 1 axis
      82         380 : static inline void Filter_32_opaque(unsigned t,
      83             :                                     SkPMColor color0,
      84             :                                     SkPMColor color1,
      85             :                                     SkPMColor* dstColor) {
      86         380 :     SkASSERT((unsigned)t <= 0xF);
      87             : 
      88         380 :     const uint32_t mask = 0xFF00FF;
      89             : 
      90         380 :     int scale = 256 - 16*t;
      91         380 :     uint32_t lo = (color0 & mask) * scale;
      92         380 :     uint32_t hi = ((color0 >> 8) & mask) * scale;
      93             : 
      94         380 :     scale = 16*t;
      95         380 :     lo += (color1 & mask) * scale;
      96         380 :     hi += ((color1 >> 8) & mask) * scale;
      97             : 
      98         380 :     *dstColor = ((lo >> 8) & mask) | (hi & ~mask);
      99         380 : }
     100             : 
     101             : // Two color version, where we filter only along 1 axis
     102           0 : static inline void Filter_32_alpha(unsigned t,
     103             :                                    SkPMColor color0,
     104             :                                    SkPMColor color1,
     105             :                                    SkPMColor* dstColor,
     106             :                                    unsigned alphaScale) {
     107           0 :     SkASSERT((unsigned)t <= 0xF);
     108           0 :     SkASSERT(alphaScale <= 256);
     109             : 
     110           0 :     const uint32_t mask = 0xFF00FF;
     111             : 
     112           0 :     int scale = 256 - 16*t;
     113           0 :     uint32_t lo = (color0 & mask) * scale;
     114           0 :     uint32_t hi = ((color0 >> 8) & mask) * scale;
     115             : 
     116           0 :     scale = 16*t;
     117           0 :     lo += (color1 & mask) * scale;
     118           0 :     hi += ((color1 >> 8) & mask) * scale;
     119             : 
     120           0 :     lo = ((lo >> 8) & mask) * alphaScale;
     121           0 :     hi = ((hi >> 8) & mask) * alphaScale;
     122             : 
     123           0 :     *dstColor = ((lo >> 8) & mask) | (hi & ~mask);
     124           0 : }