emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -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 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 8 | #include "SkCodec.h" |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 9 | #include "SkCodecPriv.h" |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 10 | #include "SkMath.h" |
Hal Canary | 2d40490 | 2018-09-06 11:20:23 -0400 | [diff] [blame] | 11 | #include "SkMathPriv.h" |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 12 | #include "SkSampledCodec.h" |
msarett | a4970dc | 2016-01-11 07:23:23 -0800 | [diff] [blame] | 13 | #include "SkSampler.h" |
scroggo | 565901d | 2015-12-10 10:44:13 -0800 | [diff] [blame] | 14 | #include "SkTemplates.h" |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 15 | |
Leon Scroggins III | da3e9ad | 2018-01-26 15:48:26 -0500 | [diff] [blame] | 16 | SkSampledCodec::SkSampledCodec(SkCodec* codec, ExifOrientationBehavior behavior) |
| 17 | : INHERITED(codec, behavior) |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 18 | {} |
| 19 | |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 20 | SkISize SkSampledCodec::accountForNativeScaling(int* sampleSizePtr, int* nativeSampleSize) const { |
Leon Scroggins III | 712476e | 2018-10-03 15:47:00 -0400 | [diff] [blame] | 21 | SkISize preSampledSize = this->codec()->dimensions(); |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 22 | int sampleSize = *sampleSizePtr; |
| 23 | SkASSERT(sampleSize > 1); |
| 24 | |
| 25 | if (nativeSampleSize) { |
| 26 | *nativeSampleSize = 1; |
| 27 | } |
| 28 | |
| 29 | // Only JPEG supports native downsampling. |
Hal Canary | db68301 | 2016-11-23 08:55:18 -0700 | [diff] [blame] | 30 | if (this->codec()->getEncodedFormat() == SkEncodedImageFormat::kJPEG) { |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 31 | // See if libjpeg supports this scale directly |
| 32 | switch (sampleSize) { |
| 33 | case 2: |
| 34 | case 4: |
| 35 | case 8: |
| 36 | // This class does not need to do any sampling. |
| 37 | *sampleSizePtr = 1; |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 38 | return this->codec()->getScaledDimensions(get_scale_from_sample_size(sampleSize)); |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 39 | default: |
| 40 | break; |
| 41 | } |
| 42 | |
| 43 | // Check if sampleSize is a multiple of something libjpeg can support. |
| 44 | int remainder; |
| 45 | const int sampleSizes[] = { 8, 4, 2 }; |
| 46 | for (int supportedSampleSize : sampleSizes) { |
| 47 | int actualSampleSize; |
| 48 | SkTDivMod(sampleSize, supportedSampleSize, &actualSampleSize, &remainder); |
| 49 | if (0 == remainder) { |
| 50 | float scale = get_scale_from_sample_size(supportedSampleSize); |
| 51 | |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 52 | // this->codec() will scale to this size. |
| 53 | preSampledSize = this->codec()->getScaledDimensions(scale); |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 54 | |
| 55 | // And then this class will sample it. |
| 56 | *sampleSizePtr = actualSampleSize; |
| 57 | if (nativeSampleSize) { |
| 58 | *nativeSampleSize = supportedSampleSize; |
| 59 | } |
| 60 | break; |
| 61 | } |
| 62 | } |
| 63 | } |
| 64 | |
| 65 | return preSampledSize; |
| 66 | } |
| 67 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 68 | SkISize SkSampledCodec::onGetSampledDimensions(int sampleSize) const { |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 69 | const SkISize size = this->accountForNativeScaling(&sampleSize); |
| 70 | return SkISize::Make(get_scaled_dimension(size.width(), sampleSize), |
| 71 | get_scaled_dimension(size.height(), sampleSize)); |
msarett | a83593b | 2015-08-18 08:03:58 -0700 | [diff] [blame] | 72 | } |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 73 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 74 | SkCodec::Result SkSampledCodec::onGetAndroidPixels(const SkImageInfo& info, void* pixels, |
scroggo | e95a068 | 2015-11-04 04:31:12 -0800 | [diff] [blame] | 75 | size_t rowBytes, const AndroidOptions& options) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 76 | // Create an Options struct for the codec. |
| 77 | SkCodec::Options codecOptions; |
| 78 | codecOptions.fZeroInitialized = options.fZeroInitialized; |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 79 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 80 | SkIRect* subset = options.fSubset; |
Leon Scroggins III | 712476e | 2018-10-03 15:47:00 -0400 | [diff] [blame] | 81 | if (!subset || subset->size() == this->codec()->dimensions()) { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 82 | if (this->codec()->dimensionsSupported(info.dimensions())) { |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 83 | return this->codec()->getPixels(info, pixels, rowBytes, &codecOptions); |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 84 | } |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 85 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 86 | // If the native codec does not support the requested scale, scale by sampling. |
| 87 | return this->sampledDecode(info, pixels, rowBytes, options); |
scroggo | e7fc14b | 2015-10-02 13:14:46 -0700 | [diff] [blame] | 88 | } |
| 89 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 90 | // We are performing a subset decode. |
| 91 | int sampleSize = options.fSampleSize; |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 92 | SkISize scaledSize = this->getSampledDimensions(sampleSize); |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 93 | if (!this->codec()->dimensionsSupported(scaledSize)) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 94 | // If the native codec does not support the requested scale, scale by sampling. |
| 95 | return this->sampledDecode(info, pixels, rowBytes, options); |
| 96 | } |
scroggo | e7fc14b | 2015-10-02 13:14:46 -0700 | [diff] [blame] | 97 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 98 | // Calculate the scaled subset bounds. |
| 99 | int scaledSubsetX = subset->x() / sampleSize; |
| 100 | int scaledSubsetY = subset->y() / sampleSize; |
| 101 | int scaledSubsetWidth = info.width(); |
| 102 | int scaledSubsetHeight = info.height(); |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 103 | |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 104 | const SkImageInfo scaledInfo = info.makeWH(scaledSize.width(), scaledSize.height()); |
| 105 | |
| 106 | { |
| 107 | // Although startScanlineDecode expects the bottom and top to match the |
| 108 | // SkImageInfo, startIncrementalDecode uses them to determine which rows to |
| 109 | // decode. |
| 110 | SkIRect incrementalSubset = SkIRect::MakeXYWH(scaledSubsetX, scaledSubsetY, |
| 111 | scaledSubsetWidth, scaledSubsetHeight); |
| 112 | codecOptions.fSubset = &incrementalSubset; |
| 113 | const SkCodec::Result startResult = this->codec()->startIncrementalDecode( |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 114 | scaledInfo, pixels, rowBytes, &codecOptions); |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 115 | if (SkCodec::kSuccess == startResult) { |
Leon Scroggins III | 6e45ce7 | 2018-10-16 15:29:11 -0400 | [diff] [blame] | 116 | int rowsDecoded = 0; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 117 | const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded); |
| 118 | if (incResult == SkCodec::kSuccess) { |
| 119 | return SkCodec::kSuccess; |
| 120 | } |
Leon Scroggins III | 6e45ce7 | 2018-10-16 15:29:11 -0400 | [diff] [blame] | 121 | SkASSERT(incResult == SkCodec::kIncompleteInput || incResult == SkCodec::kErrorInInput); |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 122 | |
| 123 | // FIXME: Can zero initialized be read from SkCodec::fOptions? |
| 124 | this->codec()->fillIncompleteImage(scaledInfo, pixels, rowBytes, |
| 125 | options.fZeroInitialized, scaledSubsetHeight, rowsDecoded); |
Leon Scroggins III | 6e45ce7 | 2018-10-16 15:29:11 -0400 | [diff] [blame] | 126 | return incResult; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 127 | } else if (startResult != SkCodec::kUnimplemented) { |
| 128 | return startResult; |
| 129 | } |
| 130 | // Otherwise fall down to use the old scanline decoder. |
| 131 | // codecOptions.fSubset will be reset below, so it will not continue to |
| 132 | // point to the object that is no longer on the stack. |
| 133 | } |
| 134 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 135 | // Start the scanline decode. |
| 136 | SkIRect scanlineSubset = SkIRect::MakeXYWH(scaledSubsetX, 0, scaledSubsetWidth, |
| 137 | scaledSize.height()); |
| 138 | codecOptions.fSubset = &scanlineSubset; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 139 | |
| 140 | SkCodec::Result result = this->codec()->startScanlineDecode(scaledInfo, |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 141 | &codecOptions); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 142 | if (SkCodec::kSuccess != result) { |
| 143 | return result; |
| 144 | } |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 145 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 146 | // At this point, we are only concerned with subsetting. Either no scale was |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 147 | // requested, or the this->codec() is handling the scale. |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 148 | // Note that subsetting is only supported for kTopDown, so this code will not be |
| 149 | // reached for other orders. |
| 150 | SkASSERT(this->codec()->getScanlineOrder() == SkCodec::kTopDown_SkScanlineOrder); |
| 151 | if (!this->codec()->skipScanlines(scaledSubsetY)) { |
| 152 | this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, |
| 153 | scaledSubsetHeight, 0); |
| 154 | return SkCodec::kIncompleteInput; |
scroggo | 6fb2391 | 2016-06-02 14:16:43 -0700 | [diff] [blame] | 155 | } |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 156 | |
| 157 | int decodedLines = this->codec()->getScanlines(pixels, scaledSubsetHeight, rowBytes); |
| 158 | if (decodedLines != scaledSubsetHeight) { |
| 159 | return SkCodec::kIncompleteInput; |
| 160 | } |
| 161 | return SkCodec::kSuccess; |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 162 | } |
| 163 | |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 164 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 165 | SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pixels, |
scroggo | e95a068 | 2015-11-04 04:31:12 -0800 | [diff] [blame] | 166 | size_t rowBytes, const AndroidOptions& options) { |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 167 | // We should only call this function when sampling. |
| 168 | SkASSERT(options.fSampleSize > 1); |
| 169 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 170 | // Create options struct for the codec. |
| 171 | SkCodec::Options sampledOptions; |
| 172 | sampledOptions.fZeroInitialized = options.fZeroInitialized; |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 173 | |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 174 | // FIXME: This was already called by onGetAndroidPixels. Can we reduce that? |
| 175 | int sampleSize = options.fSampleSize; |
| 176 | int nativeSampleSize; |
| 177 | SkISize nativeSize = this->accountForNativeScaling(&sampleSize, &nativeSampleSize); |
| 178 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 179 | // Check if there is a subset. |
| 180 | SkIRect subset; |
| 181 | int subsetY = 0; |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 182 | int subsetWidth = nativeSize.width(); |
| 183 | int subsetHeight = nativeSize.height(); |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 184 | if (options.fSubset) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 185 | // We will need to know about subsetting in the y-dimension in order to use the |
| 186 | // scanline decoder. |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 187 | // Update the subset to account for scaling done by this->codec(). |
scroggo | 4f2a88c | 2016-10-17 14:32:41 -0700 | [diff] [blame] | 188 | const SkIRect* subsetPtr = options.fSubset; |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 189 | |
| 190 | // Do the divide ourselves, instead of calling get_scaled_dimension. If |
| 191 | // X and Y are 0, they should remain 0, rather than being upgraded to 1 |
| 192 | // due to being smaller than the sampleSize. |
| 193 | const int subsetX = subsetPtr->x() / nativeSampleSize; |
| 194 | subsetY = subsetPtr->y() / nativeSampleSize; |
| 195 | |
| 196 | subsetWidth = get_scaled_dimension(subsetPtr->width(), nativeSampleSize); |
| 197 | subsetHeight = get_scaled_dimension(subsetPtr->height(), nativeSampleSize); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 198 | |
| 199 | // The scanline decoder only needs to be aware of subsetting in the x-dimension. |
scroggo | 501b734 | 2015-11-03 07:55:11 -0800 | [diff] [blame] | 200 | subset.setXYWH(subsetX, 0, subsetWidth, nativeSize.height()); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 201 | sampledOptions.fSubset = ⊂ |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 202 | } |
| 203 | |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 204 | // Since we guarantee that output dimensions are always at least one (even if the sampleSize |
| 205 | // is greater than a given dimension), the input sampleSize is not always the sampleSize that |
| 206 | // we use in practice. |
| 207 | const int sampleX = subsetWidth / info.width(); |
| 208 | const int sampleY = subsetHeight / info.height(); |
| 209 | |
| 210 | const int samplingOffsetY = get_start_coord(sampleY); |
| 211 | const int startY = samplingOffsetY + subsetY; |
scroggo | 4f2a88c | 2016-10-17 14:32:41 -0700 | [diff] [blame] | 212 | const int dstHeight = info.height(); |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 213 | |
| 214 | const SkImageInfo nativeInfo = info.makeWH(nativeSize.width(), nativeSize.height()); |
| 215 | |
| 216 | { |
| 217 | // Although startScanlineDecode expects the bottom and top to match the |
| 218 | // SkImageInfo, startIncrementalDecode uses them to determine which rows to |
| 219 | // decode. |
scroggo | 4f2a88c | 2016-10-17 14:32:41 -0700 | [diff] [blame] | 220 | SkCodec::Options incrementalOptions = sampledOptions; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 221 | SkIRect incrementalSubset; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 222 | if (sampledOptions.fSubset) { |
scroggo | 4f2a88c | 2016-10-17 14:32:41 -0700 | [diff] [blame] | 223 | incrementalSubset.fTop = subsetY; |
| 224 | incrementalSubset.fBottom = subsetY + subsetHeight; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 225 | incrementalSubset.fLeft = sampledOptions.fSubset->fLeft; |
| 226 | incrementalSubset.fRight = sampledOptions.fSubset->fRight; |
scroggo | 4f2a88c | 2016-10-17 14:32:41 -0700 | [diff] [blame] | 227 | incrementalOptions.fSubset = &incrementalSubset; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 228 | } |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 229 | const SkCodec::Result startResult = this->codec()->startIncrementalDecode(nativeInfo, |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 230 | pixels, rowBytes, &incrementalOptions); |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 231 | if (SkCodec::kSuccess == startResult) { |
| 232 | SkSampler* sampler = this->codec()->getSampler(true); |
| 233 | if (!sampler) { |
| 234 | return SkCodec::kUnimplemented; |
| 235 | } |
| 236 | |
| 237 | if (sampler->setSampleX(sampleX) != info.width()) { |
| 238 | return SkCodec::kInvalidScale; |
| 239 | } |
| 240 | if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) { |
| 241 | return SkCodec::kInvalidScale; |
| 242 | } |
| 243 | |
| 244 | sampler->setSampleY(sampleY); |
| 245 | |
Leon Scroggins III | 6e45ce7 | 2018-10-16 15:29:11 -0400 | [diff] [blame] | 246 | int rowsDecoded = 0; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 247 | const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded); |
| 248 | if (incResult == SkCodec::kSuccess) { |
| 249 | return SkCodec::kSuccess; |
| 250 | } |
Leon Scroggins III | 674a184 | 2017-07-06 12:26:09 -0400 | [diff] [blame] | 251 | SkASSERT(incResult == SkCodec::kIncompleteInput || incResult == SkCodec::kErrorInInput); |
msarett | c6c81e1 | 2016-09-16 14:52:07 -0700 | [diff] [blame] | 252 | |
scroggo | ff9f7bb | 2016-10-10 11:35:01 -0700 | [diff] [blame] | 253 | SkASSERT(rowsDecoded <= info.height()); |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 254 | this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, |
scroggo | ff9f7bb | 2016-10-10 11:35:01 -0700 | [diff] [blame] | 255 | info.height(), rowsDecoded); |
Leon Scroggins III | 674a184 | 2017-07-06 12:26:09 -0400 | [diff] [blame] | 256 | return incResult; |
Leon Scroggins III | 32526b5 | 2018-10-31 15:00:16 -0400 | [diff] [blame] | 257 | } else if (startResult == SkCodec::kIncompleteInput |
| 258 | || startResult == SkCodec::kErrorInInput) { |
| 259 | return SkCodec::kInvalidInput; |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 260 | } else if (startResult != SkCodec::kUnimplemented) { |
| 261 | return startResult; |
| 262 | } // kUnimplemented means use the old method. |
| 263 | } |
| 264 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 265 | // Start the scanline decode. |
scroggo | 8e6c7ad | 2016-09-16 08:20:38 -0700 | [diff] [blame] | 266 | SkCodec::Result result = this->codec()->startScanlineDecode(nativeInfo, |
Leon Scroggins | 571b30f | 2017-07-11 17:35:31 +0000 | [diff] [blame] | 267 | &sampledOptions); |
Leon Scroggins III | 32526b5 | 2018-10-31 15:00:16 -0400 | [diff] [blame] | 268 | if (SkCodec::kIncompleteInput == result || SkCodec::kErrorInInput == result) { |
| 269 | return SkCodec::kInvalidInput; |
| 270 | } else if (SkCodec::kSuccess != result) { |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 271 | return result; |
| 272 | } |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 273 | |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 274 | SkSampler* sampler = this->codec()->getSampler(true); |
scroggo | e7fc14b | 2015-10-02 13:14:46 -0700 | [diff] [blame] | 275 | if (!sampler) { |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 276 | return SkCodec::kUnimplemented; |
scroggo | e7fc14b | 2015-10-02 13:14:46 -0700 | [diff] [blame] | 277 | } |
| 278 | |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 279 | if (sampler->setSampleX(sampleX) != info.width()) { |
| 280 | return SkCodec::kInvalidScale; |
| 281 | } |
| 282 | if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) { |
| 283 | return SkCodec::kInvalidScale; |
scroggo | e7fc14b | 2015-10-02 13:14:46 -0700 | [diff] [blame] | 284 | } |
| 285 | |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 286 | switch(this->codec()->getScanlineOrder()) { |
scroggo | 46c5747 | 2015-09-30 08:57:13 -0700 | [diff] [blame] | 287 | case SkCodec::kTopDown_SkScanlineOrder: { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 288 | if (!this->codec()->skipScanlines(startY)) { |
| 289 | this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 290 | dstHeight, 0); |
| 291 | return SkCodec::kIncompleteInput; |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 292 | } |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 293 | void* pixelPtr = pixels; |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 294 | for (int y = 0; y < dstHeight; y++) { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 295 | if (1 != this->codec()->getScanlines(pixelPtr, 1, rowBytes)) { |
| 296 | this->codec()->fillIncompleteImage(info, pixels, rowBytes, |
| 297 | options.fZeroInitialized, dstHeight, y + 1); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 298 | return SkCodec::kIncompleteInput; |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 299 | } |
msarett | 691ad76 | 2015-11-05 11:19:29 -0800 | [diff] [blame] | 300 | if (y < dstHeight - 1) { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 301 | if (!this->codec()->skipScanlines(sampleY - 1)) { |
| 302 | this->codec()->fillIncompleteImage(info, pixels, rowBytes, |
msarett | 691ad76 | 2015-11-05 11:19:29 -0800 | [diff] [blame] | 303 | options.fZeroInitialized, dstHeight, y + 1); |
| 304 | return SkCodec::kIncompleteInput; |
| 305 | } |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 306 | } |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 307 | pixelPtr = SkTAddOffset<void>(pixelPtr, rowBytes); |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 308 | } |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 309 | return SkCodec::kSuccess; |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 310 | } |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 311 | case SkCodec::kBottomUp_SkScanlineOrder: { |
msarett | 5af4e0b | 2015-11-17 11:18:03 -0800 | [diff] [blame] | 312 | // Note that these modes do not support subsetting. |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 313 | SkASSERT(0 == subsetY && nativeSize.height() == subsetHeight); |
| 314 | int y; |
| 315 | for (y = 0; y < nativeSize.height(); y++) { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 316 | int srcY = this->codec()->nextScanline(); |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 317 | if (is_coord_necessary(srcY, sampleY, dstHeight)) { |
| 318 | void* pixelPtr = SkTAddOffset<void>(pixels, |
| 319 | rowBytes * get_dst_coord(srcY, sampleY)); |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 320 | if (1 != this->codec()->getScanlines(pixelPtr, 1, rowBytes)) { |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 321 | break; |
| 322 | } |
| 323 | } else { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 324 | if (!this->codec()->skipScanlines(1)) { |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 325 | break; |
| 326 | } |
| 327 | } |
| 328 | } |
| 329 | |
| 330 | if (nativeSize.height() == y) { |
| 331 | return SkCodec::kSuccess; |
| 332 | } |
| 333 | |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 334 | // We handle filling uninitialized memory here instead of using this->codec(). |
| 335 | // this->codec() does not know that we are sampling. |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 336 | const SkImageInfo fillInfo = info.makeWH(info.width(), 1); |
| 337 | for (; y < nativeSize.height(); y++) { |
msarett | 90c4d5f | 2015-12-10 13:09:24 -0800 | [diff] [blame] | 338 | int srcY = this->codec()->outputScanline(y); |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 339 | if (!is_coord_necessary(srcY, sampleY, dstHeight)) { |
| 340 | continue; |
| 341 | } |
| 342 | |
| 343 | void* rowPtr = SkTAddOffset<void>(pixels, rowBytes * get_dst_coord(srcY, sampleY)); |
Leon Scroggins III | e643a9e | 2018-08-03 16:15:04 -0400 | [diff] [blame] | 344 | SkSampler::Fill(fillInfo, rowPtr, rowBytes, options.fZeroInitialized); |
msarett | 887e18e | 2015-11-17 08:46:02 -0800 | [diff] [blame] | 345 | } |
| 346 | return SkCodec::kIncompleteInput; |
| 347 | } |
msarett | 5406d6f | 2015-08-31 06:55:13 -0700 | [diff] [blame] | 348 | default: |
| 349 | SkASSERT(false); |
msarett | 3d9d7a7 | 2015-10-21 10:27:10 -0700 | [diff] [blame] | 350 | return SkCodec::kUnimplemented; |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 351 | } |
emmaleer | 8f4ba76 | 2015-08-14 07:44:46 -0700 | [diff] [blame] | 352 | } |