00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017 #ifndef SkDither_DEFINED
00018 #define SkDither_DEFINED
00019
00020 #include "SkColorPriv.h"
00021
00022 #define SK_DitherValueMax4444 15
00023 #define SK_DitherValueMax565 7
00024
00025
00026
00027
00028
00029 #define SkDITHER_R32_FOR_565_MACRO(r, d) (r + d - (r >> 5))
00030 #define SkDITHER_G32_FOR_565_MACRO(g, d) (g + (d >> 1) - (g >> 6))
00031 #define SkDITHER_B32_FOR_565_MACRO(b, d) (b + d - (b >> 5))
00032
00033 #define SkDITHER_A32_FOR_4444_MACRO(a, d) (a + 15 - (a >> 4))
00034 #define SkDITHER_R32_FOR_4444_MACRO(r, d) (r + d - (r >> 4))
00035 #define SkDITHER_G32_FOR_4444_MACRO(g, d) (g + d - (g >> 4))
00036 #define SkDITHER_B32_FOR_4444_MACRO(b, d) (b + d - (b >> 4))
00037
00038 #ifdef SK_DEBUG
00039 inline unsigned SkDITHER_R32_FOR_565(unsigned r, unsigned d)
00040 {
00041 SkASSERT(d <= SK_DitherValueMax565);
00042 SkA32Assert(r);
00043 r = SkDITHER_R32_FOR_565_MACRO(r, d);
00044 SkA32Assert(r);
00045 return r;
00046 }
00047 inline unsigned SkDITHER_G32_FOR_565(unsigned g, unsigned d)
00048 {
00049 SkASSERT(d <= SK_DitherValueMax565);
00050 SkG32Assert(g);
00051 g = SkDITHER_G32_FOR_565_MACRO(g, d);
00052 SkG32Assert(g);
00053 return g;
00054 }
00055 inline unsigned SkDITHER_B32_FOR_565(unsigned b, unsigned d)
00056 {
00057 SkASSERT(d <= SK_DitherValueMax565);
00058 SkB32Assert(b);
00059 b = SkDITHER_B32_FOR_565_MACRO(b, d);
00060 SkB32Assert(b);
00061 return b;
00062 }
00063 #else
00064 #define SkDITHER_R32_FOR_565(r, d) SkDITHER_R32_FOR_565_MACRO(r, d)
00065 #define SkDITHER_G32_FOR_565(g, d) SkDITHER_G32_FOR_565_MACRO(g, d)
00066 #define SkDITHER_B32_FOR_565(b, d) SkDITHER_B32_FOR_565_MACRO(b, d)
00067 #endif
00068
00069 #define SkDITHER_R32To565(r, d) SkR32ToR16(SkDITHER_R32_FOR_565(r, d))
00070 #define SkDITHER_G32To565(g, d) SkG32ToG16(SkDITHER_G32_FOR_565(g, d))
00071 #define SkDITHER_B32To565(b, d) SkB32ToB16(SkDITHER_B32_FOR_565(b, d))
00072
00073 #define SkDITHER_A32To4444(a, d) SkA32To4444(SkDITHER_A32_FOR_4444_MACRO(a, d))
00074 #define SkDITHER_R32To4444(r, d) SkR32To4444(SkDITHER_R32_FOR_4444_MACRO(r, d))
00075 #define SkDITHER_G32To4444(g, d) SkG32To4444(SkDITHER_G32_FOR_4444_MACRO(g, d))
00076 #define SkDITHER_B32To4444(b, d) SkB32To4444(SkDITHER_B32_FOR_4444_MACRO(b, d))
00077
00078 static inline SkPMColor SkDitherARGB32For565(SkPMColor c, unsigned dither)
00079 {
00080 SkASSERT(dither <= SK_DitherValueMax565);
00081
00082 unsigned sa = SkGetPackedA32(c);
00083 dither = SkAlphaMul(dither, SkAlpha255To256(sa));
00084
00085 unsigned sr = SkGetPackedR32(c);
00086 unsigned sg = SkGetPackedG32(c);
00087 unsigned sb = SkGetPackedB32(c);
00088 sr = SkDITHER_R32_FOR_565(sr, dither);
00089 sg = SkDITHER_G32_FOR_565(sg, dither);
00090 sb = SkDITHER_B32_FOR_565(sb, dither);
00091
00092 return SkPackARGB32(sa, sr, sg, sb);
00093 }
00094
00095 static inline SkPMColor SkDitherRGB32For565(SkPMColor c, unsigned dither)
00096 {
00097 SkASSERT(dither <= SK_DitherValueMax565);
00098
00099 unsigned sr = SkGetPackedR32(c);
00100 unsigned sg = SkGetPackedG32(c);
00101 unsigned sb = SkGetPackedB32(c);
00102 sr = SkDITHER_R32_FOR_565(sr, dither);
00103 sg = SkDITHER_G32_FOR_565(sg, dither);
00104 sb = SkDITHER_B32_FOR_565(sb, dither);
00105
00106 return SkPackARGB32(0xFF, sr, sg, sb);
00107 }
00108
00109 static inline uint16_t SkDitherRGBTo565(U8CPU r, U8CPU g, U8CPU b,
00110 unsigned dither)
00111 {
00112 SkASSERT(dither <= SK_DitherValueMax565);
00113 r = SkDITHER_R32To565(r, dither);
00114 g = SkDITHER_G32To565(g, dither);
00115 b = SkDITHER_B32To565(b, dither);
00116 return SkPackRGB16(r, g, b);
00117 }
00118
00119 static inline uint16_t SkDitherRGB32To565(SkPMColor c, unsigned dither)
00120 {
00121 SkASSERT(dither <= SK_DitherValueMax565);
00122
00123 unsigned sr = SkGetPackedR32(c);
00124 unsigned sg = SkGetPackedG32(c);
00125 unsigned sb = SkGetPackedB32(c);
00126 sr = SkDITHER_R32To565(sr, dither);
00127 sg = SkDITHER_G32To565(sg, dither);
00128 sb = SkDITHER_B32To565(sb, dither);
00129
00130 return SkPackRGB16(sr, sg, sb);
00131 }
00132
00133 static inline uint16_t SkDitherARGB32To565(U8CPU sa, SkPMColor c, unsigned dither)
00134 {
00135 SkASSERT(dither <= SK_DitherValueMax565);
00136 dither = SkAlphaMul(dither, SkAlpha255To256(sa));
00137
00138 unsigned sr = SkGetPackedR32(c);
00139 unsigned sg = SkGetPackedG32(c);
00140 unsigned sb = SkGetPackedB32(c);
00141 sr = SkDITHER_R32To565(sr, dither);
00142 sg = SkDITHER_G32To565(sg, dither);
00143 sb = SkDITHER_B32To565(sb, dither);
00144
00145 return SkPackRGB16(sr, sg, sb);
00146 }
00147
00149
00150 static inline SkPMColor16 SkDitherARGB32To4444(U8CPU a, U8CPU r, U8CPU g,
00151 U8CPU b, unsigned dither)
00152 {
00153 dither = SkAlphaMul(dither, SkAlpha255To256(a));
00154
00155 a = SkDITHER_A32To4444(a, dither);
00156 r = SkDITHER_R32To4444(r, dither);
00157 g = SkDITHER_G32To4444(g, dither);
00158 b = SkDITHER_B32To4444(b, dither);
00159
00160 return SkPackARGB4444(a, r, g, b);
00161 }
00162
00163 static inline SkPMColor16 SkDitherARGB32To4444(SkPMColor c, unsigned dither)
00164 {
00165 unsigned a = SkGetPackedA32(c);
00166 unsigned r = SkGetPackedR32(c);
00167 unsigned g = SkGetPackedG32(c);
00168 unsigned b = SkGetPackedB32(c);
00169
00170 dither = SkAlphaMul(dither, SkAlpha255To256(a));
00171
00172 a = SkDITHER_A32To4444(a, dither);
00173 r = SkDITHER_R32To4444(r, dither);
00174 g = SkDITHER_G32To4444(g, dither);
00175 b = SkDITHER_B32To4444(b, dither);
00176
00177 return SkPackARGB4444(a, r, g, b);
00178 }
00179
00180
00181
00182
00183
00184
00185 #ifdef ENABLE_DITHER_MATRIX_4X4
00186 extern const uint8_t gDitherMatrix_4Bit_4X4[4][4];
00187 extern const uint8_t gDitherMatrix_3Bit_4X4[4][4];
00188
00189 #define DITHER_4444_SCAN(y) const uint8_t* dither_scan = gDitherMatrix_4Bit_4X4[(y) & 3]
00190 #define DITHER_565_SCAN(y) const uint8_t* dither_scan = gDitherMatrix_3Bit_4X4[(y) & 3]
00191
00192 #define DITHER_VALUE(x) dither_scan[(x) & 3]
00193 #else
00194 extern const uint16_t gDitherMatrix_4Bit_16[4];
00195 extern const uint16_t gDitherMatrix_3Bit_16[4];
00196
00197 #define DITHER_4444_SCAN(y) const uint16_t dither_scan = gDitherMatrix_4Bit_16[(y) & 3]
00198 #define DITHER_565_SCAN(y) const uint16_t dither_scan = gDitherMatrix_3Bit_16[(y) & 3]
00199
00200 #define DITHER_VALUE(x) ((dither_scan >> (((x) & 3) << 2)) & 0xF)
00201 #endif
00202
00203 #define DITHER_INC_X(x) ++(x)
00204
00205 #endif