1 /*
2 * Copyright 2015 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "include/codec/SkAndroidCodec.h"
9 #include "include/codec/SkCodec.h"
10 #include "include/core/SkPixmap.h"
11 #include "src/codec/SkAndroidCodecAdapter.h"
12 #include "src/codec/SkCodecPriv.h"
13 #include "src/codec/SkSampledCodec.h"
14 #include "src/core/SkPixmapPriv.h"
15
is_valid_sample_size(int sampleSize)16 static bool is_valid_sample_size(int sampleSize) {
17 // FIXME: As Leon has mentioned elsewhere, surely there is also a maximum sampleSize?
18 return sampleSize > 0;
19 }
20
21 /**
22 * Loads the gamut as a set of three points (triangle).
23 */
load_gamut(SkPoint rgb[],const skcms_Matrix3x3 & xyz)24 static void load_gamut(SkPoint rgb[], const skcms_Matrix3x3& xyz) {
25 // rx = rX / (rX + rY + rZ)
26 // ry = rY / (rX + rY + rZ)
27 // gx, gy, bx, and gy are calulcated similarly.
28 for (int rgbIdx = 0; rgbIdx < 3; rgbIdx++) {
29 float sum = xyz.vals[rgbIdx][0] + xyz.vals[rgbIdx][1] + xyz.vals[rgbIdx][2];
30 rgb[rgbIdx].fX = xyz.vals[rgbIdx][0] / sum;
31 rgb[rgbIdx].fY = xyz.vals[rgbIdx][1] / sum;
32 }
33 }
34
35 /**
36 * Calculates the area of the triangular gamut.
37 */
calculate_area(SkPoint abc[])38 static float calculate_area(SkPoint abc[]) {
39 SkPoint a = abc[0];
40 SkPoint b = abc[1];
41 SkPoint c = abc[2];
42 return 0.5f * SkTAbs(a.fX*b.fY + b.fX*c.fY - a.fX*c.fY - c.fX*b.fY - b.fX*a.fY);
43 }
44
45 static constexpr float kSRGB_D50_GamutArea = 0.084f;
46
is_wide_gamut(const skcms_ICCProfile & profile)47 static bool is_wide_gamut(const skcms_ICCProfile& profile) {
48 // Determine if the source image has a gamut that is wider than sRGB. If so, we
49 // will use P3 as the output color space to avoid clipping the gamut.
50 if (profile.has_toXYZD50) {
51 SkPoint rgb[3];
52 load_gamut(rgb, profile.toXYZD50);
53 return calculate_area(rgb) > kSRGB_D50_GamutArea;
54 }
55
56 return false;
57 }
58
adjust_info(SkCodec * codec,SkAndroidCodec::ExifOrientationBehavior orientationBehavior)59 static inline SkImageInfo adjust_info(SkCodec* codec,
60 SkAndroidCodec::ExifOrientationBehavior orientationBehavior) {
61 auto info = codec->getInfo();
62 if (orientationBehavior == SkAndroidCodec::ExifOrientationBehavior::kIgnore
63 || !SkPixmapPriv::ShouldSwapWidthHeight(codec->getOrigin())) {
64 return info;
65 }
66 return SkPixmapPriv::SwapWidthHeight(info);
67 }
68
SkAndroidCodec(SkCodec * codec,ExifOrientationBehavior orientationBehavior)69 SkAndroidCodec::SkAndroidCodec(SkCodec* codec, ExifOrientationBehavior orientationBehavior)
70 : fInfo(adjust_info(codec, orientationBehavior))
71 , fOrientationBehavior(orientationBehavior)
72 , fCodec(codec)
73 {}
74
~SkAndroidCodec()75 SkAndroidCodec::~SkAndroidCodec() {}
76
MakeFromStream(std::unique_ptr<SkStream> stream,SkPngChunkReader * chunkReader)77 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromStream(std::unique_ptr<SkStream> stream,
78 SkPngChunkReader* chunkReader) {
79 auto codec = SkCodec::MakeFromStream(std::move(stream), nullptr, chunkReader);
80 return MakeFromCodec(std::move(codec));
81 }
82
MakeFromCodec(std::unique_ptr<SkCodec> codec,ExifOrientationBehavior orientationBehavior)83 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromCodec(std::unique_ptr<SkCodec> codec,
84 ExifOrientationBehavior orientationBehavior) {
85 if (nullptr == codec) {
86 return nullptr;
87 }
88
89 switch ((SkEncodedImageFormat)codec->getEncodedFormat()) {
90 case SkEncodedImageFormat::kPNG:
91 case SkEncodedImageFormat::kICO:
92 case SkEncodedImageFormat::kJPEG:
93 #ifndef SK_HAS_WUFFS_LIBRARY
94 case SkEncodedImageFormat::kGIF:
95 #endif
96 case SkEncodedImageFormat::kBMP:
97 case SkEncodedImageFormat::kWBMP:
98 case SkEncodedImageFormat::kHEIF:
99 case SkEncodedImageFormat::kAVIF:
100 return std::make_unique<SkSampledCodec>(codec.release(), orientationBehavior);
101 #ifdef SK_HAS_WUFFS_LIBRARY
102 case SkEncodedImageFormat::kGIF:
103 #endif
104 #ifdef SK_CODEC_DECODES_WEBP
105 case SkEncodedImageFormat::kWEBP:
106 #endif
107 #ifdef SK_CODEC_DECODES_RAW
108 case SkEncodedImageFormat::kDNG:
109 #endif
110 #if defined(SK_CODEC_DECODES_WEBP) || defined(SK_CODEC_DECODES_RAW) || defined(SK_HAS_WUFFS_LIBRARY)
111 return std::make_unique<SkAndroidCodecAdapter>(codec.release(), orientationBehavior);
112 #endif
113
114 default:
115 return nullptr;
116 }
117 }
118
MakeFromData(sk_sp<SkData> data,SkPngChunkReader * chunkReader)119 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromData(sk_sp<SkData> data,
120 SkPngChunkReader* chunkReader) {
121 if (!data) {
122 return nullptr;
123 }
124
125 return MakeFromStream(SkMemoryStream::Make(std::move(data)), chunkReader);
126 }
127
computeOutputColorType(SkColorType requestedColorType)128 SkColorType SkAndroidCodec::computeOutputColorType(SkColorType requestedColorType) {
129 bool highPrecision = fCodec->getEncodedInfo().bitsPerComponent() > 8;
130 switch (requestedColorType) {
131 case kARGB_4444_SkColorType:
132 return kN32_SkColorType;
133 case kN32_SkColorType:
134 break;
135 case kAlpha_8_SkColorType:
136 // Fall through to kGray_8. Before kGray_8_SkColorType existed,
137 // we allowed clients to request kAlpha_8 when they wanted a
138 // grayscale decode.
139 case kGray_8_SkColorType:
140 if (kGray_8_SkColorType == this->getInfo().colorType()) {
141 return kGray_8_SkColorType;
142 }
143 break;
144 case kRGB_565_SkColorType:
145 if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
146 return kRGB_565_SkColorType;
147 }
148 break;
149 case kRGBA_F16_SkColorType:
150 return kRGBA_F16_SkColorType;
151 default:
152 break;
153 }
154
155 // F16 is the Android default for high precision images.
156 return highPrecision ? kRGBA_F16_SkColorType : kN32_SkColorType;
157 }
158
computeOutputAlphaType(bool requestedUnpremul)159 SkAlphaType SkAndroidCodec::computeOutputAlphaType(bool requestedUnpremul) {
160 if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
161 return kOpaque_SkAlphaType;
162 }
163 return requestedUnpremul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType;
164 }
165
computeOutputColorSpace(SkColorType outputColorType,sk_sp<SkColorSpace> prefColorSpace)166 sk_sp<SkColorSpace> SkAndroidCodec::computeOutputColorSpace(SkColorType outputColorType,
167 sk_sp<SkColorSpace> prefColorSpace) {
168 switch (outputColorType) {
169 case kRGBA_F16_SkColorType:
170 case kRGB_565_SkColorType:
171 case kRGBA_8888_SkColorType:
172 case kBGRA_8888_SkColorType: {
173 // If |prefColorSpace| is supplied, choose it.
174 if (prefColorSpace) {
175 return prefColorSpace;
176 }
177
178 const skcms_ICCProfile* encodedProfile = fCodec->getEncodedInfo().profile();
179 if (encodedProfile) {
180 if (auto encodedSpace = SkColorSpace::Make(*encodedProfile)) {
181 // Leave the pixels in the encoded color space. Color space conversion
182 // will be handled after decode time.
183 return encodedSpace;
184 }
185
186 if (is_wide_gamut(*encodedProfile)) {
187 return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDisplayP3);
188 }
189 }
190
191 return SkColorSpace::MakeSRGB();
192 }
193 default:
194 // Color correction not supported for kGray.
195 return nullptr;
196 }
197 }
198
supports_any_down_scale(const SkCodec * codec)199 static bool supports_any_down_scale(const SkCodec* codec) {
200 return codec->getEncodedFormat() == SkEncodedImageFormat::kWEBP;
201 }
202
203 // There are a variety of ways two SkISizes could be compared. This method
204 // returns true if either dimensions of a is < that of b.
205 // computeSampleSize also uses the opposite, which means that both
206 // dimensions of a >= b.
smaller_than(const SkISize & a,const SkISize & b)207 static inline bool smaller_than(const SkISize& a, const SkISize& b) {
208 return a.width() < b.width() || a.height() < b.height();
209 }
210
211 // Both dimensions of a > that of b.
strictly_bigger_than(const SkISize & a,const SkISize & b)212 static inline bool strictly_bigger_than(const SkISize& a, const SkISize& b) {
213 return a.width() > b.width() && a.height() > b.height();
214 }
215
computeSampleSize(SkISize * desiredSize) const216 int SkAndroidCodec::computeSampleSize(SkISize* desiredSize) const {
217 SkASSERT(desiredSize);
218
219 if (!desiredSize || *desiredSize == fInfo.dimensions()) {
220 return 1;
221 }
222
223 if (smaller_than(fInfo.dimensions(), *desiredSize)) {
224 *desiredSize = fInfo.dimensions();
225 return 1;
226 }
227
228 // Handle bad input:
229 if (desiredSize->width() < 1 || desiredSize->height() < 1) {
230 *desiredSize = SkISize::Make(std::max(1, desiredSize->width()),
231 std::max(1, desiredSize->height()));
232 }
233
234 if (supports_any_down_scale(fCodec.get())) {
235 return 1;
236 }
237
238 int sampleX = fInfo.width() / desiredSize->width();
239 int sampleY = fInfo.height() / desiredSize->height();
240 int sampleSize = std::min(sampleX, sampleY);
241 auto computedSize = this->getSampledDimensions(sampleSize);
242 if (computedSize == *desiredSize) {
243 return sampleSize;
244 }
245
246 if (computedSize == fInfo.dimensions() || sampleSize == 1) {
247 // Cannot downscale
248 *desiredSize = computedSize;
249 return 1;
250 }
251
252 if (strictly_bigger_than(computedSize, *desiredSize)) {
253 // See if there is a tighter fit.
254 while (true) {
255 auto smaller = this->getSampledDimensions(sampleSize + 1);
256 if (smaller == *desiredSize) {
257 return sampleSize + 1;
258 }
259 if (smaller == computedSize || smaller_than(smaller, *desiredSize)) {
260 // Cannot get any smaller without being smaller than desired.
261 *desiredSize = computedSize;
262 return sampleSize;
263 }
264
265 sampleSize++;
266 computedSize = smaller;
267 }
268
269 SkASSERT(false);
270 }
271
272 if (!smaller_than(computedSize, *desiredSize)) {
273 // This means one of the computed dimensions is equal to desired, and
274 // the other is bigger. This is as close as we can get.
275 *desiredSize = computedSize;
276 return sampleSize;
277 }
278
279 // computedSize is too small. Make it larger.
280 while (sampleSize > 2) {
281 auto bigger = this->getSampledDimensions(sampleSize - 1);
282 if (bigger == *desiredSize || !smaller_than(bigger, *desiredSize)) {
283 *desiredSize = bigger;
284 return sampleSize - 1;
285 }
286 sampleSize--;
287 }
288
289 *desiredSize = fInfo.dimensions();
290 return 1;
291 }
292
getSampledDimensions(int sampleSize) const293 SkISize SkAndroidCodec::getSampledDimensions(int sampleSize) const {
294 if (!is_valid_sample_size(sampleSize)) {
295 return {0, 0};
296 }
297
298 // Fast path for when we are not scaling.
299 if (1 == sampleSize) {
300 return fInfo.dimensions();
301 }
302
303 auto dims = this->onGetSampledDimensions(sampleSize);
304 if (fOrientationBehavior == SkAndroidCodec::ExifOrientationBehavior::kIgnore
305 || !SkPixmapPriv::ShouldSwapWidthHeight(fCodec->getOrigin())) {
306 return dims;
307 }
308
309 return { dims.height(), dims.width() };
310 }
311
getSupportedSubset(SkIRect * desiredSubset) const312 bool SkAndroidCodec::getSupportedSubset(SkIRect* desiredSubset) const {
313 if (!desiredSubset || !is_valid_subset(*desiredSubset, fInfo.dimensions())) {
314 return false;
315 }
316
317 return this->onGetSupportedSubset(desiredSubset);
318 }
319
getSampledSubsetDimensions(int sampleSize,const SkIRect & subset) const320 SkISize SkAndroidCodec::getSampledSubsetDimensions(int sampleSize, const SkIRect& subset) const {
321 if (!is_valid_sample_size(sampleSize)) {
322 return {0, 0};
323 }
324
325 // We require that the input subset is a subset that is supported by SkAndroidCodec.
326 // We test this by calling getSupportedSubset() and verifying that no modifications
327 // are made to the subset.
328 SkIRect copySubset = subset;
329 if (!this->getSupportedSubset(©Subset) || copySubset != subset) {
330 return {0, 0};
331 }
332
333 // If the subset is the entire image, for consistency, use getSampledDimensions().
334 if (fInfo.dimensions() == subset.size()) {
335 return this->getSampledDimensions(sampleSize);
336 }
337
338 // This should perhaps call a virtual function, but currently both of our subclasses
339 // want the same implementation.
340 return {get_scaled_dimension(subset.width(), sampleSize),
341 get_scaled_dimension(subset.height(), sampleSize)};
342 }
343
acceptable_result(SkCodec::Result result)344 static bool acceptable_result(SkCodec::Result result) {
345 switch (result) {
346 // These results mean a partial or complete image. They should be considered
347 // a success by SkPixmapPriv.
348 case SkCodec::kSuccess:
349 case SkCodec::kIncompleteInput:
350 case SkCodec::kErrorInInput:
351 return true;
352 default:
353 return false;
354 }
355 }
356
getAndroidPixels(const SkImageInfo & requestInfo,void * requestPixels,size_t requestRowBytes,const AndroidOptions * options)357 SkCodec::Result SkAndroidCodec::getAndroidPixels(const SkImageInfo& requestInfo,
358 void* requestPixels, size_t requestRowBytes, const AndroidOptions* options) {
359 if (!requestPixels) {
360 return SkCodec::kInvalidParameters;
361 }
362 if (requestRowBytes < requestInfo.minRowBytes()) {
363 return SkCodec::kInvalidParameters;
364 }
365
366 SkImageInfo adjustedInfo = fInfo;
367 if (ExifOrientationBehavior::kRespect == fOrientationBehavior
368 && SkPixmapPriv::ShouldSwapWidthHeight(fCodec->getOrigin())) {
369 adjustedInfo = SkPixmapPriv::SwapWidthHeight(adjustedInfo);
370 }
371
372 AndroidOptions defaultOptions;
373 if (!options) {
374 options = &defaultOptions;
375 } else if (options->fSubset) {
376 if (!is_valid_subset(*options->fSubset, adjustedInfo.dimensions())) {
377 return SkCodec::kInvalidParameters;
378 }
379
380 if (SkIRect::MakeSize(adjustedInfo.dimensions()) == *options->fSubset) {
381 // The caller wants the whole thing, rather than a subset. Modify
382 // the AndroidOptions passed to onGetAndroidPixels to not specify
383 // a subset.
384 defaultOptions = *options;
385 defaultOptions.fSubset = nullptr;
386 options = &defaultOptions;
387 }
388 }
389
390 if (ExifOrientationBehavior::kIgnore == fOrientationBehavior) {
391 return this->onGetAndroidPixels(requestInfo, requestPixels, requestRowBytes, *options);
392 }
393
394 SkCodec::Result result;
395 auto decode = [this, options, &result](const SkPixmap& pm) {
396 result = this->onGetAndroidPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), *options);
397 return acceptable_result(result);
398 };
399
400 SkPixmap dst(requestInfo, requestPixels, requestRowBytes);
401 if (SkPixmapPriv::Orient(dst, fCodec->getOrigin(), decode)) {
402 return result;
403 }
404
405 // Orient returned false. If onGetAndroidPixels succeeded, then Orient failed internally.
406 if (acceptable_result(result)) {
407 return SkCodec::kInternalError;
408 }
409
410 return result;
411 }
412
getAndroidPixels(const SkImageInfo & info,void * pixels,size_t rowBytes)413 SkCodec::Result SkAndroidCodec::getAndroidPixels(const SkImageInfo& info, void* pixels,
414 size_t rowBytes) {
415 return this->getAndroidPixels(info, pixels, rowBytes, nullptr);
416 }
417