LCOV - code coverage report
Current view: directory - gfx/skia/src/core - SkColor.cpp (source / functions) Found Hit Coverage
Test: app.info Lines: 62 0 0.0 %
Date: 2012-06-02 Functions: 7 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 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                 : #include "SkColor.h"
      11                 : #include "SkColorPriv.h"
      12                 : 
      13               0 : SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
      14               0 :     return SkPremultiplyARGBInline(a, r, g, b);
      15                 : }
      16                 : 
      17               0 : SkPMColor SkPreMultiplyColor(SkColor c) {
      18                 :     return SkPremultiplyARGBInline(SkColorGetA(c), SkColorGetR(c),
      19               0 :                                    SkColorGetG(c), SkColorGetB(c));
      20                 : }
      21                 : 
      22                 : ///////////////////////////////////////////////////////////////////////////////
      23                 : 
      24               0 : static inline SkScalar ByteToScalar(U8CPU x) {
      25               0 :     SkASSERT(x <= 255);
      26               0 :     return SkIntToScalar(x) / 255;
      27                 : }
      28                 : 
      29               0 : static inline SkScalar ByteDivToScalar(int numer, U8CPU denom) {
      30                 :     // cast to keep the answer signed
      31               0 :     return SkIntToScalar(numer) / (int)denom;
      32                 : }
      33                 : 
      34               0 : void SkRGBToHSV(U8CPU r, U8CPU g, U8CPU b, SkScalar hsv[3]) {
      35               0 :     SkASSERT(hsv);
      36                 : 
      37               0 :     unsigned min = SkMin32(r, SkMin32(g, b));
      38               0 :     unsigned max = SkMax32(r, SkMax32(g, b));
      39               0 :     unsigned delta = max - min;
      40                 : 
      41               0 :     SkScalar v = ByteToScalar(max);
      42               0 :     SkASSERT(v >= 0 && v <= SK_Scalar1);
      43                 : 
      44               0 :     if (0 == delta) { // we're a shade of gray
      45               0 :         hsv[0] = 0;
      46               0 :         hsv[1] = 0;
      47               0 :         hsv[2] = v;
      48               0 :         return;
      49                 :     }
      50                 : 
      51               0 :     SkScalar s = ByteDivToScalar(delta, max);
      52               0 :     SkASSERT(s >= 0 && s <= SK_Scalar1);
      53                 : 
      54                 :     SkScalar h;    
      55               0 :     if (r == max) {
      56               0 :         h = ByteDivToScalar(g - b, delta);
      57               0 :     } else if (g == max) {
      58               0 :         h = SkIntToScalar(2) + ByteDivToScalar(b - r, delta);
      59                 :     } else { // b == max
      60               0 :         h = SkIntToScalar(4) + ByteDivToScalar(r - g, delta);
      61                 :     }
      62                 : 
      63               0 :     h *= 60;
      64               0 :     if (h < 0) {
      65               0 :         h += SkIntToScalar(360);
      66                 :     }
      67               0 :     SkASSERT(h >= 0 && h < SkIntToScalar(360));
      68                 : 
      69               0 :     hsv[0] = h;
      70               0 :     hsv[1] = s;
      71               0 :     hsv[2] = v;
      72                 : }
      73                 : 
      74               0 : static inline U8CPU UnitScalarToByte(SkScalar x) {
      75               0 :     if (x < 0) {
      76               0 :         return 0;
      77                 :     }
      78               0 :     if (x >= SK_Scalar1) {
      79               0 :         return 255;
      80                 :     }
      81               0 :     return SkScalarToFixed(x) >> 8;
      82                 : }
      83                 : 
      84               0 : SkColor SkHSVToColor(U8CPU a, const SkScalar hsv[3]) {
      85               0 :     SkASSERT(hsv);
      86                 : 
      87               0 :     U8CPU s = UnitScalarToByte(hsv[1]);
      88               0 :     U8CPU v = UnitScalarToByte(hsv[2]);
      89                 : 
      90               0 :     if (0 == s) { // shade of gray
      91               0 :         return SkColorSetARGB(a, v, v, v);
      92                 :     }
      93               0 :     SkFixed hx = (hsv[0] < 0 || hsv[0] >= SkIntToScalar(360)) ? 0 : SkScalarToFixed(hsv[0]/60);
      94               0 :     SkFixed f = hx & 0xFFFF;
      95                 :     
      96               0 :     unsigned v_scale = SkAlpha255To256(v);
      97               0 :     unsigned p = SkAlphaMul(255 - s, v_scale);
      98               0 :     unsigned q = SkAlphaMul(255 - (s * f >> 16), v_scale);
      99               0 :     unsigned t = SkAlphaMul(255 - (s * (SK_Fixed1 - f) >> 16), v_scale);
     100                 :     
     101                 :     unsigned r, g, b;
     102                 : 
     103               0 :     SkASSERT((unsigned)(hx >> 16) < 6);
     104               0 :     switch (hx >> 16) {
     105               0 :         case 0: r = v; g = t; b = p; break;
     106               0 :         case 1: r = q; g = v; b = p; break;
     107               0 :         case 2: r = p; g = v; b = t; break;
     108               0 :         case 3: r = p; g = q; b = v; break;
     109               0 :         case 4: r = t;  g = p; b = v; break;
     110               0 :         default: r = v; g = p; b = q; break;
     111                 :     }
     112               0 :     return SkColorSetARGB(a, r, g, b);
     113                 : }
     114                 : 

Generated by: LCOV version 1.7