1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "CanvasTransform.h"
18
19 #include <SkAndroidFrameworkUtils.h>
20 #include <SkBlendMode.h>
21 #include <SkColorFilter.h>
22 #include <SkGradientShader.h>
23 #include <SkHighContrastFilter.h>
24 #include <SkPaint.h>
25 #include <SkShader.h>
26 #include <log/log.h>
27
28 #include <algorithm>
29 #include <cmath>
30
31 #include "Properties.h"
32 #include "utils/Color.h"
33
34 namespace android::uirenderer {
35
makeLight(SkColor color)36 SkColor makeLight(SkColor color) {
37 Lab lab = sRGBToLab(color);
38 float invertedL = std::min(110 - lab.L, 100.0f);
39 if (invertedL > lab.L) {
40 lab.L = invertedL;
41 return LabToSRGB(lab, SkColorGetA(color));
42 } else {
43 return color;
44 }
45 }
46
makeDark(SkColor color)47 SkColor makeDark(SkColor color) {
48 Lab lab = sRGBToLab(color);
49 float invertedL = std::min(110 - lab.L, 100.0f);
50 if (invertedL < lab.L) {
51 lab.L = invertedL;
52 return LabToSRGB(lab, SkColorGetA(color));
53 } else {
54 return color;
55 }
56 }
57
invert(SkColor color)58 SkColor invert(SkColor color) {
59 Lab lab = sRGBToLab(color);
60 lab.L = 100 - lab.L;
61 return LabToSRGB(lab, SkColorGetA(color));
62 }
63
transformColor(ColorTransform transform,SkColor color)64 SkColor transformColor(ColorTransform transform, SkColor color) {
65 switch (transform) {
66 case ColorTransform::Light:
67 return makeLight(color);
68 case ColorTransform::Dark:
69 return makeDark(color);
70 case ColorTransform::Invert:
71 return invert(color);
72 default:
73 return color;
74 }
75 }
76
transformColorInverse(ColorTransform transform,SkColor color)77 SkColor transformColorInverse(ColorTransform transform, SkColor color) {
78 switch (transform) {
79 case ColorTransform::Dark:
80 return makeLight(color);
81 case ColorTransform::Light:
82 return makeDark(color);
83 default:
84 return color;
85 }
86 }
87
applyColorTransform(ColorTransform transform,SkPaint & paint)88 static void applyColorTransform(ColorTransform transform, SkPaint& paint) {
89 if (transform == ColorTransform::None) return;
90
91 SkColor newColor = transformColor(transform, paint.getColor());
92 paint.setColor(newColor);
93
94 if (paint.getShader()) {
95 SkAndroidFrameworkUtils::LinearGradientInfo info;
96 std::array<SkColor, 10> _colorStorage;
97 std::array<SkScalar, _colorStorage.size()> _offsetStorage;
98 info.fColorCount = _colorStorage.size();
99 info.fColors = _colorStorage.data();
100 info.fColorOffsets = _offsetStorage.data();
101
102 if (SkAndroidFrameworkUtils::ShaderAsALinearGradient(paint.getShader(), &info) &&
103 info.fColorCount <= _colorStorage.size()) {
104 for (int i = 0; i < info.fColorCount; i++) {
105 info.fColors[i] = transformColor(transform, info.fColors[i]);
106 }
107 paint.setShader(SkGradientShader::MakeLinear(
108 info.fPoints, info.fColors, info.fColorOffsets, info.fColorCount,
109 info.fTileMode, info.fGradientFlags, nullptr));
110 } else {
111 if (transform == ColorTransform::Invert) {
112 // Since we're trying to invert every thing around this draw call, we invert
113 // the color of the draw call if we don't know what it is.
114 auto filter = SkHighContrastFilter::Make(
115 {/* grayscale= */ false,
116 SkHighContrastConfig::InvertStyle::kInvertLightness,
117 /* contrast= */ 0.0f});
118
119 if (paint.getColorFilter()) {
120 paint.setColorFilter(SkColorFilters::Compose(filter, paint.refColorFilter()));
121 } else {
122 paint.setColorFilter(filter);
123 }
124 return;
125 }
126 }
127 }
128
129 if (paint.getColorFilter()) {
130 SkBlendMode mode;
131 SkColor color;
132 // TODO: LRU this or something to avoid spamming new color mode filters
133 if (paint.getColorFilter()->asAColorMode(&color, &mode)) {
134 color = transformColor(transform, color);
135 paint.setColorFilter(SkColorFilters::Blend(color, mode));
136 }
137 }
138 }
139
paletteForColorHSV(SkColor color)140 static BitmapPalette paletteForColorHSV(SkColor color) {
141 float hsv[3];
142 SkColorToHSV(color, hsv);
143 return hsv[2] >= .5f ? BitmapPalette::Light : BitmapPalette::Dark;
144 }
145
filterPalette(const SkPaint * paint,BitmapPalette palette)146 static BitmapPalette filterPalette(const SkPaint* paint, BitmapPalette palette) {
147 if (palette == BitmapPalette::Unknown || !paint || !paint->getColorFilter()) {
148 return palette;
149 }
150
151 SkColor4f color = palette == BitmapPalette::Light ? SkColors::kWhite : SkColors::kBlack;
152 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
153 color = paint->getColorFilter()->filterColor4f(color, srgb.get(), srgb.get());
154 return paletteForColorHSV(color.toSkColor());
155 }
156
transformPaint(ColorTransform transform,SkPaint * paint)157 bool transformPaint(ColorTransform transform, SkPaint* paint) {
158 // TODO
159 applyColorTransform(transform, *paint);
160 return true;
161 }
162
transformPaint(ColorTransform transform,SkPaint * paint,BitmapPalette palette)163 bool transformPaint(ColorTransform transform, SkPaint* paint, BitmapPalette palette) {
164 bool shouldInvert = false;
165 if (transform == ColorTransform::Invert && palette != BitmapPalette::Colorful) {
166 // When the transform is Invert we invert any image that is not deemed "colorful",
167 // regardless of calculated image brightness.
168 shouldInvert = true;
169 }
170 palette = filterPalette(paint, palette);
171 if (palette == BitmapPalette::Light && transform == ColorTransform::Dark) {
172 shouldInvert = true;
173 }
174 if (palette == BitmapPalette::Dark && transform == ColorTransform::Light) {
175 shouldInvert = true;
176 }
177 if (shouldInvert) {
178 SkHighContrastConfig config;
179 config.fInvertStyle = SkHighContrastConfig::InvertStyle::kInvertLightness;
180 paint->setColorFilter(SkHighContrastFilter::Make(config)->makeComposed(paint->refColorFilter()));
181 }
182 return shouldInvert;
183 }
184
185 } // namespace android::uirenderer
186