LCOV - app.info - gfx/skia/include/core/SkDither.h

LCOV - code coverage report
| Current view: | directory - gfx/skia/include/core - SkDither.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 38 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 5 | 0 | 0.0 %

           1                 :
           2                 : /*
           3                 :  * Copyright 2008 The Android Open Source Project
           4                 :  *
           5                 :  * Use of this source code is governed by a BSD-style license that can be
           6                 :  * found in the LICENSE file.
           7                 :  */
           8                 :
           9                 :
          10                 : #ifndef SkDither_DEFINED
          11                 : #define SkDither_DEFINED
          12                 :
          13                 : #include "SkColorPriv.h"
          14                 :
          15                 : #define SK_DitherValueMax4444   15
          16                 : #define SK_DitherValueMax565    7
          17                 :
          18                 : /*  need to use macros for bit-counts for each component, and then
          19                 :     move these into SkColorPriv.h
          20                 : */
          21                 :
          22                 : #define SkDITHER_R32_FOR_565_MACRO(r, d)    (r + d - (r >> 5))
          23                 : #define SkDITHER_G32_FOR_565_MACRO(g, d)    (g + (d >> 1) - (g >> 6))
          24                 : #define SkDITHER_B32_FOR_565_MACRO(b, d)    (b + d - (b >> 5))
          25                 :
          26                 : #define SkDITHER_A32_FOR_4444_MACRO(a, d)    (a + 15 - (a >> 4))
          27                 : #define SkDITHER_R32_FOR_4444_MACRO(r, d)    (r + d - (r >> 4))
          28                 : #define SkDITHER_G32_FOR_4444_MACRO(g, d)    (g + d - (g >> 4))
          29                 : #define SkDITHER_B32_FOR_4444_MACRO(b, d)    (b + d - (b >> 4))
          30                 :
          31                 : #ifdef SK_DEBUG
          32               0 :     inline unsigned SkDITHER_R32_FOR_565(unsigned r, unsigned d)
          33                 :     {
          34               0 :         SkASSERT(d <= SK_DitherValueMax565);
          35               0 :         SkA32Assert(r);
          36               0 :         r = SkDITHER_R32_FOR_565_MACRO(r, d);
          37               0 :         SkA32Assert(r);
          38               0 :         return r;
          39                 :     }
          40               0 :     inline unsigned SkDITHER_G32_FOR_565(unsigned g, unsigned d)
          41                 :     {
          42               0 :         SkASSERT(d <= SK_DitherValueMax565);
          43               0 :         SkG32Assert(g);
          44               0 :         g = SkDITHER_G32_FOR_565_MACRO(g, d);
          45               0 :         SkG32Assert(g);
          46               0 :         return g;
          47                 :     }
          48               0 :     inline unsigned SkDITHER_B32_FOR_565(unsigned b, unsigned d)
          49                 :     {
          50               0 :         SkASSERT(d <= SK_DitherValueMax565);
          51               0 :         SkB32Assert(b);
          52               0 :         b = SkDITHER_B32_FOR_565_MACRO(b, d);
          53               0 :         SkB32Assert(b);
          54               0 :         return b;
          55                 :     }
          56                 : #else
          57                 :     #define SkDITHER_R32_FOR_565(r, d)  SkDITHER_R32_FOR_565_MACRO(r, d)
          58                 :     #define SkDITHER_G32_FOR_565(g, d)  SkDITHER_G32_FOR_565_MACRO(g, d)
          59                 :     #define SkDITHER_B32_FOR_565(b, d)  SkDITHER_B32_FOR_565_MACRO(b, d)
          60                 : #endif
          61                 :
          62                 : #define SkDITHER_R32To565(r, d)  SkR32ToR16(SkDITHER_R32_FOR_565(r, d))
          63                 : #define SkDITHER_G32To565(g, d)  SkG32ToG16(SkDITHER_G32_FOR_565(g, d))
          64                 : #define SkDITHER_B32To565(b, d)  SkB32ToB16(SkDITHER_B32_FOR_565(b, d))
          65                 :
          66                 : #define SkDITHER_A32To4444(a, d)  SkA32To4444(SkDITHER_A32_FOR_4444_MACRO(a, d))
          67                 : #define SkDITHER_R32To4444(r, d)  SkR32To4444(SkDITHER_R32_FOR_4444_MACRO(r, d))
          68                 : #define SkDITHER_G32To4444(g, d)  SkG32To4444(SkDITHER_G32_FOR_4444_MACRO(g, d))
          69                 : #define SkDITHER_B32To4444(b, d)  SkB32To4444(SkDITHER_B32_FOR_4444_MACRO(b, d))
          70                 :
          71                 : static inline SkPMColor SkDitherARGB32For565(SkPMColor c, unsigned dither)
          72                 : {
          73                 :     SkASSERT(dither <= SK_DitherValueMax565);
          74                 :
          75                 :     unsigned sa = SkGetPackedA32(c);
          76                 :     dither = SkAlphaMul(dither, SkAlpha255To256(sa));
          77                 :
          78                 :     unsigned sr = SkGetPackedR32(c);
          79                 :     unsigned sg = SkGetPackedG32(c);
          80                 :     unsigned sb = SkGetPackedB32(c);
          81                 :     sr = SkDITHER_R32_FOR_565(sr, dither);
          82                 :     sg = SkDITHER_G32_FOR_565(sg, dither);
          83                 :     sb = SkDITHER_B32_FOR_565(sb, dither);
          84                 :
          85                 :     return SkPackARGB32(sa, sr, sg, sb);
          86                 : }
          87                 :
          88                 : static inline SkPMColor SkDitherRGB32For565(SkPMColor c, unsigned dither)
          89                 : {
          90                 :     SkASSERT(dither <= SK_DitherValueMax565);
          91                 :
          92                 :     unsigned sr = SkGetPackedR32(c);
          93                 :     unsigned sg = SkGetPackedG32(c);
          94                 :     unsigned sb = SkGetPackedB32(c);
          95                 :     sr = SkDITHER_R32_FOR_565(sr, dither);
          96                 :     sg = SkDITHER_G32_FOR_565(sg, dither);
          97                 :     sb = SkDITHER_B32_FOR_565(sb, dither);
          98                 :
          99                 :     return SkPackARGB32(0xFF, sr, sg, sb);
         100                 : }
         101                 :
         102                 : static inline uint16_t SkDitherRGBTo565(U8CPU r, U8CPU g, U8CPU b,
         103                 :                                               unsigned dither)
         104                 : {
         105                 :     SkASSERT(dither <= SK_DitherValueMax565);
         106                 :     r = SkDITHER_R32To565(r, dither);
         107                 :     g = SkDITHER_G32To565(g, dither);
         108                 :     b = SkDITHER_B32To565(b, dither);
         109                 :     return SkPackRGB16(r, g, b);
         110                 : }
         111                 :
         112               0 : static inline uint16_t SkDitherRGB32To565(SkPMColor c, unsigned dither)
         113                 : {
         114               0 :     SkASSERT(dither <= SK_DitherValueMax565);
         115                 :
         116               0 :     unsigned sr = SkGetPackedR32(c);
         117               0 :     unsigned sg = SkGetPackedG32(c);
         118               0 :     unsigned sb = SkGetPackedB32(c);
         119               0 :     sr = SkDITHER_R32To565(sr, dither);
         120               0 :     sg = SkDITHER_G32To565(sg, dither);
         121               0 :     sb = SkDITHER_B32To565(sb, dither);
         122                 :
         123               0 :     return SkPackRGB16(sr, sg, sb);
         124                 : }
         125                 :
         126                 : static inline uint16_t SkDitherARGB32To565(U8CPU sa, SkPMColor c, unsigned dither)
         127                 : {
         128                 :     SkASSERT(dither <= SK_DitherValueMax565);
         129                 :     dither = SkAlphaMul(dither, SkAlpha255To256(sa));
         130                 :
         131                 :     unsigned sr = SkGetPackedR32(c);
         132                 :     unsigned sg = SkGetPackedG32(c);
         133                 :     unsigned sb = SkGetPackedB32(c);
         134                 :     sr = SkDITHER_R32To565(sr, dither);
         135                 :     sg = SkDITHER_G32To565(sg, dither);
         136                 :     sb = SkDITHER_B32To565(sb, dither);
         137                 :
         138                 :     return SkPackRGB16(sr, sg, sb);
         139                 : }
         140                 :
         141                 : ///////////////////////// 4444
         142                 :
         143                 : static inline SkPMColor16 SkDitherARGB32To4444(U8CPU a, U8CPU r, U8CPU g,
         144                 :                                                U8CPU b, unsigned dither)
         145                 : {
         146                 :     dither = SkAlphaMul(dither, SkAlpha255To256(a));
         147                 :
         148                 :     a = SkDITHER_A32To4444(a, dither);
         149                 :     r = SkDITHER_R32To4444(r, dither);
         150                 :     g = SkDITHER_G32To4444(g, dither);
         151                 :     b = SkDITHER_B32To4444(b, dither);
         152                 :
         153                 :     return SkPackARGB4444(a, r, g, b);
         154                 : }
         155                 :
         156               0 : static inline SkPMColor16 SkDitherARGB32To4444(SkPMColor c, unsigned dither)
         157                 : {
         158               0 :     unsigned a = SkGetPackedA32(c);
         159               0 :     unsigned r = SkGetPackedR32(c);
         160               0 :     unsigned g = SkGetPackedG32(c);
         161               0 :     unsigned b = SkGetPackedB32(c);
         162                 :
         163               0 :     dither = SkAlphaMul(dither, SkAlpha255To256(a));
         164                 :
         165               0 :     a = SkDITHER_A32To4444(a, dither);
         166               0 :     r = SkDITHER_R32To4444(r, dither);
         167               0 :     g = SkDITHER_G32To4444(g, dither);
         168               0 :     b = SkDITHER_B32To4444(b, dither);
         169                 :
         170               0 :     return SkPackARGB4444(a, r, g, b);
         171                 : }
         172                 :
         173                 : // TODO: need dither routines for 565 -> 4444
         174                 :
         175                 : // this toggles between a 4x4 and a 1x4 array
         176                 : //#define ENABLE_DITHER_MATRIX_4X4
         177                 :
         178                 : #ifdef ENABLE_DITHER_MATRIX_4X4
         179                 :     extern const uint8_t gDitherMatrix_4Bit_4X4[4][4];
         180                 :     extern const uint8_t gDitherMatrix_3Bit_4X4[4][4];
         181                 :
         182                 :     #define DITHER_4444_SCAN(y) const uint8_t* dither_scan = gDitherMatrix_4Bit_4X4[(y) & 3]
         183                 :     #define DITHER_565_SCAN(y)  const uint8_t* dither_scan = gDitherMatrix_3Bit_4X4[(y) & 3]
         184                 :
         185                 :     #define DITHER_VALUE(x) dither_scan[(x) & 3]
         186                 : #else
         187                 :     extern const uint16_t gDitherMatrix_4Bit_16[4];
         188                 :     extern const uint16_t gDitherMatrix_3Bit_16[4];
         189                 :
         190                 :     #define DITHER_4444_SCAN(y) const uint16_t dither_scan = gDitherMatrix_4Bit_16[(y) & 3]
         191                 :     #define DITHER_565_SCAN(y)  const uint16_t dither_scan = gDitherMatrix_3Bit_16[(y) & 3]
         192                 :
         193                 :     #define DITHER_VALUE(x) ((dither_scan >> (((x) & 3) << 2)) & 0xF)
         194                 : #endif
         195                 :
         196                 : #define DITHER_INC_X(x) ++(x)
         197                 :
         198                 : #endif

Generated by: LCOV version 1.7