Color.cpp revision 81bc750723a18f21cd17d1b173cd2a4dda9cea6e 
1/*
2 * Copyright (C) 2003, 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#include "config.h"
27#include "Color.h"
28
29#include "HashTools.h"
30#include "PlatformString.h"
31#include <math.h>
32#include <wtf/Assertions.h>
33#include <wtf/MathExtras.h>
34
35using namespace std;
36using namespace WTF;
37
38namespace WebCore {
39
40#if !COMPILER(MSVC)
41const RGBA32 Color::black;
42const RGBA32 Color::white;
43const RGBA32 Color::darkGray;
44const RGBA32 Color::gray;
45const RGBA32 Color::lightGray;
46const RGBA32 Color::transparent;
47#endif
48
49static const RGBA32 lightenedBlack = 0xFF545454;
50static const RGBA32 darkenedWhite = 0xFFABABAB;
51
52RGBA32 makeRGB(int r, int g, int b)
53{
54    return 0xFF000000 | max(0, min(r, 255)) << 16 | max(0, min(g, 255)) << 8 | max(0, min(b, 255));
55}
56
57RGBA32 makeRGBA(int r, int g, int b, int a)
58{
59    return max(0, min(a, 255)) << 24 | max(0, min(r, 255)) << 16 | max(0, min(g, 255)) << 8 | max(0, min(b, 255));
60}
61
62static int colorFloatToRGBAByte(float f)
63{
64    // We use lroundf and 255 instead of nextafterf(256, 0) to match CG's rounding
65    return max(0, min(static_cast<int>(lroundf(255.0f * f)), 255));
66}
67
68RGBA32 makeRGBA32FromFloats(float r, float g, float b, float a)
69{
70    return colorFloatToRGBAByte(a) << 24 | colorFloatToRGBAByte(r) << 16 | colorFloatToRGBAByte(g) << 8 | colorFloatToRGBAByte(b);
71}
72
73RGBA32 colorWithOverrideAlpha(RGBA32 color, float overrideAlpha)
74{
75    RGBA32 rgbOnly = color & 0x00FFFFFF;
76    RGBA32 rgba = rgbOnly | colorFloatToRGBAByte(overrideAlpha) << 24;
77    return rgba;
78}
79
80static double calcHue(double temp1, double temp2, double hueVal)
81{
82    if (hueVal < 0.0)
83        hueVal++;
84    else if (hueVal > 1.0)
85        hueVal--;
86    if (hueVal * 6.0 < 1.0)
87        return temp1 + (temp2 - temp1) * hueVal * 6.0;
88    if (hueVal * 2.0 < 1.0)
89        return temp2;
90    if (hueVal * 3.0 < 2.0)
91        return temp1 + (temp2 - temp1) * (2.0 / 3.0 - hueVal) * 6.0;
92    return temp1;
93}
94
95// Explanation of this algorithm can be found in the CSS3 Color Module
96// specification at http://www.w3.org/TR/css3-color/#hsl-color with further
97// explanation available at http://en.wikipedia.org/wiki/HSL_color_space
98
99// all values are in the range of 0 to 1.0
100RGBA32 makeRGBAFromHSLA(double hue, double saturation, double lightness, double alpha)
101{
102    const double scaleFactor = nextafter(256.0, 0.0);
103
104    if (!saturation) {
105        int greyValue = static_cast<int>(lightness * scaleFactor);
106        return makeRGBA(greyValue, greyValue, greyValue, static_cast<int>(alpha * scaleFactor));
107    }
108
109    double temp2 = lightness < 0.5 ? lightness * (1.0 + saturation) : lightness + saturation - lightness * saturation;
110    double temp1 = 2.0 * lightness - temp2;
111
112    return makeRGBA(static_cast<int>(calcHue(temp1, temp2, hue + 1.0 / 3.0) * scaleFactor),
113                    static_cast<int>(calcHue(temp1, temp2, hue) * scaleFactor),
114                    static_cast<int>(calcHue(temp1, temp2, hue - 1.0 / 3.0) * scaleFactor),
115                    static_cast<int>(alpha * scaleFactor));
116}
117
118RGBA32 makeRGBAFromCMYKA(float c, float m, float y, float k, float a)
119{
120    double colors = 1 - k;
121    int r = static_cast<int>(nextafter(256, 0) * (colors * (1 - c)));
122    int g = static_cast<int>(nextafter(256, 0) * (colors * (1 - m)));
123    int b = static_cast<int>(nextafter(256, 0) * (colors * (1 - y)));
124    return makeRGBA(r, g, b, static_cast<float>(nextafter(256, 0) * a));
125}
126
127// originally moved here from the CSS parser
128bool Color::parseHexColor(const UChar* name, unsigned length, RGBA32& rgb)
129{
130    if (length != 3 && length != 6)
131        return false;
132    unsigned value = 0;
133    for (unsigned i = 0; i < length; ++i) {
134        if (!isASCIIHexDigit(name[i]))
135            return false;
136        value <<= 4;
137        value |= toASCIIHexValue(name[i]);
138    }
139    if (length == 6) {
140        rgb = 0xFF000000 | value;
141        return true;
142    }
143    // #abc converts to #aabbcc
144    rgb = 0xFF000000
145        | (value & 0xF00) << 12 | (value & 0xF00) << 8
146        | (value & 0xF0) << 8 | (value & 0xF0) << 4
147        | (value & 0xF) << 4 | (value & 0xF);
148    return true;
149}
150
151bool Color::parseHexColor(const String& name, RGBA32& rgb)
152{
153    return parseHexColor(name.characters(), name.length(), rgb);
154}
155
156int differenceSquared(const Color& c1, const Color& c2)
157{
158    int dR = c1.red() - c2.red();
159    int dG = c1.green() - c2.green();
160    int dB = c1.blue() - c2.blue();
161    return dR * dR + dG * dG + dB * dB;
162}
163
164Color::Color(const String& name)
165{
166    if (name[0] == '#')
167        m_valid = parseHexColor(name.characters() + 1, name.length() - 1, m_color);
168    else
169        setNamedColor(name);
170}
171
172Color::Color(const char* name)
173{
174    if (name[0] == '#')
175        m_valid = parseHexColor(&name[1], m_color);
176    else {
177        const NamedColor* foundColor = findColor(name, strlen(name));
178        m_color = foundColor ? foundColor->ARGBValue : 0;
179        m_valid = foundColor;
180    }
181}
182
183static inline void appendHexNumber(UChar* destination, uint8_t number)
184{
185    static const char hexDigits[17] = "0123456789abcdef";
186
187    destination[0] = hexDigits[number >> 4];
188    destination[1] = hexDigits[number & 0xF];
189}
190
191String Color::serialized() const
192{
193    DEFINE_STATIC_LOCAL(const String, commaSpace, (", "));
194    DEFINE_STATIC_LOCAL(const String, rgbaParen, ("rgba("));
195    DEFINE_STATIC_LOCAL(const String, zeroPointZero, ("0.0"));
196
197    if (!hasAlpha()) {
198        UChar* characters;
199        String result = String::createUninitialized(7, characters);
200        characters[0] = '#';
201        appendHexNumber(characters + 1, red());
202        appendHexNumber(characters + 3, green());
203        appendHexNumber(characters + 5, blue());
204        return result;
205    }
206
207    Vector<UChar> result;
208    result.reserveInitialCapacity(28);
209
210    append(result, rgbaParen);
211    appendNumber(result, red());
212    append(result, commaSpace);
213    appendNumber(result, green());
214    append(result, commaSpace);
215    appendNumber(result, blue());
216    append(result, commaSpace);
217
218    // Match Gecko ("0.0" for zero, 5 decimals for anything else)
219    if (!alpha())
220        append(result, zeroPointZero);
221    else
222        append(result, String::format("%.5f", alpha() / 255.0f));
223
224    result.append(')');
225    return String::adopt(result);
226}
227
228String Color::nameForRenderTreeAsText() const
229{
230    if (alpha() < 0xFF)
231        return String::format("#%02X%02X%02X%02X", red(), green(), blue(), alpha());
232    return String::format("#%02X%02X%02X", red(), green(), blue());
233}
234
235static inline const NamedColor* findNamedColor(const String& name)
236{
237    char buffer[64]; // easily big enough for the longest color name
238    unsigned length = name.length();
239    if (length > sizeof(buffer) - 1)
240        return 0;
241    for (unsigned i = 0; i < length; ++i) {
242        UChar c = name[i];
243        if (!c || c > 0x7F)
244            return 0;
245        buffer[i] = toASCIILower(static_cast<char>(c));
246    }
247    buffer[length] = '\0';
248    return findColor(buffer, length);
249}
250
251void Color::setNamedColor(const String& name)
252{
253    const NamedColor* foundColor = findNamedColor(name);
254    m_color = foundColor ? foundColor->ARGBValue : 0;
255    m_valid = foundColor;
256}
257
258Color Color::light() const
259{
260    // Hardcode this common case for speed.
261    if (m_color == black)
262        return lightenedBlack;
263
264    const float scaleFactor = nextafterf(256.0f, 0.0f);
265
266    float r, g, b, a;
267    getRGBA(r, g, b, a);
268
269    float v = max(r, max(g, b));
270
271    if (v == 0.0f)
272        // Lightened black with alpha.
273        return Color(0x54, 0x54, 0x54, alpha());
274
275    float multiplier = min(1.0f, v + 0.33f) / v;
276
277    return Color(static_cast<int>(multiplier * r * scaleFactor),
278                 static_cast<int>(multiplier * g * scaleFactor),
279                 static_cast<int>(multiplier * b * scaleFactor),
280                 alpha());
281}
282
283Color Color::dark() const
284{
285    // Hardcode this common case for speed.
286    if (m_color == white)
287        return darkenedWhite;
288
289    const float scaleFactor = nextafterf(256.0f, 0.0f);
290
291    float r, g, b, a;
292    getRGBA(r, g, b, a);
293
294    float v = max(r, max(g, b));
295    float multiplier = max(0.0f, (v - 0.33f) / v);
296
297    return Color(static_cast<int>(multiplier * r * scaleFactor),
298                 static_cast<int>(multiplier * g * scaleFactor),
299                 static_cast<int>(multiplier * b * scaleFactor),
300                 alpha());
301}
302
303static int blendComponent(int c, int a)
304{
305    // We use white.
306    float alpha = a / 255.0f;
307    int whiteBlend = 255 - a;
308    c -= whiteBlend;
309    return static_cast<int>(c / alpha);
310}
311
312const int cStartAlpha = 153; // 60%
313const int cEndAlpha = 204; // 80%;
314const int cAlphaIncrement = 17; // Increments in between.
315
316Color Color::blend(const Color& source) const
317{
318    if (!alpha() || !source.hasAlpha())
319        return source;
320
321    if (!source.alpha())
322        return *this;
323
324    int d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
325    int a = d / 255;
326    int r = (red() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.red()) / d;
327    int g = (green() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.green()) / d;
328    int b = (blue() * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source.blue()) / d;
329    return Color(r, g, b, a);
330}
331
332Color Color::blendWithWhite() const
333{
334    // If the color contains alpha already, we leave it alone.
335    if (hasAlpha())
336        return *this;
337
338    Color newColor;
339    for (int alpha = cStartAlpha; alpha <= cEndAlpha; alpha += cAlphaIncrement) {
340        // We have a solid color.  Convert to an equivalent color that looks the same when blended with white
341        // at the current alpha.  Try using less transparency if the numbers end up being negative.
342        int r = blendComponent(red(), alpha);
343        int g = blendComponent(green(), alpha);
344        int b = blendComponent(blue(), alpha);
345
346        newColor = Color(r, g, b, alpha);
347
348        if (r >= 0 && g >= 0 && b >= 0)
349            break;
350    }
351    return newColor;
352}
353
354void Color::getRGBA(float& r, float& g, float& b, float& a) const
355{
356    r = red() / 255.0f;
357    g = green() / 255.0f;
358    b = blue() / 255.0f;
359    a = alpha() / 255.0f;
360}
361
362void Color::getRGBA(double& r, double& g, double& b, double& a) const
363{
364    r = red() / 255.0;
365    g = green() / 255.0;
366    b = blue() / 255.0;
367    a = alpha() / 255.0;
368}
369
370void Color::getHSL(double& hue, double& saturation, double& lightness) const
371{
372    // http://en.wikipedia.org/wiki/HSL_color_space. This is a direct copy of
373    // the algorithm therein, although it's 360^o based and we end up wanting
374    // [0...1) based. It's clearer if we stick to 360^o until the end.
375    double r = static_cast<double>(red()) / 255.0;
376    double g = static_cast<double>(green()) / 255.0;
377    double b = static_cast<double>(blue()) / 255.0;
378    double max = std::max(std::max(r, g), b);
379    double min = std::min(std::min(r, g), b);
380
381    if (max == min)
382        hue = 0.0;
383    else if (max == r)
384        hue = (60.0 * ((g - b) / (max - min))) + 360.0;
385    else if (max == g)
386        hue = (60.0 * ((b - r) / (max - min))) + 120.0;
387    else
388        hue = (60.0 * ((r - g) / (max - min))) + 240.0;
389
390    if (hue >= 360.0)
391        hue -= 360.0;
392
393    // makeRGBAFromHSLA assumes that hue is in [0...1).
394    hue /= 360.0;
395
396    lightness = 0.5 * (max + min);
397    if (max == min)
398        saturation = 0.0;
399    else if (lightness <= 0.5)
400        saturation = ((max - min) / (max + min));
401    else
402        saturation = ((max - min) / (2.0 - (max + min)));
403}
404
405Color colorFromPremultipliedARGB(unsigned pixelColor)
406{
407    RGBA32 rgba;
408
409    if (unsigned alpha = (pixelColor & 0xFF000000) >> 24) {
410        rgba = makeRGBA(((pixelColor & 0x00FF0000) >> 16) * 255 / alpha,
411                        ((pixelColor & 0x0000FF00) >> 8) * 255 / alpha,
412                         (pixelColor & 0x000000FF) * 255 / alpha,
413                          alpha);
414    } else
415        rgba = pixelColor;
416
417    return Color(rgba);
418}
419
420unsigned premultipliedARGBFromColor(const Color& color)
421{
422    unsigned pixelColor;
423
424    if (unsigned alpha = color.alpha()) {
425        pixelColor = alpha << 24 |
426             ((color.red() * alpha  + 254) / 255) << 16 |
427             ((color.green() * alpha  + 254) / 255) << 8 |
428             ((color.blue() * alpha  + 254) / 255);
429    } else
430         pixelColor = color.rgb();
431
432    return pixelColor;
433}
434
435} // namespace WebCore
436