msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 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 "SkAndroidCodec.h" |
| 9 | #include "SkCodec.h" |
| 10 | #include "SkCodecPriv.h" |
yujieqin | 916de9f | 2016-01-25 08:26:16 -0800 | [diff] [blame] | 11 | #include "SkRawAdapterCodec.h" |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 12 | #include "SkSampledCodec.h" |
| 13 | #include "SkWebpAdapterCodec.h" |
| 14 | |
| 15 | static bool is_valid_sample_size(int sampleSize) { |
| 16 | // FIXME: As Leon has mentioned elsewhere, surely there is also a maximum sampleSize? |
| 17 | return sampleSize > 0; |
| 18 | } |
| 19 | |
Matt Sarett | 2ae3a2e | 2017-02-15 08:48:02 -0500 | [diff] [blame] | 20 | /** |
| 21 | * Loads the gamut as a set of three points (triangle). |
| 22 | */ |
| 23 | static void load_gamut(SkPoint rgb[], const SkMatrix44& xyz) { |
| 24 | // rx = rX / (rX + rY + rZ) |
| 25 | // ry = rY / (rX + rY + rZ) |
| 26 | // gx, gy, bx, and gy are calulcated similarly. |
| 27 | float rSum = xyz.get(0, 0) + xyz.get(1, 0) + xyz.get(2, 0); |
| 28 | float gSum = xyz.get(0, 1) + xyz.get(1, 1) + xyz.get(2, 1); |
| 29 | float bSum = xyz.get(0, 2) + xyz.get(1, 2) + xyz.get(2, 2); |
| 30 | rgb[0].fX = xyz.get(0, 0) / rSum; |
| 31 | rgb[0].fY = xyz.get(1, 0) / rSum; |
| 32 | rgb[1].fX = xyz.get(0, 1) / gSum; |
| 33 | rgb[1].fY = xyz.get(1, 1) / gSum; |
| 34 | rgb[2].fX = xyz.get(0, 2) / bSum; |
| 35 | rgb[2].fY = xyz.get(1, 2) / bSum; |
| 36 | } |
| 37 | |
| 38 | /** |
| 39 | * Calculates the area of the triangular gamut. |
| 40 | */ |
| 41 | static float calculate_area(SkPoint abc[]) { |
| 42 | SkPoint a = abc[0]; |
| 43 | SkPoint b = abc[1]; |
| 44 | SkPoint c = abc[2]; |
| 45 | return 0.5f * SkTAbs(a.fX*b.fY + b.fX*c.fY - a.fX*c.fY - c.fX*b.fY - b.fX*a.fY); |
| 46 | } |
| 47 | |
| 48 | static const float kSRGB_D50_GamutArea = 0.084f; |
| 49 | |
| 50 | static bool is_wide_gamut(const SkColorSpace* colorSpace) { |
| 51 | // Determine if the source image has a gamut that is wider than sRGB. If so, we |
| 52 | // will use P3 as the output color space to avoid clipping the gamut. |
| 53 | const SkMatrix44* toXYZD50 = as_CSB(colorSpace)->toXYZD50(); |
| 54 | if (toXYZD50) { |
| 55 | SkPoint rgb[3]; |
| 56 | load_gamut(rgb, *toXYZD50); |
| 57 | return calculate_area(rgb) > kSRGB_D50_GamutArea; |
| 58 | } |
| 59 | |
| 60 | return false; |
| 61 | } |
| 62 | |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 63 | SkAndroidCodec::SkAndroidCodec(SkCodec* codec) |
| 64 | : fInfo(codec->getInfo()) |
| 65 | , fCodec(codec) |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 66 | {} |
| 67 | |
msarett | 7d5105c | 2015-12-02 07:02:41 -0800 | [diff] [blame] | 68 | SkAndroidCodec* SkAndroidCodec::NewFromStream(SkStream* stream, SkPngChunkReader* chunkReader) { |
Ben Wagner | 145dbcd | 2016-11-03 14:40:50 -0400 | [diff] [blame] | 69 | std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream, chunkReader)); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 70 | if (nullptr == codec) { |
| 71 | return nullptr; |
| 72 | } |
| 73 | |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 74 | switch ((SkEncodedImageFormat)codec->getEncodedFormat()) { |
msarett | ad3a5c6 | 2016-05-06 07:21:26 -0700 | [diff] [blame] | 75 | #ifdef SK_HAS_PNG_LIBRARY |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 76 | case SkEncodedImageFormat::kPNG: |
| 77 | case SkEncodedImageFormat::kICO: |
msarett | 39b2d5a | 2016-02-17 08:26:31 -0800 | [diff] [blame] | 78 | #endif |
msarett | ad3a5c6 | 2016-05-06 07:21:26 -0700 | [diff] [blame] | 79 | #ifdef SK_HAS_JPEG_LIBRARY |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 80 | case SkEncodedImageFormat::kJPEG: |
msarett | 39b2d5a | 2016-02-17 08:26:31 -0800 | [diff] [blame] | 81 | #endif |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 82 | case SkEncodedImageFormat::kGIF: |
| 83 | case SkEncodedImageFormat::kBMP: |
| 84 | case SkEncodedImageFormat::kWBMP: |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 85 | return new SkSampledCodec(codec.release()); |
msarett | ad3a5c6 | 2016-05-06 07:21:26 -0700 | [diff] [blame] | 86 | #ifdef SK_HAS_WEBP_LIBRARY |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 87 | case SkEncodedImageFormat::kWEBP: |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 88 | return new SkWebpAdapterCodec((SkWebpCodec*) codec.release()); |
msarett | 39b2d5a | 2016-02-17 08:26:31 -0800 | [diff] [blame] | 89 | #endif |
yujieqin | 916de9f | 2016-01-25 08:26:16 -0800 | [diff] [blame] | 90 | #ifdef SK_CODEC_DECODES_RAW |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 91 | case SkEncodedImageFormat::kDNG: |
mtklein | 18300a3 | 2016-03-16 13:53:35 -0700 | [diff] [blame] | 92 | return new SkRawAdapterCodec((SkRawCodec*)codec.release()); |
yujieqin | 916de9f | 2016-01-25 08:26:16 -0800 | [diff] [blame] | 93 | #endif |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 94 | default: |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 95 | return nullptr; |
| 96 | } |
| 97 | } |
| 98 | |
reed | 42943c8 | 2016-09-12 12:01:44 -0700 | [diff] [blame] | 99 | SkAndroidCodec* SkAndroidCodec::NewFromData(sk_sp<SkData> data, SkPngChunkReader* chunkReader) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 100 | if (!data) { |
| 101 | return nullptr; |
| 102 | } |
| 103 | |
msarett | 7d5105c | 2015-12-02 07:02:41 -0800 | [diff] [blame] | 104 | return NewFromStream(new SkMemoryStream(data), chunkReader); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 105 | } |
| 106 | |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 107 | SkColorType SkAndroidCodec::computeOutputColorType(SkColorType requestedColorType) { |
msarett | 457f54d | 2015-12-11 10:37:39 -0800 | [diff] [blame] | 108 | // The legacy GIF and WBMP decoders always decode to kIndex_8_SkColorType. |
Leon Scroggins III | 4cd6865 | 2016-12-16 14:17:03 -0500 | [diff] [blame] | 109 | // We will maintain this behavior when we can. |
| 110 | const SkColorType suggestedColorType = this->getInfo().colorType(); |
| 111 | switch ((SkEncodedImageFormat) this->getEncodedFormat()) { |
| 112 | case SkEncodedImageFormat::kGIF: |
| 113 | if (suggestedColorType == kIndex_8_SkColorType) { |
| 114 | return kIndex_8_SkColorType; |
| 115 | } |
| 116 | break; |
| 117 | case SkEncodedImageFormat::kWBMP: |
| 118 | return kIndex_8_SkColorType; |
| 119 | default: |
| 120 | break; |
msarett | 457f54d | 2015-12-11 10:37:39 -0800 | [diff] [blame] | 121 | } |
| 122 | |
Matt Sarett | 8dcc84f | 2016-12-14 10:23:41 -0500 | [diff] [blame] | 123 | bool highPrecision = fCodec->getEncodedInfo().bitsPerComponent() > 8; |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 124 | switch (requestedColorType) { |
| 125 | case kARGB_4444_SkColorType: |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 126 | return kN32_SkColorType; |
Matt Sarett | 8dcc84f | 2016-12-14 10:23:41 -0500 | [diff] [blame] | 127 | case kN32_SkColorType: |
| 128 | // F16 is the Android default for high precision images. |
| 129 | return highPrecision ? kRGBA_F16_SkColorType : kN32_SkColorType; |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 130 | case kIndex_8_SkColorType: |
| 131 | if (kIndex_8_SkColorType == suggestedColorType) { |
| 132 | return kIndex_8_SkColorType; |
| 133 | } |
| 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 == suggestedColorType) { |
| 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; |
Matt Sarett | 8dcc84f | 2016-12-14 10:23:41 -0500 | [diff] [blame] | 149 | case kRGBA_F16_SkColorType: |
| 150 | return kRGBA_F16_SkColorType; |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 151 | default: |
| 152 | break; |
| 153 | } |
| 154 | |
msarett | 457f54d | 2015-12-11 10:37:39 -0800 | [diff] [blame] | 155 | // Android has limited support for kGray_8 (using kAlpha_8). We will not |
| 156 | // use kGray_8 for Android unless they specifically ask for it. |
| 157 | if (kGray_8_SkColorType == suggestedColorType) { |
| 158 | return kN32_SkColorType; |
| 159 | } |
| 160 | |
Matt Sarett | 8dcc84f | 2016-12-14 10:23:41 -0500 | [diff] [blame] | 161 | // |suggestedColorType| may be kN32_SkColorType or kIndex_8_SkColorType. |
| 162 | return highPrecision ? kRGBA_F16_SkColorType : suggestedColorType; |
msarett | 9a0e346 | 2015-12-11 07:38:50 -0800 | [diff] [blame] | 163 | } |
| 164 | |
| 165 | SkAlphaType SkAndroidCodec::computeOutputAlphaType(bool requestedUnpremul) { |
| 166 | if (kOpaque_SkAlphaType == this->getInfo().alphaType()) { |
| 167 | return kOpaque_SkAlphaType; |
| 168 | } |
| 169 | return requestedUnpremul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType; |
| 170 | } |
| 171 | |
Matt Sarett | 966bb34 | 2016-12-12 16:30:13 -0500 | [diff] [blame] | 172 | sk_sp<SkColorSpace> SkAndroidCodec::computeOutputColorSpace(SkColorType outputColorType) { |
| 173 | switch (outputColorType) { |
| 174 | case kRGBA_8888_SkColorType: |
| 175 | case kBGRA_8888_SkColorType: |
Matt Sarett | 9341c98 | 2017-02-28 15:36:42 -0500 | [diff] [blame] | 176 | case kIndex_8_SkColorType: { |
| 177 | SkColorSpace* encodedSpace = fCodec->getInfo().colorSpace(); |
| 178 | SkColorSpaceTransferFn fn; |
| 179 | if (encodedSpace->isNumericalTransferFn(&fn)) { |
| 180 | // Leave the pixels in the encoded color space. Color space conversion |
| 181 | // will be handled after decode time. |
Matt Sarett | cf3f234 | 2017-03-23 15:32:25 -0400 | [diff] [blame^] | 182 | return sk_ref_sp(encodedSpace); |
Matt Sarett | 9341c98 | 2017-02-28 15:36:42 -0500 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | if (is_wide_gamut(encodedSpace)) { |
Matt Sarett | 2ae3a2e | 2017-02-15 08:48:02 -0500 | [diff] [blame] | 186 | return SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma, |
Matt Sarett | cf3f234 | 2017-03-23 15:32:25 -0400 | [diff] [blame^] | 187 | SkColorSpace::kDCIP3_D65_Gamut); |
Matt Sarett | 2ae3a2e | 2017-02-15 08:48:02 -0500 | [diff] [blame] | 188 | } |
| 189 | |
Matt Sarett | cf3f234 | 2017-03-23 15:32:25 -0400 | [diff] [blame^] | 190 | return SkColorSpace::MakeSRGB(); |
Matt Sarett | 9341c98 | 2017-02-28 15:36:42 -0500 | [diff] [blame] | 191 | } |
Matt Sarett | 966bb34 | 2016-12-12 16:30:13 -0500 | [diff] [blame] | 192 | case kRGBA_F16_SkColorType: |
Matt Sarett | 77a7a1b | 2017-02-07 13:56:11 -0500 | [diff] [blame] | 193 | return SkColorSpace::MakeSRGBLinear(); |
Matt Sarett | 966bb34 | 2016-12-12 16:30:13 -0500 | [diff] [blame] | 194 | default: |
| 195 | // Color correction not supported for k565 and kGray. |
| 196 | return nullptr; |
| 197 | } |
| 198 | } |
| 199 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 200 | SkISize SkAndroidCodec::getSampledDimensions(int sampleSize) const { |
| 201 | if (!is_valid_sample_size(sampleSize)) { |
| 202 | return SkISize::Make(0, 0); |
| 203 | } |
| 204 | |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 205 | // Fast path for when we are not scaling. |
| 206 | if (1 == sampleSize) { |
| 207 | return fInfo.dimensions(); |
| 208 | } |
| 209 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 210 | return this->onGetSampledDimensions(sampleSize); |
| 211 | } |
| 212 | |
| 213 | bool SkAndroidCodec::getSupportedSubset(SkIRect* desiredSubset) const { |
| 214 | if (!desiredSubset || !is_valid_subset(*desiredSubset, fInfo.dimensions())) { |
| 215 | return false; |
| 216 | } |
| 217 | |
| 218 | return this->onGetSupportedSubset(desiredSubset); |
| 219 | } |
| 220 | |
| 221 | SkISize SkAndroidCodec::getSampledSubsetDimensions(int sampleSize, const SkIRect& subset) const { |
| 222 | if (!is_valid_sample_size(sampleSize)) { |
| 223 | return SkISize::Make(0, 0); |
| 224 | } |
| 225 | |
| 226 | // We require that the input subset is a subset that is supported by SkAndroidCodec. |
| 227 | // We test this by calling getSupportedSubset() and verifying that no modifications |
| 228 | // are made to the subset. |
| 229 | SkIRect copySubset = subset; |
| 230 | if (!this->getSupportedSubset(©Subset) || copySubset != subset) { |
| 231 | return SkISize::Make(0, 0); |
| 232 | } |
| 233 | |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 234 | // If the subset is the entire image, for consistency, use getSampledDimensions(). |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 235 | if (fInfo.dimensions() == subset.size()) { |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 236 | return this->getSampledDimensions(sampleSize); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 237 | } |
| 238 | |
| 239 | // This should perhaps call a virtual function, but currently both of our subclasses |
| 240 | // want the same implementation. |
| 241 | return SkISize::Make(get_scaled_dimension(subset.width(), sampleSize), |
| 242 | get_scaled_dimension(subset.height(), sampleSize)); |
| 243 | } |
| 244 | |
| 245 | SkCodec::Result SkAndroidCodec::getAndroidPixels(const SkImageInfo& info, void* pixels, |
scroggo | e95a068 | 2015-11-04 04:31:12 -0800 | [diff] [blame] | 246 | size_t rowBytes, const AndroidOptions* options) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 247 | if (!pixels) { |
| 248 | return SkCodec::kInvalidParameters; |
| 249 | } |
| 250 | if (rowBytes < info.minRowBytes()) { |
| 251 | return SkCodec::kInvalidParameters; |
| 252 | } |
| 253 | |
| 254 | AndroidOptions defaultOptions; |
| 255 | if (!options) { |
| 256 | options = &defaultOptions; |
| 257 | } else if (options->fSubset) { |
| 258 | if (!is_valid_subset(*options->fSubset, fInfo.dimensions())) { |
| 259 | return SkCodec::kInvalidParameters; |
| 260 | } |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 261 | |
| 262 | if (SkIRect::MakeSize(fInfo.dimensions()) == *options->fSubset) { |
| 263 | // The caller wants the whole thing, rather than a subset. Modify |
| 264 | // the AndroidOptions passed to onGetAndroidPixels to not specify |
| 265 | // a subset. |
| 266 | defaultOptions = *options; |
| 267 | defaultOptions.fSubset = nullptr; |
| 268 | options = &defaultOptions; |
| 269 | } |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | return this->onGetAndroidPixels(info, pixels, rowBytes, *options); |
| 273 | } |
| 274 | |
| 275 | SkCodec::Result SkAndroidCodec::getAndroidPixels(const SkImageInfo& info, void* pixels, |
| 276 | size_t rowBytes) { |
| 277 | return this->getAndroidPixels(info, pixels, rowBytes, nullptr); |
| 278 | } |