SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pixels, size_t rowBytes, const AndroidOptions& options) { // We should only call this function when sampling. SkASSERT(options.fSampleSize > 1); // Create options struct for the codec. SkCodec::Options sampledOptions; sampledOptions.fZeroInitialized = options.fZeroInitialized; sampledOptions.fPremulBehavior = SkTransferFunctionBehavior::kIgnore; // FIXME: This was already called by onGetAndroidPixels. Can we reduce that? int sampleSize = options.fSampleSize; int nativeSampleSize; SkISize nativeSize = this->accountForNativeScaling(&sampleSize, &nativeSampleSize); // Check if there is a subset. SkIRect subset; int subsetY = 0; int subsetWidth = nativeSize.width(); int subsetHeight = nativeSize.height(); if (options.fSubset) { // We will need to know about subsetting in the y-dimension in order to use the // scanline decoder. // Update the subset to account for scaling done by this->codec(). const SkIRect* subsetPtr = options.fSubset; // Do the divide ourselves, instead of calling get_scaled_dimension. If // X and Y are 0, they should remain 0, rather than being upgraded to 1 // due to being smaller than the sampleSize. const int subsetX = subsetPtr->x() / nativeSampleSize; subsetY = subsetPtr->y() / nativeSampleSize; subsetWidth = get_scaled_dimension(subsetPtr->width(), nativeSampleSize); subsetHeight = get_scaled_dimension(subsetPtr->height(), nativeSampleSize); // The scanline decoder only needs to be aware of subsetting in the x-dimension. subset.setXYWH(subsetX, 0, subsetWidth, nativeSize.height()); sampledOptions.fSubset = ⊂ } // Since we guarantee that output dimensions are always at least one (even if the sampleSize // is greater than a given dimension), the input sampleSize is not always the sampleSize that // we use in practice. const int sampleX = subsetWidth / info.width(); const int sampleY = subsetHeight / info.height(); const int samplingOffsetY = get_start_coord(sampleY); const int startY = samplingOffsetY + subsetY; const int dstHeight = info.height(); const SkImageInfo nativeInfo = info.makeWH(nativeSize.width(), nativeSize.height()); { // Although startScanlineDecode expects the bottom and top to match the // SkImageInfo, startIncrementalDecode uses them to determine which rows to // decode. SkCodec::Options incrementalOptions = sampledOptions; SkIRect incrementalSubset; if (sampledOptions.fSubset) { incrementalSubset.fTop = subsetY; incrementalSubset.fBottom = subsetY + subsetHeight; incrementalSubset.fLeft = sampledOptions.fSubset->fLeft; incrementalSubset.fRight = sampledOptions.fSubset->fRight; incrementalOptions.fSubset = &incrementalSubset; } const SkCodec::Result startResult = this->codec()->startIncrementalDecode(nativeInfo, pixels, rowBytes, &incrementalOptions); if (SkCodec::kSuccess == startResult) { SkSampler* sampler = this->codec()->getSampler(true); if (!sampler) { return SkCodec::kUnimplemented; } if (sampler->setSampleX(sampleX) != info.width()) { return SkCodec::kInvalidScale; } if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) { return SkCodec::kInvalidScale; } sampler->setSampleY(sampleY); int rowsDecoded; const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded); if (incResult == SkCodec::kSuccess) { return SkCodec::kSuccess; } SkASSERT(incResult == SkCodec::kIncompleteInput || incResult == SkCodec::kErrorInInput); SkASSERT(rowsDecoded <= info.height()); this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, info.height(), rowsDecoded); return incResult; } else if (startResult != SkCodec::kUnimplemented) { return startResult; } // kUnimplemented means use the old method. } // Start the scanline decode. SkCodec::Result result = this->codec()->startScanlineDecode(nativeInfo, &sampledOptions); if (SkCodec::kSuccess != result) { return result; } SkSampler* sampler = this->codec()->getSampler(true); if (!sampler) { return SkCodec::kUnimplemented; } if (sampler->setSampleX(sampleX) != info.width()) { return SkCodec::kInvalidScale; } if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) { return SkCodec::kInvalidScale; } switch(this->codec()->getScanlineOrder()) { case SkCodec::kTopDown_SkScanlineOrder: { if (!this->codec()->skipScanlines(startY)) { this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, dstHeight, 0); return SkCodec::kIncompleteInput; } void* pixelPtr = pixels; for (int y = 0; y < dstHeight; y++) { if (1 != this->codec()->getScanlines(pixelPtr, 1, rowBytes)) { this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, dstHeight, y + 1); return SkCodec::kIncompleteInput; } if (y < dstHeight - 1) { if (!this->codec()->skipScanlines(sampleY - 1)) { this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized, dstHeight, y + 1); return SkCodec::kIncompleteInput; } } pixelPtr = SkTAddOffset<void>(pixelPtr, rowBytes); } return SkCodec::kSuccess; } case SkCodec::kBottomUp_SkScanlineOrder: { // Note that these modes do not support subsetting. SkASSERT(0 == subsetY && nativeSize.height() == subsetHeight); int y; for (y = 0; y < nativeSize.height(); y++) { int srcY = this->codec()->nextScanline(); if (is_coord_necessary(srcY, sampleY, dstHeight)) { void* pixelPtr = SkTAddOffset<void>(pixels, rowBytes * get_dst_coord(srcY, sampleY)); if (1 != this->codec()->getScanlines(pixelPtr, 1, rowBytes)) { break; } } else { if (!this->codec()->skipScanlines(1)) { break; } } } if (nativeSize.height() == y) { return SkCodec::kSuccess; } // We handle filling uninitialized memory here instead of using this->codec(). // this->codec() does not know that we are sampling. const uint64_t fillValue = this->codec()->getFillValue(info); const SkImageInfo fillInfo = info.makeWH(info.width(), 1); for (; y < nativeSize.height(); y++) { int srcY = this->codec()->outputScanline(y); if (!is_coord_necessary(srcY, sampleY, dstHeight)) { continue; } void* rowPtr = SkTAddOffset<void>(pixels, rowBytes * get_dst_coord(srcY, sampleY)); SkSampler::Fill(fillInfo, rowPtr, rowBytes, fillValue, options.fZeroInitialized); } return SkCodec::kIncompleteInput; } default: SkASSERT(false); return SkCodec::kUnimplemented; } }