From 910f7ec7e79cd051f69b47c3e19d4fda2adbcef4 Mon Sep 17 00:00:00 2001 From: msarett Date: Thu, 24 Mar 2016 04:45:39 -0700 Subject: Revert of Delete SkImageDecoder (patchset #9 id:150001 of https://codereview.chromium.org/1820503002/ ) Reason for revert: Roll still failing Original issue's description: > Delete SkImageDecoder > > This image decoding implementation has been replaced > by SkCodec in Android. > > Additionally, we have replaced uses of SkImageDecoder > in Skia and Google3 with uses of SkCodec. > > Now we can delete SkImageDecoder :). > > BUG=skia: > GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1820503002 > CQ_EXTRA_TRYBOTS=client.skia.compile:Build-Ubuntu-GCC-x86_64-Release-CMake-Trybot,Build-Mac-Clang-x86_64-Release-CMake-Trybot > > Committed: https://skia.googlesource.com/skia/+/f799706656f2581c5bf5510d94df3fa17cce1607 > > Committed: https://skia.googlesource.com/skia/+/5b6e73e0c8282c4d85accbfbcecc6dee84f8a1eb > > Committed: https://skia.googlesource.com/skia/+/f037fdebda2a2626e6512d7532063f2cd41a264d TBR=scroggo@google.com,djsollen@google.com # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=skia: Review URL: https://codereview.chromium.org/1830943002 --- include/core/SkCanvas.h | 2 +- include/core/SkImageDecoder.h | 413 ++++++++++++++++++++++++++++++++++++++++ include/core/SkImageEncoder.h | 8 +- include/core/SkPicture.h | 5 +- include/core/SkPngChunkReader.h | 2 +- include/core/SkWriteBuffer.h | 1 - 6 files changed, 418 insertions(+), 13 deletions(-) create mode 100644 include/core/SkImageDecoder.h (limited to 'include') diff --git a/include/core/SkCanvas.h b/include/core/SkCanvas.h index b77e8a7689..bdb2eb0706 100644 --- a/include/core/SkCanvas.h +++ b/include/core/SkCanvas.h @@ -11,7 +11,6 @@ #include "SkTypes.h" #include "SkBitmap.h" #include "SkDeque.h" -#include "SkImage.h" #include "SkPaint.h" #include "SkRefCnt.h" #include "SkRegion.h" @@ -27,6 +26,7 @@ class SkData; class SkDraw; class SkDrawable; class SkDrawFilter; +class SkImage; class SkImageFilter; class SkMetaData; class SkPath; diff --git a/include/core/SkImageDecoder.h b/include/core/SkImageDecoder.h new file mode 100644 index 0000000000..7a90964b13 --- /dev/null +++ b/include/core/SkImageDecoder.h @@ -0,0 +1,413 @@ +/* + * Copyright 2006 The Android Open Source Project + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkImageDecoder_DEFINED +#define SkImageDecoder_DEFINED + +#include "SkBitmap.h" +#include "SkImage.h" +#include "SkPngChunkReader.h" +#include "SkRect.h" +#include "SkRefCnt.h" +#include "SkTRegistry.h" +#include "SkTypes.h" + +class SkStream; +class SkStreamRewindable; + +/** \class SkImageDecoder + + DEPRECATED Please use SkImage::NewFromEncoded() or SkImageGenerator::NewFromEncoded(). + + Base class for decoding compressed images into a SkBitmap +*/ +class SkImageDecoder : SkNoncopyable { +public: + virtual ~SkImageDecoder(); + + // TODO (scroggo): Merge with SkEncodedFormat + enum Format { + kUnknown_Format, + kBMP_Format, + kGIF_Format, + kICO_Format, + kJPEG_Format, + kPNG_Format, + kWBMP_Format, + kWEBP_Format, + kPKM_Format, + kKTX_Format, + kASTC_Format, + + kLastKnownFormat = kKTX_Format, + }; + + /** Return the format of image this decoder can decode. If this decoder can decode multiple + formats, kUnknown_Format will be returned. + */ + virtual Format getFormat() const; + + /** If planes or rowBytes is NULL, decodes the header and computes componentSizes + for memory allocation. + Otherwise, decodes the YUV planes into the provided image planes and + updates componentSizes to the final image size. + Returns whether the decoding was successful. + */ + bool decodeYUV8Planes(SkStream* stream, SkISize componentSizes[3], void* planes[3], + size_t rowBytes[3], SkYUVColorSpace*); + + /** Return the format of the SkStreamRewindable or kUnknown_Format if it cannot be determined. + Rewinds the stream before returning. + */ + static Format GetStreamFormat(SkStreamRewindable*); + + /** Return a readable string of the Format provided. + */ + static const char* GetFormatName(Format); + + /** Return a readable string of the value returned by getFormat(). + */ + const char* getFormatName() const; + + /** Whether the decoder should skip writing zeroes to output if possible. + */ + bool getSkipWritingZeroes() const { return fSkipWritingZeroes; } + + /** Set to true if the decoder should skip writing any zeroes when + creating the output image. + This is a hint that may not be respected by the decoder. + It should only be used if it is known that the memory to write + to has already been set to 0; otherwise the resulting image will + have garbage. + This is ideal for images that contain a lot of completely transparent + pixels, but may be a performance hit for an image that has only a + few transparent pixels. + The default is false. + */ + void setSkipWritingZeroes(bool skip) { fSkipWritingZeroes = skip; } + + /** Returns true if the decoder should try to dither the resulting image. + The default setting is true. + */ + bool getDitherImage() const { return fDitherImage; } + + /** Set to true if the the decoder should try to dither the resulting image. + The default setting is true. + */ + void setDitherImage(bool dither) { fDitherImage = dither; } + + /** Returns true if the decoder should try to decode the + resulting image to a higher quality even at the expense of + the decoding speed. + */ + bool getPreferQualityOverSpeed() const { return fPreferQualityOverSpeed; } + + /** Set to true if the the decoder should try to decode the + resulting image to a higher quality even at the expense of + the decoding speed. + */ + void setPreferQualityOverSpeed(bool qualityOverSpeed) { + fPreferQualityOverSpeed = qualityOverSpeed; + } + + /** Set to true to require the decoder to return a bitmap with unpremultiplied + colors. The default is false, meaning the resulting bitmap will have its + colors premultiplied. + NOTE: Passing true to this function may result in a bitmap which cannot + be properly used by Skia. + */ + void setRequireUnpremultipliedColors(bool request) { + fRequireUnpremultipliedColors = request; + } + + /** Returns true if the decoder will only return bitmaps with unpremultiplied + colors. + */ + bool getRequireUnpremultipliedColors() const { return fRequireUnpremultipliedColors; } + + SkPngChunkReader* getPeeker() const { return fPeeker; } + SkPngChunkReader* setPeeker(SkPngChunkReader*); + + /** + * By default, the codec will try to comply with the "pref" colortype + * that is passed to decode() or decodeSubset(). However, this can be called + * to override that, causing the codec to try to match the src depth instead + * (as shown below). + * + * src_8Index -> kIndex_8_SkColorType + * src_8Gray -> kN32_SkColorType + * src_8bpc -> kN32_SkColorType + */ + void setPreserveSrcDepth(bool preserve) { + fPreserveSrcDepth = preserve; + } + + SkBitmap::Allocator* getAllocator() const { return fAllocator; } + SkBitmap::Allocator* setAllocator(SkBitmap::Allocator*); + + // sample-size, if set to > 1, tells the decoder to return a smaller than + // original bitmap, sampling 1 pixel for every size pixels. e.g. if sample + // size is set to 3, then the returned bitmap will be 1/3 as wide and high, + // and will contain 1/9 as many pixels as the original. + // Note: this is a hint, and the codec may choose to ignore this, or only + // approximate the sample size. + int getSampleSize() const { return fSampleSize; } + void setSampleSize(int size); + + /** Reset the sampleSize to its default of 1 + */ + void resetSampleSize() { this->setSampleSize(1); } + + /** Decoding is synchronous, but for long decodes, a different thread can + call this method safely. This sets a state that the decoders will + periodically check, and if they see it changed to cancel, they will + cancel. This will result in decode() returning false. However, there is + no guarantee that the decoder will see the state change in time, so + it is possible that cancelDecode() will be called, but will be ignored + and decode() will return true (assuming no other problems were + encountered). + + This state is automatically reset at the beginning of decode(). + */ + void cancelDecode() { + // now the subclass must query shouldCancelDecode() to be informed + // of the request + fShouldCancelDecode = true; + } + + /** Passed to the decode method. If kDecodeBounds_Mode is passed, then + only the bitmap's info need be set. If kDecodePixels_Mode + is passed, then the bitmap must have pixels or a pixelRef. + */ + enum Mode { + kDecodeBounds_Mode, //!< only return info in bitmap + kDecodePixels_Mode //!< return entire bitmap (including pixels) + }; + + /** Result of a decode. If read as a boolean, a partial success is + considered a success (true). + */ + enum Result { + kFailure = 0, //!< Image failed to decode. bitmap will be + // unchanged. + kPartialSuccess = 1, //!< Part of the image decoded. The rest is + // filled in automatically + kSuccess = 2 //!< The entire image was decoded, if Mode is + // kDecodePixels_Mode, or the bounds were + // decoded, in kDecodeBounds_Mode. + }; + + /** Given a stream, decode it into the specified bitmap. + If the decoder can decompress the image, it calls bitmap.setInfo(), + and then if the Mode is kDecodePixels_Mode, call allocPixelRef(), + which will allocated a pixelRef. To access the pixel memory, the codec + needs to call lockPixels/unlockPixels on the + bitmap. It can then set the pixels with the decompressed image. + * If the image cannot be decompressed, return kFailure. After the + * decoding, the function converts the decoded colortype in bitmap + * to pref if possible. Whether a conversion is feasible is + * tested by Bitmap::canCopyTo(pref). + + If an SkBitmap::Allocator is installed via setAllocator, it will be + used to allocate the pixel memory. A clever allocator can be used + to allocate the memory from a cache, volatile memory, or even from + an existing bitmap's memory. + + If an SkPngChunkReader is installed via setPeeker, it may be used to + peek into meta data during the decode. + */ + Result decode(SkStream*, SkBitmap* bitmap, SkColorType pref, Mode); + Result decode(SkStream* stream, SkBitmap* bitmap, Mode mode) { + return this->decode(stream, bitmap, kUnknown_SkColorType, mode); + } + + /** Given a stream, this will try to find an appropriate decoder object. + If none is found, the method returns NULL. + + DEPRECATED Please use SkImage::NewFromEncoded() or SkImageGenerator::NewFromEncoded(). + */ + static SkImageDecoder* Factory(SkStreamRewindable*); + + /** Decode the image stored in the specified file, and store the result + in bitmap. Return true for success or false on failure. + + @param pref Prefer this colortype. + + @param format On success, if format is non-null, it is set to the format + of the decoded file. On failure it is ignored. + + DEPRECATED Do not use. + */ + static bool DecodeFile(const char file[], SkBitmap* bitmap, SkColorType pref, Mode, + Format* format = NULL); + static bool DecodeFile(const char file[], SkBitmap* bitmap) { + return DecodeFile(file, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL); + } + + /** Decode the image stored in the specified memory buffer, and store the + result in bitmap. Return true for success or false on failure. + + @param pref Prefer this colortype. + + @param format On success, if format is non-null, it is set to the format + of the decoded buffer. On failure it is ignored. + + DEPRECATED Please use SkImage::NewFromEncoded() or SkImageGenerator::NewFromEncoded(). + */ + static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap, SkColorType pref, + Mode, Format* format = NULL); + static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap){ + return DecodeMemory(buffer, size, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL); + } + + /** Decode the image stored in the specified SkStreamRewindable, and store the result + in bitmap. Return true for success or false on failure. + + @param pref Prefer this colortype. + + @param format On success, if format is non-null, it is set to the format + of the decoded stream. On failure it is ignored. + + DEPRECATED Please use SkImage::NewFromEncoded() or SkImageGenerator::NewFromEncoded(). + */ + static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap, SkColorType pref, Mode, + Format* format = NULL); + static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap) { + return DecodeStream(stream, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL); + } + +protected: + // must be overridden in subclasses. This guy is called by decode(...) + virtual Result onDecode(SkStream*, SkBitmap* bitmap, Mode) = 0; + + /** If planes or rowBytes is NULL, decodes the header and computes componentSizes + for memory allocation. + Otherwise, decodes the YUV planes into the provided image planes and + updates componentSizes to the final image size. + Returns whether the decoding was successful. + */ + virtual bool onDecodeYUV8Planes(SkStream*, SkISize[3] /*componentSizes*/, + void*[3] /*planes*/, size_t[3] /*rowBytes*/, + SkYUVColorSpace*) { + return false; + } + + /** + * Copy all fields on this decoder to the other decoder. Used by subclasses + * to decode a subimage using a different decoder, but with the same settings. + */ + void copyFieldsToOther(SkImageDecoder* other); + + /** Can be queried from within onDecode, to see if the user (possibly in + a different thread) has requested the decode to cancel. If this returns + true, your onDecode() should stop and return false. + Each subclass needs to decide how often it can query this, to balance + responsiveness with performance. + + Calling this outside of onDecode() may return undefined values. + */ + +public: + bool shouldCancelDecode() const { return fShouldCancelDecode; } + +protected: + SkImageDecoder(); + + /** + * Return the default preference being used by the current or latest call to decode. + */ + SkColorType getDefaultPref() { return fDefaultPref; } + + /* Helper for subclasses. Call this to allocate the pixel memory given the bitmap's info. + Returns true on success. This method handles checking for an optional Allocator. + */ + bool allocPixelRef(SkBitmap*, SkColorTable*) const; + + /** + * The raw data of the src image. + */ + enum SrcDepth { + // Color-indexed. + kIndex_SrcDepth, + // Grayscale in 8 bits. + k8BitGray_SrcDepth, + // 8 bits per component. Used for 24 bit if there is no alpha. + k32Bit_SrcDepth, + }; + /** The subclass, inside onDecode(), calls this to determine the colorType of + the returned bitmap. SrcDepth and hasAlpha reflect the raw data of the + src image. This routine returns the caller's preference given + srcDepth and hasAlpha, or kUnknown_SkColorType if there is no preference. + */ + SkColorType getPrefColorType(SrcDepth, bool hasAlpha) const; + +private: + SkPngChunkReader* fPeeker; + SkBitmap::Allocator* fAllocator; + int fSampleSize; + SkColorType fDefaultPref; // use if fUsePrefTable is false + bool fPreserveSrcDepth; + bool fDitherImage; + bool fSkipWritingZeroes; + mutable bool fShouldCancelDecode; + bool fPreferQualityOverSpeed; + bool fRequireUnpremultipliedColors; +}; + +/** Calling newDecoder with a stream returns a new matching imagedecoder + instance, or NULL if none can be found. The caller must manage its ownership + of the stream as usual, calling unref() when it is done, as the returned + decoder may have called ref() (and if so, the decoder is responsible for + balancing its ownership when it is destroyed). + */ +class SkImageDecoderFactory : public SkRefCnt { +public: + + + virtual SkImageDecoder* newDecoder(SkStreamRewindable*) = 0; + +private: + typedef SkRefCnt INHERITED; +}; + +class SkDefaultImageDecoderFactory : SkImageDecoderFactory { +public: + // calls SkImageDecoder::Factory(stream) + virtual SkImageDecoder* newDecoder(SkStreamRewindable* stream) { + return SkImageDecoder::Factory(stream); + } +}; + +// This macro declares a global (i.e., non-class owned) creation entry point +// for each decoder (e.g., CreateJPEGImageDecoder) +#define DECLARE_DECODER_CREATOR(codec) \ + SkImageDecoder *Create ## codec (); + +// This macro defines the global creation entry point for each decoder. Each +// decoder implementation that registers with the decoder factory must call it. +#define DEFINE_DECODER_CREATOR(codec) \ + SkImageDecoder* Create##codec() { return new Sk##codec; } + +// All the decoders known by Skia. Note that, depending on the compiler settings, +// not all of these will be available +DECLARE_DECODER_CREATOR(BMPImageDecoder); +DECLARE_DECODER_CREATOR(GIFImageDecoder); +DECLARE_DECODER_CREATOR(ICOImageDecoder); +DECLARE_DECODER_CREATOR(JPEGImageDecoder); +DECLARE_DECODER_CREATOR(PNGImageDecoder); +DECLARE_DECODER_CREATOR(WBMPImageDecoder); +DECLARE_DECODER_CREATOR(WEBPImageDecoder); +DECLARE_DECODER_CREATOR(PKMImageDecoder); +DECLARE_DECODER_CREATOR(KTXImageDecoder); +DECLARE_DECODER_CREATOR(ASTCImageDecoder); + +// Typedefs to make registering decoder and formatter callbacks easier. +// These have to be defined outside SkImageDecoder. :( +typedef SkTRegistry SkImageDecoder_DecodeReg; +typedef SkTRegistry SkImageDecoder_FormatReg; + +#endif diff --git a/include/core/SkImageEncoder.h b/include/core/SkImageEncoder.h index 1ccfae0bf9..bb3341f836 100644 --- a/include/core/SkImageEncoder.h +++ b/include/core/SkImageEncoder.h @@ -110,12 +110,8 @@ DECLARE_ENCODER_CREATOR(PNGImageEncoder); DECLARE_ENCODER_CREATOR(KTXImageEncoder); DECLARE_ENCODER_CREATOR(WEBPImageEncoder); -#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS) -DECLARE_ENCODER_CREATOR(PNGImageEncoder_CG); -#endif - -#if defined(SK_BUILD_FOR_WIN) -DECLARE_ENCODER_CREATOR(ImageEncoder_WIC); +#ifdef SK_BUILD_FOR_IOS +DECLARE_ENCODER_CREATOR(PNGImageEncoder_IOS); #endif // Typedef to make registering encoder callback easier diff --git a/include/core/SkPicture.h b/include/core/SkPicture.h index 0cf9411f56..6c0dda0d3e 100644 --- a/include/core/SkPicture.h +++ b/include/core/SkPicture.h @@ -8,23 +8,20 @@ #ifndef SkPicture_DEFINED #define SkPicture_DEFINED +#include "SkImageDecoder.h" #include "SkRefCnt.h" -#include "SkRect.h" #include "SkTypes.h" class GrContext; class SkBigPicture; class SkBitmap; class SkCanvas; -class SkPath; class SkPictureData; class SkPixelSerializer; -class SkReadBuffer; class SkRefCntSet; class SkStream; class SkTypefacePlayback; class SkWStream; -class SkWriteBuffer; struct SkPictInfo; #define SK_SUPPORT_LEGACY_PICTURE_PTR diff --git a/include/core/SkPngChunkReader.h b/include/core/SkPngChunkReader.h index 0cd6634bce..f424dd8cfc 100644 --- a/include/core/SkPngChunkReader.h +++ b/include/core/SkPngChunkReader.h @@ -16,7 +16,7 @@ * * Base class for optional callbacks to retrieve meta/chunk data out of a PNG * encoded image as it is being decoded. - * Used by SkCodec. + * Used by SkImageDecoder and SkCodec. */ class SkPngChunkReader : public SkRefCnt { public: diff --git a/include/core/SkWriteBuffer.h b/include/core/SkWriteBuffer.h index 6e9d043aeb..8e4607887d 100644 --- a/include/core/SkWriteBuffer.h +++ b/include/core/SkWriteBuffer.h @@ -10,7 +10,6 @@ #define SkWriteBuffer_DEFINED #include "SkData.h" -#include "SkImage.h" #include "SkPath.h" #include "SkPicture.h" #include "SkPixelSerializer.h" -- cgit v1.2.3