src/codec/SkSwizzler.h - platform/external/skqp - Gitiles

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

 #ifndef SkSwizzler_DEFINED
 #define SkSwizzler_DEFINED

 #include "SkCodec.h"
 #include "SkColor.h"
 #include "SkImageInfo.h"
 #include "SkSampler.h"

 class SkSwizzler : public SkSampler {
 public:
     /**
      *  Create a new SkSwizzler.
      *  @param encodedInfo Description of the format of the encoded data.
      *  @param ctable Unowned pointer to an array of up to 256 colors for an
      *                index source.
      *  @param dstInfo Describes the destination.
      *  @param options Indicates if dst is zero-initialized. The
      *                         implementation may choose to skip writing zeroes
      *                         if set to kYes_ZeroInitialized.
      *                 Contains partial scanline information.
      *  @param frame   Is non-NULL if the source pixels are part of an image
      *                 frame that is a subset of the full image.
      *  @param skipFormatConversion Indicates that we should skip format conversion.
      *                              The swizzler only needs to sample and/or subset.
      *
      *  Note that a deeper discussion of partial scanline subsets and image frame
      *  subsets is below.  Currently, we do not support both simultaneously.  If
      *  options->fSubset is non-NULL, frame must be NULL.
      *
      *  @return A new SkSwizzler or nullptr on failure.
      */
     static SkSwizzler* CreateSwizzler(const SkEncodedInfo& encodedInfo, const SkPMColor* ctable,
                                       const SkImageInfo& dstInfo, const SkCodec::Options&,
                                       const SkIRect* frame = nullptr,
                                       bool skipFormatConversion = false);

     /**
      *  Swizzle a line. Generally this will be called height times, once
      *  for each row of source.
      *  By allowing the caller to pass in the dst pointer, we give the caller
      *  flexibility to use the swizzler even when the encoded data does not
      *  store the rows in order.  This also improves usability for scaled and
      *  subset decodes.
      *  @param dst Where we write the output.
      *  @param src The next row of the source data.
      */
     void swizzle(void* dst, const uint8_t* SK_RESTRICT src);

     /**
      * Implement fill using a custom width.
      */
     void fill(const SkImageInfo& info, void* dst, size_t rowBytes, uint64_t colorOrIndex,
             SkCodec::ZeroInitialized zeroInit) override {
         const SkImageInfo fillInfo = info.makeWH(fAllocatedWidth, info.height());
         SkSampler::Fill(fillInfo, dst, rowBytes, colorOrIndex, zeroInit);
     }

     /**
      *  If fSampleX > 1, the swizzler is sampling every fSampleX'th pixel and
      *  discarding the rest.
      *
      *  This getter is currently used by SkBmpStandardCodec for Bmp-in-Ico decodes.
      *  Ideally, the subclasses of SkCodec would have no knowledge of sampling, but
      *  this allows us to apply a transparency mask to pixels after swizzling.
      */
     int sampleX() const { return fSampleX; }

     /**
      *  Returns the actual number of pixels written to destination memory, taking
      *  scaling, subsetting, and partial frames into account.
      */
     int swizzleWidth() const { return fSwizzleWidth; }

     /**
      *  Returns the byte offset at which we write to destination memory, taking
      *  scaling, subsetting, and partial frames into account.
      */
     size_t swizzleOffsetBytes() const { return fDstOffsetBytes; }

 private:

     /**
      *  Method for converting raw data to Skia pixels.
      *  @param dstRow Row in which to write the resulting pixels.
      *  @param src Row of src data, in format specified by SrcConfig
      *  @param dstWidth Width in pixels of the destination
      *  @param bpp if bitsPerPixel % 8 == 0, deltaSrc is bytesPerPixel
      *             else, deltaSrc is bitsPerPixel
      *  @param deltaSrc bpp * sampleX
      *  @param ctable Colors (used for kIndex source).
      *  @param offset The offset before the first pixel to sample.
                         Is in bytes or bits based on what deltaSrc is in.
      */
     typedef void (*RowProc)(void* SK_RESTRICT dstRow,
                             const uint8_t* SK_RESTRICT src,
                             int dstWidth, int bpp, int deltaSrc, int offset,
                             const SkPMColor ctable[]);

     template <RowProc Proc>
     static void SkipLeading8888ZerosThen(void* SK_RESTRICT dstRow,
                                          const uint8_t* SK_RESTRICT src,
                                          int dstWidth, int bpp, int deltaSrc, int offset,
                                          const SkPMColor ctable[]);

     template <RowProc Proc>
     static void SkipLeadingGrayAlphaZerosThen(void* dst, const uint8_t* src, int width, int bpp,
                                               int deltaSrc, int offset, const SkPMColor ctable[]);

     // May be NULL.  We have not implemented optimized functions for all supported transforms.
     const RowProc       fFastProc;
     // Always non-NULL.  Supports sampling.
     const RowProc       fSlowProc;
     // The actual RowProc we are using.  This depends on if fFastProc is non-NULL and
     // whether or not we are sampling.
     RowProc             fActualProc;

     const SkPMColor*    fColorTable;      // Unowned pointer

     // Subset Swizzles
     // There are two types of subset swizzles that we support.  We do not
     // support both at the same time.
     // TODO: If we want to support partial scanlines for gifs (which may
     //       use frame subsets), we will need to support both subsetting
     //       modes at the same time.
     // (1) Partial Scanlines
     //         The client only wants to write a subset of the source pixels
     //         to the destination.  This subset is specified to CreateSwizzler
     //         using options->fSubset.  We will store subset information in
     //         the following fields.
     //
     //         fSrcOffset:      The starting pixel of the source.
     //         fSrcOffsetUnits: Derived from fSrcOffset with two key
     //                          differences:
     //                          (1) This takes the size of source pixels into
     //                          account by multiplying by fSrcBPP.  This may
     //                          be measured in bits or bytes depending on
     //                          which is natural for the SrcConfig.
     //                          (2) If we are sampling, this will be larger
     //                          than fSrcOffset * fSrcBPP, since sampling
     //                          implies that we will skip some pixels.
     //         fDstOffset:      Will be zero.  There is no destination offset
     //                          for this type of subset.
     //         fDstOffsetBytes: Will be zero.
     //         fSrcWidth:       The width of the desired subset of source
     //                          pixels, before any sampling is performed.
     //         fDstWidth:       Will be equal to fSrcWidth, since this is also
     //                          calculated before any sampling is performed.
     //                          For this type of subset, the destination width
     //                          matches the desired subset of the source.
     //         fSwizzleWidth:   The actual number of pixels that will be
     //                          written by the RowProc.  This is a scaled
     //                          version of fSrcWidth/fDstWidth.
     //         fAllocatedWidth: Will be equal to fSwizzleWidth.  For this type
     //                          of subset, the number of pixels written is the
     //                          same as the actual width of the destination.
     // (2) Frame Subset
     //         The client will decode the entire width of the source into a
     //         subset of destination memory.  This subset is specified to
     //         CreateSwizzler in the "frame" parameter.  We store subset
     //         information in the following fields.
     //
     //         fSrcOffset:      Will be zero.  The starting pixel of the source.
     //         fSrcOffsetUnits: Will only be non-zero if we are sampling,
     //                          since sampling implies that we will skip some
     //                          pixels.  Note that this is measured in bits
     //                          or bytes depending on which is natural for
     //                          SrcConfig.
     //         fDstOffset:      First pixel to write in destination.
     //         fDstOffsetBytes: fDstOffset * fDstBPP.
     //         fSrcWidth:       The entire width of the source pixels, before
     //                          any sampling is performed.
     //         fDstWidth:       The entire width of the destination memory,
     //                          before any sampling is performed.
     //         fSwizzleWidth:   The actual number of pixels that will be
     //                          written by the RowProc.  This is a scaled
     //                          version of fSrcWidth.
     //         fAllocatedWidth: The actual number of pixels in destination
     //                          memory.  This is a scaled version of
     //                          fDstWidth.
     //
     // If we are not subsetting, these fields are more straightforward.
     //         fSrcOffset = fDstOffet = fDstOffsetBytes = 0
     //         fSrcOffsetUnits may be non-zero (we will skip the first few pixels when sampling)
     //         fSrcWidth = fDstWidth = Full original width
     //         fSwizzleWidth = fAllcoatedWidth = Scaled width (if we are sampling)
     const int           fSrcOffset;
     const int           fDstOffset;
     int                 fSrcOffsetUnits;
     int                 fDstOffsetBytes;
     const int           fSrcWidth;
     const int           fDstWidth;
     int                 fSwizzleWidth;
     int                 fAllocatedWidth;

     int                 fSampleX;         // Step between X samples
     const int           fSrcBPP;          // Bits/bytes per pixel for the SrcConfig
                                           // if bitsPerPixel % 8 == 0
                                           //     fBPP is bytesPerPixel
                                           // else
                                           //     fBPP is bitsPerPixel
     const int           fDstBPP;          // Bytes per pixel for the destination color type

     SkSwizzler(RowProc fastProc, RowProc proc, const SkPMColor* ctable, int srcOffset,
             int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP);

     int onSetSampleX(int) override;

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

	#ifndef SkSwizzler_DEFINED
	#define SkSwizzler_DEFINED

	#include "SkCodec.h"
	#include "SkColor.h"
	#include "SkImageInfo.h"
	#include "SkSampler.h"

	class SkSwizzler : public SkSampler {
	public:
	/**
	* Create a new SkSwizzler.
	* @param encodedInfo Description of the format of the encoded data.
	* @param ctable Unowned pointer to an array of up to 256 colors for an
	* index source.
	* @param dstInfo Describes the destination.
	* @param options Indicates if dst is zero-initialized. The
	* implementation may choose to skip writing zeroes
	* if set to kYes_ZeroInitialized.
	* Contains partial scanline information.
	* @param frame Is non-NULL if the source pixels are part of an image
	* frame that is a subset of the full image.
	* @param skipFormatConversion Indicates that we should skip format conversion.
	* The swizzler only needs to sample and/or subset.
	*
	* Note that a deeper discussion of partial scanline subsets and image frame
	* subsets is below. Currently, we do not support both simultaneously. If
	* options->fSubset is non-NULL, frame must be NULL.
	*
	* @return A new SkSwizzler or nullptr on failure.
	*/
	static SkSwizzler* CreateSwizzler(const SkEncodedInfo& encodedInfo, const SkPMColor* ctable,
	const SkImageInfo& dstInfo, const SkCodec::Options&,
	const SkIRect* frame = nullptr,
	bool skipFormatConversion = false);

	/**
	* Swizzle a line. Generally this will be called height times, once
	* for each row of source.
	* By allowing the caller to pass in the dst pointer, we give the caller
	* flexibility to use the swizzler even when the encoded data does not
	* store the rows in order. This also improves usability for scaled and
	* subset decodes.
	* @param dst Where we write the output.
	* @param src The next row of the source data.
	*/
	void swizzle(void* dst, const uint8_t* SK_RESTRICT src);

	/**
	* Implement fill using a custom width.
	*/
	void fill(const SkImageInfo& info, void* dst, size_t rowBytes, uint64_t colorOrIndex,
	SkCodec::ZeroInitialized zeroInit) override {
	const SkImageInfo fillInfo = info.makeWH(fAllocatedWidth, info.height());
	SkSampler::Fill(fillInfo, dst, rowBytes, colorOrIndex, zeroInit);
	}

	/**
	* If fSampleX > 1, the swizzler is sampling every fSampleX'th pixel and
	* discarding the rest.
	*
	* This getter is currently used by SkBmpStandardCodec for Bmp-in-Ico decodes.
	* Ideally, the subclasses of SkCodec would have no knowledge of sampling, but
	* this allows us to apply a transparency mask to pixels after swizzling.
	*/
	int sampleX() const { return fSampleX; }

	/**
	* Returns the actual number of pixels written to destination memory, taking
	* scaling, subsetting, and partial frames into account.
	*/
	int swizzleWidth() const { return fSwizzleWidth; }

	/**
	* Returns the byte offset at which we write to destination memory, taking
	* scaling, subsetting, and partial frames into account.
	*/
	size_t swizzleOffsetBytes() const { return fDstOffsetBytes; }

	private:

	/**
	* Method for converting raw data to Skia pixels.
	* @param dstRow Row in which to write the resulting pixels.
	* @param src Row of src data, in format specified by SrcConfig
	* @param dstWidth Width in pixels of the destination
	* @param bpp if bitsPerPixel % 8 == 0, deltaSrc is bytesPerPixel
	* else, deltaSrc is bitsPerPixel
	* @param deltaSrc bpp * sampleX
	* @param ctable Colors (used for kIndex source).
	* @param offset The offset before the first pixel to sample.
	Is in bytes or bits based on what deltaSrc is in.
	*/
	typedef void (RowProc)(void SK_RESTRICT dstRow,
	const uint8_t* SK_RESTRICT src,
	int dstWidth, int bpp, int deltaSrc, int offset,
	const SkPMColor ctable[]);

	template <RowProc Proc>
	static void SkipLeading8888ZerosThen(void* SK_RESTRICT dstRow,
	const uint8_t* SK_RESTRICT src,
	int dstWidth, int bpp, int deltaSrc, int offset,
	const SkPMColor ctable[]);

	template <RowProc Proc>
	static void SkipLeadingGrayAlphaZerosThen(void* dst, const uint8_t* src, int width, int bpp,
	int deltaSrc, int offset, const SkPMColor ctable[]);

	// May be NULL. We have not implemented optimized functions for all supported transforms.
	const RowProc fFastProc;
	// Always non-NULL. Supports sampling.
	const RowProc fSlowProc;
	// The actual RowProc we are using. This depends on if fFastProc is non-NULL and
	// whether or not we are sampling.
	RowProc fActualProc;

	const SkPMColor* fColorTable; // Unowned pointer

	// Subset Swizzles
	// There are two types of subset swizzles that we support. We do not
	// support both at the same time.
	// TODO: If we want to support partial scanlines for gifs (which may
	// use frame subsets), we will need to support both subsetting
	// modes at the same time.
	// (1) Partial Scanlines
	// The client only wants to write a subset of the source pixels
	// to the destination. This subset is specified to CreateSwizzler
	// using options->fSubset. We will store subset information in
	// the following fields.
	//
	// fSrcOffset: The starting pixel of the source.
	// fSrcOffsetUnits: Derived from fSrcOffset with two key
	// differences:
	// (1) This takes the size of source pixels into
	// account by multiplying by fSrcBPP. This may
	// be measured in bits or bytes depending on
	// which is natural for the SrcConfig.
	// (2) If we are sampling, this will be larger
	// than fSrcOffset * fSrcBPP, since sampling
	// implies that we will skip some pixels.
	// fDstOffset: Will be zero. There is no destination offset
	// for this type of subset.
	// fDstOffsetBytes: Will be zero.
	// fSrcWidth: The width of the desired subset of source
	// pixels, before any sampling is performed.
	// fDstWidth: Will be equal to fSrcWidth, since this is also
	// calculated before any sampling is performed.
	// For this type of subset, the destination width
	// matches the desired subset of the source.
	// fSwizzleWidth: The actual number of pixels that will be
	// written by the RowProc. This is a scaled
	// version of fSrcWidth/fDstWidth.
	// fAllocatedWidth: Will be equal to fSwizzleWidth. For this type
	// of subset, the number of pixels written is the
	// same as the actual width of the destination.
	// (2) Frame Subset
	// The client will decode the entire width of the source into a
	// subset of destination memory. This subset is specified to
	// CreateSwizzler in the "frame" parameter. We store subset
	// information in the following fields.
	//
	// fSrcOffset: Will be zero. The starting pixel of the source.
	// fSrcOffsetUnits: Will only be non-zero if we are sampling,
	// since sampling implies that we will skip some
	// pixels. Note that this is measured in bits
	// or bytes depending on which is natural for
	// SrcConfig.
	// fDstOffset: First pixel to write in destination.
	// fDstOffsetBytes: fDstOffset * fDstBPP.
	// fSrcWidth: The entire width of the source pixels, before
	// any sampling is performed.
	// fDstWidth: The entire width of the destination memory,
	// before any sampling is performed.
	// fSwizzleWidth: The actual number of pixels that will be
	// written by the RowProc. This is a scaled
	// version of fSrcWidth.
	// fAllocatedWidth: The actual number of pixels in destination
	// memory. This is a scaled version of
	// fDstWidth.
	//
	// If we are not subsetting, these fields are more straightforward.
	// fSrcOffset = fDstOffet = fDstOffsetBytes = 0
	// fSrcOffsetUnits may be non-zero (we will skip the first few pixels when sampling)
	// fSrcWidth = fDstWidth = Full original width
	// fSwizzleWidth = fAllcoatedWidth = Scaled width (if we are sampling)
	const int fSrcOffset;
	const int fDstOffset;
	int fSrcOffsetUnits;
	int fDstOffsetBytes;
	const int fSrcWidth;
	const int fDstWidth;
	int fSwizzleWidth;
	int fAllocatedWidth;

	int fSampleX; // Step between X samples
	const int fSrcBPP; // Bits/bytes per pixel for the SrcConfig
	// if bitsPerPixel % 8 == 0
	// fBPP is bytesPerPixel
	// else
	// fBPP is bitsPerPixel
	const int fDstBPP; // Bytes per pixel for the destination color type

	SkSwizzler(RowProc fastProc, RowProc proc, const SkPMColor* ctable, int srcOffset,
	int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP);

	int onSetSampleX(int) override;

	};
	#endif // SkSwizzler_DEFINED