Home | History | Annotate | Download | only in codec 
      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 "SkAndroidCodecAdapter.h"
     10 #include "SkCodec.h"
     11 #include "SkCodecPriv.h"
     12 #include "SkMakeUnique.h"
     13 #include "SkPixmap.h"
     14 #include "SkPixmapPriv.h"
     15 #include "SkSampledCodec.h"
     16 
     17 static bool is_valid_sample_size(int sampleSize) {
     18     // FIXME: As Leon has mentioned elsewhere, surely there is also a maximum sampleSize?
     19     return sampleSize > 0;
     20 }
     21 
     22 /**
     23  *  Loads the gamut as a set of three points (triangle).
     24  */
     25 static void load_gamut(SkPoint rgb[], const skcms_Matrix3x3& xyz) {
     26     // rx = rX / (rX + rY + rZ)
     27     // ry = rY / (rX + rY + rZ)
     28     // gx, gy, bx, and gy are calulcated similarly.
     29     for (int rgbIdx = 0; rgbIdx < 3; rgbIdx++) {
     30         float sum = xyz.vals[rgbIdx][0] + xyz.vals[rgbIdx][1] + xyz.vals[rgbIdx][2];
     31         rgb[rgbIdx].fX = xyz.vals[rgbIdx][0] / sum;
     32         rgb[rgbIdx].fY = xyz.vals[rgbIdx][1] / sum;
     33     }
     34 }
     35 
     36 /**
     37  *  Calculates the area of the triangular gamut.
     38  */
     39 static float calculate_area(SkPoint abc[]) {
     40     SkPoint a = abc[0];
     41     SkPoint b = abc[1];
     42     SkPoint c = abc[2];
     43     return 0.5f * SkTAbs(a.fX*b.fY + b.fX*c.fY - a.fX*c.fY - c.fX*b.fY - b.fX*a.fY);
     44 }
     45 
     46 static constexpr float kSRGB_D50_GamutArea = 0.084f;
     47 
     48 static bool is_wide_gamut(const skcms_ICCProfile& profile) {
     49     // Determine if the source image has a gamut that is wider than sRGB.  If so, we
     50     // will use P3 as the output color space to avoid clipping the gamut.
     51     if (profile.has_toXYZD50) {
     52         SkPoint rgb[3];
     53         load_gamut(rgb, profile.toXYZD50);
     54         return calculate_area(rgb) > kSRGB_D50_GamutArea;
     55     }
     56 
     57     return false;
     58 }
     59 
     60 static inline SkImageInfo adjust_info(SkCodec* codec,
     61         SkAndroidCodec::ExifOrientationBehavior orientationBehavior) {
     62     auto info = codec->getInfo();
     63     if (orientationBehavior == SkAndroidCodec::ExifOrientationBehavior::kIgnore
     64             || !SkPixmapPriv::ShouldSwapWidthHeight(codec->getOrigin())) {
     65         return info;
     66     }
     67     return SkPixmapPriv::SwapWidthHeight(info);
     68 }
     69 
     70 SkAndroidCodec::SkAndroidCodec(SkCodec* codec, ExifOrientationBehavior orientationBehavior)
     71     : fInfo(adjust_info(codec, orientationBehavior))
     72     , fOrientationBehavior(orientationBehavior)
     73     , fCodec(codec)
     74 {}
     75 
     76 SkAndroidCodec::~SkAndroidCodec() {}
     77 
     78 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromStream(std::unique_ptr<SkStream> stream,
     79                                                                SkPngChunkReader* chunkReader) {
     80     auto codec = SkCodec::MakeFromStream(std::move(stream), nullptr, chunkReader);
     81     return MakeFromCodec(std::move(codec));
     82 }
     83 
     84 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromCodec(std::unique_ptr<SkCodec> codec,
     85         ExifOrientationBehavior orientationBehavior) {
     86     if (nullptr == codec) {
     87         return nullptr;
     88     }
     89 
     90     switch ((SkEncodedImageFormat)codec->getEncodedFormat()) {
     91         case SkEncodedImageFormat::kPNG:
     92         case SkEncodedImageFormat::kICO:
     93         case SkEncodedImageFormat::kJPEG:
     94         case SkEncodedImageFormat::kGIF:
     95         case SkEncodedImageFormat::kBMP:
     96         case SkEncodedImageFormat::kWBMP:
     97         case SkEncodedImageFormat::kHEIF:
     98             return skstd::make_unique<SkSampledCodec>(codec.release(), orientationBehavior);
     99 
    100 #ifdef SK_HAS_WEBP_LIBRARY
    101         case SkEncodedImageFormat::kWEBP:
    102 #endif
    103 #ifdef SK_CODEC_DECODES_RAW
    104         case SkEncodedImageFormat::kDNG:
    105 #endif
    106 #if defined(SK_HAS_WEBP_LIBRARY) || defined(SK_CODEC_DECODES_RAW)
    107             return skstd::make_unique<SkAndroidCodecAdapter>(codec.release(), orientationBehavior);
    108 #endif
    109 
    110         default:
    111             return nullptr;
    112     }
    113 }
    114 
    115 std::unique_ptr<SkAndroidCodec> SkAndroidCodec::MakeFromData(sk_sp<SkData> data,
    116                                                              SkPngChunkReader* chunkReader) {
    117     if (!data) {
    118         return nullptr;
    119     }
    120 
    121     return MakeFromStream(SkMemoryStream::Make(std::move(data)), chunkReader);
    122 }
    123 
    124 SkColorType SkAndroidCodec::computeOutputColorType(SkColorType requestedColorType) {
    125     bool highPrecision = fCodec->getEncodedInfo().bitsPerComponent() > 8;
    126     switch (requestedColorType) {
    127         case kARGB_4444_SkColorType:
    128             return kN32_SkColorType;
    129         case kN32_SkColorType:
    130             break;
    131         case kAlpha_8_SkColorType:
    132             // Fall through to kGray_8.  Before kGray_8_SkColorType existed,
    133             // we allowed clients to request kAlpha_8 when they wanted a
    134             // grayscale decode.
    135         case kGray_8_SkColorType:
    136             if (kGray_8_SkColorType == this->getInfo().colorType()) {
    137                 return kGray_8_SkColorType;
    138             }
    139             break;
    140         case kRGB_565_SkColorType:
    141             if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
    142                 return kRGB_565_SkColorType;
    143             }
    144             break;
    145         case kRGBA_F16_SkColorType:
    146             return kRGBA_F16_SkColorType;
    147         default:
    148             break;
    149     }
    150 
    151     // F16 is the Android default for high precision images.
    152     return highPrecision ? kRGBA_F16_SkColorType : kN32_SkColorType;
    153 }
    154 
    155 SkAlphaType SkAndroidCodec::computeOutputAlphaType(bool requestedUnpremul) {
    156     if (kOpaque_SkAlphaType == this->getInfo().alphaType()) {
    157         return kOpaque_SkAlphaType;
    158     }
    159     return requestedUnpremul ? kUnpremul_SkAlphaType : kPremul_SkAlphaType;
    160 }
    161 
    162 sk_sp<SkColorSpace> SkAndroidCodec::computeOutputColorSpace(SkColorType outputColorType,
    163                                                             sk_sp<SkColorSpace> prefColorSpace) {
    164     switch (outputColorType) {
    165         case kRGBA_8888_SkColorType:
    166         case kBGRA_8888_SkColorType: {
    167             // If |prefColorSpace| is supplied, choose it.
    168             if (prefColorSpace) {
    169                 return prefColorSpace;
    170             }
    171 
    172             const skcms_ICCProfile* encodedProfile = fCodec->getEncodedInfo().profile();
    173             if (encodedProfile) {
    174                 if (auto encodedSpace = SkColorSpace::Make(*encodedProfile)) {
    175                     // Leave the pixels in the encoded color space.  Color space conversion
    176                     // will be handled after decode time.
    177                     return encodedSpace;
    178                 }
    179 
    180                 if (is_wide_gamut(*encodedProfile)) {
    181                     return SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
    182                 }
    183             }
    184 
    185             return SkColorSpace::MakeSRGB();
    186         }
    187         case kRGBA_F16_SkColorType:
    188             // Note that |prefColorSpace| is ignored, F16 is always linear sRGB.
    189             return SkColorSpace::MakeSRGBLinear();
    190         case kRGB_565_SkColorType:
    191             // Note that |prefColorSpace| is ignored, 565 is always sRGB.
    192             return SkColorSpace::MakeSRGB();
    193         default:
    194             // Color correction not supported for kGray.
    195             return nullptr;
    196     }
    197 }
    198 
    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.
    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.
    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 
    216 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 
    293 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 
    312 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 
    320 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(&copySubset) || 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 
    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 
    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 
    413 SkCodec::Result SkAndroidCodec::getAndroidPixels(const SkImageInfo& info, void* pixels,
    414         size_t rowBytes) {
    415     return this->getAndroidPixels(info, pixels, rowBytes, nullptr);
    416 }
    417