src/codec/SkScaledCodec.cpp - skia - Git at Google

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkSampledCodec.h"

 // FIXME: Rename this file to SkSampledCodec.cpp

 SkSampledCodec::SkSampledCodec(SkCodec* codec)
     : INHERITED(codec->getInfo())
     , fCodec(codec)
 {}

 SkISize SkSampledCodec::onGetSampledDimensions(int sampleSize) const {
     // Fast path for when we are not scaling.
     if (1 == sampleSize) {
         return fCodec->getInfo().dimensions();
     }

     const int width = fCodec->getInfo().width();
     const int height = fCodec->getInfo().height();

     // Check if the codec can provide the scaling natively.
     float scale = get_scale_from_sample_size(sampleSize);
     SkSize idealSize = SkSize::Make(scale * (float) width, scale * (float) height);
     SkISize nativeSize = fCodec->getScaledDimensions(scale);
     float widthDiff = SkTAbs(((float) nativeSize.width()) - idealSize.width());
     float heightDiff = SkTAbs(((float) nativeSize.height()) - idealSize.height());
     // Native scaling is preferred to sampling.  If we can scale natively to
     // within one of the ideal value, we should choose to scale natively.
     if (widthDiff < 1.0f && heightDiff < 1.0f) {
         return nativeSize;
     }

     // Provide the scaling by sampling.
     return SkISize::Make(get_scaled_dimension(width, sampleSize),
             get_scaled_dimension(height, sampleSize));
 }

 SkCodec::Result SkSampledCodec::onGetAndroidPixels(const SkImageInfo& info, void* pixels,
         size_t rowBytes, AndroidOptions& options) {
     // Create an Options struct for the codec.
     SkCodec::Options codecOptions;
     codecOptions.fZeroInitialized = options.fZeroInitialized;

     SkIRect* subset = options.fSubset;
     if (!subset || subset->size() == fCodec->getInfo().dimensions()) {
         if (fCodec->dimensionsSupported(info.dimensions())) {
             return fCodec->getPixels(info, pixels, rowBytes, &codecOptions, options.fColorPtr,
                     options.fColorCount);
         }

         // If the native codec does not support the requested scale, scale by sampling.
         return this->sampledDecode(info, pixels, rowBytes, options);
     }

     // We are performing a subset decode.
     int sampleSize = options.fSampleSize;
     SkISize scaledSize = this->onGetSampledDimensions(sampleSize);
     if (!fCodec->dimensionsSupported(scaledSize)) {
         // If the native codec does not support the requested scale, scale by sampling.
         return this->sampledDecode(info, pixels, rowBytes, options);
     }

     // Calculate the scaled subset bounds.
     int scaledSubsetX = subset->x() / sampleSize;
     int scaledSubsetY = subset->y() / sampleSize;
     int scaledSubsetWidth = info.width();
     int scaledSubsetHeight = info.height();

     // Start the scanline decode.
     SkIRect scanlineSubset = SkIRect::MakeXYWH(scaledSubsetX, 0, scaledSubsetWidth,
             scaledSize.height());
     codecOptions.fSubset = &scanlineSubset;
     SkCodec::Result result = fCodec->startScanlineDecode(info.makeWH(scaledSize.width(),
             scaledSize.height()), &codecOptions, options.fColorPtr, options.fColorCount);
     if (SkCodec::kSuccess != result) {
         return result;
     }

     // At this point, we are only concerned with subsetting.  Either no scale was
     // requested, or the fCodec is handling the scale.
     switch (fCodec->getScanlineOrder()) {
         case SkCodec::kTopDown_SkScanlineOrder:
         case SkCodec::kNone_SkScanlineOrder: {
             if (!fCodec->skipScanlines(scaledSubsetY)) {
                 fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                         scaledSubsetHeight, 0);
                 return SkCodec::kIncompleteInput;
             }

             int decodedLines = fCodec->getScanlines(pixels, scaledSubsetHeight, rowBytes);
             if (decodedLines != scaledSubsetHeight) {
                 return SkCodec::kIncompleteInput;
             }
             return SkCodec::kSuccess;
         }
         default:
             SkASSERT(false);
             return SkCodec::kUnimplemented;
     }
 }


 SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pixels,
         size_t rowBytes, AndroidOptions& options) {
     // Create options struct for the codec.
     SkCodec::Options sampledOptions;
     sampledOptions.fZeroInitialized = options.fZeroInitialized;

     // Check if there is a subset.
     SkIRect subset;
     int subsetY = 0;
     int subsetWidth = fCodec->getInfo().width();
     int subsetHeight = fCodec->getInfo().height();
     if (options.fSubset) {
         // We will need to know about subsetting in the y-dimension in order to use the
         // scanline decoder.
         SkIRect* subsetPtr = options.fSubset;
         subsetY = subsetPtr->y();
         subsetWidth = subsetPtr->width();
         subsetHeight = subsetPtr->height();

         // The scanline decoder only needs to be aware of subsetting in the x-dimension.
         subset.setXYWH(subsetPtr->x(), 0, subsetWidth, fCodec->getInfo().height());
         sampledOptions.fSubset = &subset;
     }

     // Start the scanline decode.
     SkCodec::Result result = fCodec->startScanlineDecode(
             info.makeWH(fCodec->getInfo().width(), fCodec->getInfo().height()), &sampledOptions,
             options.fColorPtr, options.fColorCount);
     if (SkCodec::kSuccess != result) {
         return result;
     }

     SkSampler* sampler = fCodec->getSampler(true);
     if (!sampler) {
         return SkCodec::kUnimplemented;
     }

     // 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();
     if (sampler->setSampleX(sampleX) != info.width()) {
         return SkCodec::kInvalidScale;
     }
     if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) {
         return SkCodec::kInvalidScale;
     }

     const int samplingOffsetY = get_start_coord(sampleY);
     const int startY = samplingOffsetY + subsetY;
     int dstHeight = info.height();
     switch(fCodec->getScanlineOrder()) {
         case SkCodec::kTopDown_SkScanlineOrder: {
             if (!fCodec->skipScanlines(startY)) {
                 fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                         dstHeight, 0);
                 return SkCodec::kIncompleteInput;
             }
             void* pixelPtr = pixels;
             for (int y = 0; y < dstHeight; y++) {
                 if (1 != fCodec->getScanlines(pixelPtr, 1, rowBytes)) {
                     fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                             dstHeight, y + 1);
                     return SkCodec::kIncompleteInput;
                 }
                 int linesToSkip = SkTMin(sampleY - 1, dstHeight - y - 1);
                 if (!fCodec->skipScanlines(linesToSkip)) {
                     fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                             dstHeight, y + 1);
                     return SkCodec::kIncompleteInput;
                 }
                 pixelPtr = SkTAddOffset<void>(pixelPtr, rowBytes);
             }
             return SkCodec::kSuccess;
         }
         case SkCodec::kNone_SkScanlineOrder: {
             const int linesNeeded = subsetHeight - samplingOffsetY;
             SkAutoMalloc storage(linesNeeded * rowBytes);
             uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());

             if (!fCodec->skipScanlines(startY)) {
                 fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                         dstHeight, 0);
                 return SkCodec::kIncompleteInput;
             }
             int scanlines = fCodec->getScanlines(storagePtr, linesNeeded, rowBytes);

             for (int y = 0; y < dstHeight; y++) {
                 memcpy(pixels, storagePtr, info.minRowBytes());
                 storagePtr += sampleY * rowBytes;
                 pixels = SkTAddOffset<void>(pixels, rowBytes);
             }

             if (scanlines < dstHeight) {
                 // fCodec has already handled filling uninitialized memory.
                 return SkCodec::kIncompleteInput;
             }
             return SkCodec::kSuccess;
         }
         default:
             SkASSERT(false);
             return SkCodec::kUnimplemented;
     }
 }
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SkCodec.h"
	#include "SkCodecPriv.h"
	#include "SkSampledCodec.h"

	// FIXME: Rename this file to SkSampledCodec.cpp

	SkSampledCodec::SkSampledCodec(SkCodec* codec)
	: INHERITED(codec->getInfo())
	, fCodec(codec)
	{}

	SkISize SkSampledCodec::onGetSampledDimensions(int sampleSize) const {
	// Fast path for when we are not scaling.
	if (1 == sampleSize) {
	return fCodec->getInfo().dimensions();
	}

	const int width = fCodec->getInfo().width();
	const int height = fCodec->getInfo().height();

	// Check if the codec can provide the scaling natively.
	float scale = get_scale_from_sample_size(sampleSize);
	SkSize idealSize = SkSize::Make(scale * (float) width, scale * (float) height);
	SkISize nativeSize = fCodec->getScaledDimensions(scale);
	float widthDiff = SkTAbs(((float) nativeSize.width()) - idealSize.width());
	float heightDiff = SkTAbs(((float) nativeSize.height()) - idealSize.height());
	// Native scaling is preferred to sampling. If we can scale natively to
	// within one of the ideal value, we should choose to scale natively.
	if (widthDiff < 1.0f && heightDiff < 1.0f) {
	return nativeSize;
	}

	// Provide the scaling by sampling.
	return SkISize::Make(get_scaled_dimension(width, sampleSize),
	get_scaled_dimension(height, sampleSize));
	}

	SkCodec::Result SkSampledCodec::onGetAndroidPixels(const SkImageInfo& info, void* pixels,
	size_t rowBytes, AndroidOptions& options) {
	// Create an Options struct for the codec.
	SkCodec::Options codecOptions;
	codecOptions.fZeroInitialized = options.fZeroInitialized;

	SkIRect* subset = options.fSubset;
	if (!subset \|\| subset->size() == fCodec->getInfo().dimensions()) {
	if (fCodec->dimensionsSupported(info.dimensions())) {
	return fCodec->getPixels(info, pixels, rowBytes, &codecOptions, options.fColorPtr,
	options.fColorCount);
	}

	// If the native codec does not support the requested scale, scale by sampling.
	return this->sampledDecode(info, pixels, rowBytes, options);
	}

	// We are performing a subset decode.
	int sampleSize = options.fSampleSize;
	SkISize scaledSize = this->onGetSampledDimensions(sampleSize);
	if (!fCodec->dimensionsSupported(scaledSize)) {
	// If the native codec does not support the requested scale, scale by sampling.
	return this->sampledDecode(info, pixels, rowBytes, options);
	}

	// Calculate the scaled subset bounds.
	int scaledSubsetX = subset->x() / sampleSize;
	int scaledSubsetY = subset->y() / sampleSize;
	int scaledSubsetWidth = info.width();
	int scaledSubsetHeight = info.height();

	// Start the scanline decode.
	SkIRect scanlineSubset = SkIRect::MakeXYWH(scaledSubsetX, 0, scaledSubsetWidth,
	scaledSize.height());
	codecOptions.fSubset = &scanlineSubset;
	SkCodec::Result result = fCodec->startScanlineDecode(info.makeWH(scaledSize.width(),
	scaledSize.height()), &codecOptions, options.fColorPtr, options.fColorCount);
	if (SkCodec::kSuccess != result) {
	return result;
	}

	// At this point, we are only concerned with subsetting. Either no scale was
	// requested, or the fCodec is handling the scale.
	switch (fCodec->getScanlineOrder()) {
	case SkCodec::kTopDown_SkScanlineOrder:
	case SkCodec::kNone_SkScanlineOrder: {
	if (!fCodec->skipScanlines(scaledSubsetY)) {
	fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
	scaledSubsetHeight, 0);
	return SkCodec::kIncompleteInput;
	}

	int decodedLines = fCodec->getScanlines(pixels, scaledSubsetHeight, rowBytes);
	if (decodedLines != scaledSubsetHeight) {
	return SkCodec::kIncompleteInput;
	}
	return SkCodec::kSuccess;
	}
	default:
	SkASSERT(false);
	return SkCodec::kUnimplemented;
	}
	}


	SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pixels,
	size_t rowBytes, AndroidOptions& options) {
	// Create options struct for the codec.
	SkCodec::Options sampledOptions;
	sampledOptions.fZeroInitialized = options.fZeroInitialized;

	// Check if there is a subset.
	SkIRect subset;
	int subsetY = 0;
	int subsetWidth = fCodec->getInfo().width();
	int subsetHeight = fCodec->getInfo().height();
	if (options.fSubset) {
	// We will need to know about subsetting in the y-dimension in order to use the
	// scanline decoder.
	SkIRect* subsetPtr = options.fSubset;
	subsetY = subsetPtr->y();
	subsetWidth = subsetPtr->width();
	subsetHeight = subsetPtr->height();

	// The scanline decoder only needs to be aware of subsetting in the x-dimension.
	subset.setXYWH(subsetPtr->x(), 0, subsetWidth, fCodec->getInfo().height());
	sampledOptions.fSubset = &subset;
	}

	// Start the scanline decode.
	SkCodec::Result result = fCodec->startScanlineDecode(
	info.makeWH(fCodec->getInfo().width(), fCodec->getInfo().height()), &sampledOptions,
	options.fColorPtr, options.fColorCount);
	if (SkCodec::kSuccess != result) {
	return result;
	}

	SkSampler* sampler = fCodec->getSampler(true);
	if (!sampler) {
	return SkCodec::kUnimplemented;
	}

	// 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();
	if (sampler->setSampleX(sampleX) != info.width()) {
	return SkCodec::kInvalidScale;
	}
	if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) {
	return SkCodec::kInvalidScale;
	}

	const int samplingOffsetY = get_start_coord(sampleY);
	const int startY = samplingOffsetY + subsetY;
	int dstHeight = info.height();
	switch(fCodec->getScanlineOrder()) {
	case SkCodec::kTopDown_SkScanlineOrder: {
	if (!fCodec->skipScanlines(startY)) {
	fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
	dstHeight, 0);
	return SkCodec::kIncompleteInput;
	}
	void* pixelPtr = pixels;
	for (int y = 0; y < dstHeight; y++) {
	if (1 != fCodec->getScanlines(pixelPtr, 1, rowBytes)) {
	fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
	dstHeight, y + 1);
	return SkCodec::kIncompleteInput;
	}
	int linesToSkip = SkTMin(sampleY - 1, dstHeight - y - 1);
	if (!fCodec->skipScanlines(linesToSkip)) {
	fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
	dstHeight, y + 1);
	return SkCodec::kIncompleteInput;
	}
	pixelPtr = SkTAddOffset<void>(pixelPtr, rowBytes);
	}
	return SkCodec::kSuccess;
	}
	case SkCodec::kNone_SkScanlineOrder: {
	const int linesNeeded = subsetHeight - samplingOffsetY;
	SkAutoMalloc storage(linesNeeded * rowBytes);
	uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());

	if (!fCodec->skipScanlines(startY)) {
	fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
	dstHeight, 0);
	return SkCodec::kIncompleteInput;
	}
	int scanlines = fCodec->getScanlines(storagePtr, linesNeeded, rowBytes);

	for (int y = 0; y < dstHeight; y++) {
	memcpy(pixels, storagePtr, info.minRowBytes());
	storagePtr += sampleY * rowBytes;
	pixels = SkTAddOffset<void>(pixels, rowBytes);
	}

	if (scanlines < dstHeight) {
	// fCodec has already handled filling uninitialized memory.
	return SkCodec::kIncompleteInput;
	}
	return SkCodec::kSuccess;
	}
	default:
	SkASSERT(false);
	return SkCodec::kUnimplemented;
	}
	}