Source/WebCore/platform/image-decoders/bmp/BMPImageReader.h - WebKit - Git at Google

 /*
  * Copyright (c) 2008, 2009, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #pragma once

 #include "ScalableImageDecoder.h"
 #include <stdint.h>

 namespace WebCore {

 // This class decodes a BMP image. It is used in the BMP and ICO decoders,
 // which wrap it in the appropriate code to read file headers, etc.
 class BMPImageReader {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     // Read a value from |data[offset]|, converting from little to native
     // endianness.
     static inline uint16_t readUint16(const SharedBuffer& data, int offset)
     {
         uint16_t result;
         memcpy(&result, &data.data()[offset], 2);
 #if CPU(BIG_ENDIAN)
         result = ((result & 0xff) << 8) | ((result & 0xff00) >> 8);
 #endif
         return result;
     }

     static inline uint32_t readUint32(const SharedBuffer& data, int offset)
     {
         uint32_t result;
         memcpy(&result, &data.data()[offset], 4);
 #if CPU(BIG_ENDIAN)
         result = ((result & 0xff) << 24) | ((result & 0xff00) << 8) | ((result & 0xff0000) >> 8) | ((result & 0xff000000) >> 24);
 #endif
         return result;
     }

     // |parent| is the decoder that owns us.
     // |startOffset| points to the start of the BMP within the file.
     // |buffer| points at an empty ScalableImageDecoderFrame that we'll initialize and
     // fill with decoded data.
     BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);

     void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }
     void setData(const SharedBuffer& data) { m_data = &data; }

     // Does the actual decoding. If |onlySize| is true, decoding only
     // progresses as far as necessary to get the image size. Returns
     // whether decoding succeeded.
     bool decodeBMP(bool onlySize);

 private:
     // The various BMP compression types. We don't currently decode all
     // these.
     enum CompressionType {
         // Universal types
         RGB = 0,
         RLE8 = 1,
         RLE4 = 2,
         // Windows V3+ only
         BITFIELDS = 3,
         JPEG = 4,
         PNG = 5,
         // OS/2 2.x-only
         HUFFMAN1D, // Stored in file as 3
         RLE24, // Stored in file as 4
     };
     enum AndMaskState {
         None,
         NotYetDecoded,
         Decoding,
     };
     enum ProcessingResult {
         Success,
         Failure,
         InsufficientData,
     };

     // These are based on the Windows BITMAPINFOHEADER and RGBTRIPLE
     // structs, but with unnecessary entries removed.
     struct BitmapInfoHeader {
         uint32_t biSize;
         int32_t biWidth;
         int32_t biHeight;
         uint16_t biBitCount;
         CompressionType biCompression;
         uint32_t biClrUsed;
     };
     struct RGBTriple {
         uint8_t rgbBlue;
         uint8_t rgbGreen;
         uint8_t rgbRed;
     };

     inline uint16_t readUint16(int offset) const
     {
         return readUint16(*m_data, m_decodedOffset + offset);
     }

     inline uint32_t readUint32(int offset) const
     {
         return readUint32(*m_data, m_decodedOffset + offset);
     }

     // Determines the size of the BMP info header. Returns true if the size
     // is valid.
     bool readInfoHeaderSize();

     // Processes the BMP info header. Returns true if the info header could
     // be decoded.
     bool processInfoHeader();

     // Helper function for processInfoHeader() which does the actual reading
     // of header values from the byte stream. Returns false on error.
     bool readInfoHeader();

     // Returns true if this is a Windows V4+ BMP.
     inline bool isWindowsV4Plus() const
     {
         // Windows V4 info header is 108 bytes. V5 is 124 bytes.
         return (m_infoHeader.biSize == 108) || (m_infoHeader.biSize == 124);
     }

     // Returns false if consistency errors are found in the info header.
     bool isInfoHeaderValid() const;

     // For BI_BITFIELDS images, initializes the m_bitMasks[] and
     // m_bitOffsets[] arrays. processInfoHeader() will initialize these for
     // other compression types where needed.
     bool processBitmasks();

     // For paletted images, allocates and initializes the m_colorTable[]
     // array.
     bool processColorTable();

     // Processes an RLE-encoded image. Returns true if the entire image was
     // decoded.
     bool processRLEData();

     // Processes a set of non-RLE-compressed pixels. Two cases:
     //   * inRLE = true: the data is inside an RLE-encoded bitmap. Tries to
     //     process |numPixels| pixels on the current row.
     //   * inRLE = false: the data is inside a non-RLE-encoded bitmap.
     //     |numPixels| is ignored. Expects |m_coord| to point at the
     //     beginning of the next row to be decoded. Tries to process as
     //     many complete rows as possible. Returns InsufficientData if
     //     there wasn't enough data to decode the whole image.
     //
     // This function returns a ProcessingResult instead of a bool so that it
     // can avoid calling m_parent->setFailed(), which could lead to memory
     // corruption since that will delete |this| but some callers still want
     // to access member variables after this returns.
     ProcessingResult processNonRLEData(bool inRLE, int numPixels);

     // Returns true if the current y-coordinate plus |numRows| would be past
     // the end of the image. Here "plus" means "toward the end of the
     // image", so downwards for m_isTopDown images and upwards otherwise.
     inline bool pastEndOfImage(int numRows)
     {
         return m_isTopDown ? ((m_coord.y() + numRows) >= m_parent->size().height()) : ((m_coord.y() - numRows) < 0);
     }

     // Returns the pixel data for the current X coordinate in a uint32_t.
     // Assumes m_decodedOffset has been set to the beginning of the current
     // row.
     // NOTE: Only as many bytes of the return value as are needed to hold
     // the pixel data will actually be set.
     inline uint32_t readCurrentPixel(int bytesPerPixel) const
     {
         const int offset = m_coord.x() * bytesPerPixel;
         switch (bytesPerPixel) {
         case 2:
             return readUint16(offset);

         case 3: {
             // It doesn't matter that we never set the most significant byte
             // of the return value here in little-endian mode, the caller
             // won't read it.
             uint32_t pixel;
             memcpy(&pixel, &m_data->data()[m_decodedOffset + offset], 3);
 #if CPU(BIG_ENDIAN)
             pixel = ((pixel & 0xff00) << 8) | ((pixel & 0xff0000) >> 8) | ((pixel & 0xff000000) >> 24);
 #endif
             return pixel;
         }

         case 4:
             return readUint32(offset);

         default:
             ASSERT_NOT_REACHED();
             return 0;
         }
     }

     // Returns the value of the desired component (0, 1, 2, 3 == R, G, B, A)
     // in the given pixel data.
     inline unsigned getComponent(uint32_t pixel, int component) const
     {
         return ((pixel & m_bitMasks[component]) >> m_bitShiftsRight[component]) << m_bitShiftsLeft[component];
     }

     inline unsigned getAlpha(uint32_t pixel) const
     {
         // For images without alpha, return alpha of 0xff.
         return m_bitMasks[3] ? getComponent(pixel, 3) : 0xff;
     }

     // Sets the current pixel to the color given by |colorIndex|. This also
     // increments the relevant local variables to move the current pixel
     // right by one.
     inline void setI(size_t colorIndex)
     {
         setPixel(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
     }

     // Like setI(), but with the individual component values specified.
     inline void setPixel(unsigned red, unsigned green, unsigned blue, unsigned alpha)
     {
         m_buffer->backingStore()->setPixel(m_coord.x(), m_coord.y(), red, green, blue, alpha);
         m_coord.move(1, 0);
     }

     // Fills pixels from the current X-coordinate up to, but not including,
     // |endCoord| with the color given by the individual components. This
     // also increments the relevant local variables to move the current
     // pixel right to |endCoord|.
     inline void fillRGBA(int endCoord, unsigned red, unsigned green, unsigned blue, unsigned alpha)
     {
         if (endCoord <= m_coord.x())
             return;
         m_buffer->backingStore()->fillRect(IntRect(m_coord.x(), m_coord.y(), endCoord - m_coord.x(), 1), red, green, blue, alpha);
         m_coord.setX(endCoord);
     }

     // Resets the relevant local variables to start drawing at the left edge
     // of the "next" row, where "next" is above or below the current row
     // depending on the value of |m_isTopDown|.
     void moveBufferToNextRow();

     // The decoder that owns us.
     ScalableImageDecoder* m_parent;

     // The destination for the pixel data.
     ScalableImageDecoderFrame* m_buffer;

     // The file to decode.
     RefPtr<const SharedBuffer> m_data;

     // An index into |m_data| representing how much we've already decoded.
     size_t m_decodedOffset;

     // The file offset at which the BMP info header starts.
     size_t m_headerOffset;

     // The file offset at which the actual image bits start. When decoding
     // ICO files, this is set to 0, since it's not stored anywhere in a
     // header; the reader functions expect the image data to start
     // immediately after the header and (if necessary) color table.
     size_t m_imgDataOffset;

     // The BMP info header.
     BitmapInfoHeader m_infoHeader;

     // True if this is an OS/2 1.x (aka Windows 2.x) BMP. The struct
     // layouts for this type of BMP are slightly different from the later,
     // more common formats.
     bool m_isOS21x;

     // True if this is an OS/2 2.x BMP. The meanings of compression types 3
     // and 4 for this type of BMP differ from Windows V3+ BMPs.
     //
     // This will be falsely negative in some cases, but only ones where the
     // way we misinterpret the data is irrelevant.
     bool m_isOS22x;

     // True if the BMP is not vertically flipped, that is, the first line of
     // raster data in the file is the top line of the image.
     bool m_isTopDown;

     // These flags get set to false as we finish each processing stage.
     bool m_needToProcessBitmasks;
     bool m_needToProcessColorTable;

     // Masks/offsets for the color values for non-palette formats. These
     // are bitwise, with array entries 0, 1, 2, 3 corresponding to R, G, B,
     // A.
     //
     // The right/left shift values are meant to be applied after the masks.
     // We need to right shift to compensate for the bitfields' offsets into
     // the 32 bits of pixel data, and left shift to scale the color values
     // up for fields with less than 8 bits of precision. Sadly, we can't
     // just combine these into one shift value because the net shift amount
     // could go either direction. (If only "<< -x" were equivalent to
     // ">> x"...)
     uint32_t m_bitMasks[4];
     int m_bitShiftsRight[4];
     int m_bitShiftsLeft[4];

     // The color palette, for paletted formats.
     size_t m_tableSizeInBytes;
     Vector<RGBTriple> m_colorTable;

     // The coordinate to which we've decoded the image.
     IntPoint m_coord;

     // Variables that track whether we've seen pixels with alpha values != 0
     // and == 0, respectively. See comments in processNonRLEData() on how
     // these are used.
     bool m_seenNonZeroAlphaPixel;
     bool m_seenZeroAlphaPixel;

     // ICOs store a 1bpp "mask" immediately after the main bitmap image data
     // (and, confusingly, add its height to the biHeight value in the info
     // header, thus doubling it). This variable tracks whether we have such
     // a mask and if we've started decoding it yet.
     AndMaskState m_andMaskState;
 };

 } // namespace WebCore
	/*
	* Copyright (c) 2008, 2009, Google Inc. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	*
	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer
	* in the documentation and/or other materials provided with the
	* distribution.
	* * Neither the name of Google Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#pragma once

	#include "ScalableImageDecoder.h"
	#include <stdint.h>

	namespace WebCore {

	// This class decodes a BMP image. It is used in the BMP and ICO decoders,
	// which wrap it in the appropriate code to read file headers, etc.
	class BMPImageReader {
	WTF_MAKE_FAST_ALLOCATED;
	public:
	// Read a value from \|data[offset]\|, converting from little to native
	// endianness.
	static inline uint16_t readUint16(const SharedBuffer& data, int offset)
	{
	uint16_t result;
	memcpy(&result, &data.data()[offset], 2);
	#if CPU(BIG_ENDIAN)
	result = ((result & 0xff) << 8) \| ((result & 0xff00) >> 8);
	#endif
	return result;
	}

	static inline uint32_t readUint32(const SharedBuffer& data, int offset)
	{
	uint32_t result;
	memcpy(&result, &data.data()[offset], 4);
	#if CPU(BIG_ENDIAN)
	result = ((result & 0xff) << 24) \| ((result & 0xff00) << 8) \| ((result & 0xff0000) >> 8) \| ((result & 0xff000000) >> 24);
	#endif
	return result;
	}

	// \|parent\| is the decoder that owns us.
	// \|startOffset\| points to the start of the BMP within the file.
	// \|buffer\| points at an empty ScalableImageDecoderFrame that we'll initialize and
	// fill with decoded data.
	BMPImageReader(ScalableImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool usesAndMask);

	void setBuffer(ScalableImageDecoderFrame* buffer) { m_buffer = buffer; }
	void setData(const SharedBuffer& data) { m_data = &data; }

	// Does the actual decoding. If \|onlySize\| is true, decoding only
	// progresses as far as necessary to get the image size. Returns
	// whether decoding succeeded.
	bool decodeBMP(bool onlySize);

	private:
	// The various BMP compression types. We don't currently decode all
	// these.
	enum CompressionType {
	// Universal types
	RGB = 0,
	RLE8 = 1,
	RLE4 = 2,
	// Windows V3+ only
	BITFIELDS = 3,
	JPEG = 4,
	PNG = 5,
	// OS/2 2.x-only
	HUFFMAN1D, // Stored in file as 3
	RLE24, // Stored in file as 4
	};
	enum AndMaskState {
	None,
	NotYetDecoded,
	Decoding,
	};
	enum ProcessingResult {
	Success,
	Failure,
	InsufficientData,
	};

	// These are based on the Windows BITMAPINFOHEADER and RGBTRIPLE
	// structs, but with unnecessary entries removed.
	struct BitmapInfoHeader {
	uint32_t biSize;
	int32_t biWidth;
	int32_t biHeight;
	uint16_t biBitCount;
	CompressionType biCompression;
	uint32_t biClrUsed;
	};
	struct RGBTriple {
	uint8_t rgbBlue;
	uint8_t rgbGreen;
	uint8_t rgbRed;
	};

	inline uint16_t readUint16(int offset) const
	{
	return readUint16(*m_data, m_decodedOffset + offset);
	}

	inline uint32_t readUint32(int offset) const
	{
	return readUint32(*m_data, m_decodedOffset + offset);
	}

	// Determines the size of the BMP info header. Returns true if the size
	// is valid.
	bool readInfoHeaderSize();

	// Processes the BMP info header. Returns true if the info header could
	// be decoded.
	bool processInfoHeader();

	// Helper function for processInfoHeader() which does the actual reading
	// of header values from the byte stream. Returns false on error.
	bool readInfoHeader();

	// Returns true if this is a Windows V4+ BMP.
	inline bool isWindowsV4Plus() const
	{
	// Windows V4 info header is 108 bytes. V5 is 124 bytes.
	return (m_infoHeader.biSize == 108) \|\| (m_infoHeader.biSize == 124);
	}

	// Returns false if consistency errors are found in the info header.
	bool isInfoHeaderValid() const;

	// For BI_BITFIELDS images, initializes the m_bitMasks[] and
	// m_bitOffsets[] arrays. processInfoHeader() will initialize these for
	// other compression types where needed.
	bool processBitmasks();

	// For paletted images, allocates and initializes the m_colorTable[]
	// array.
	bool processColorTable();

	// Processes an RLE-encoded image. Returns true if the entire image was
	// decoded.
	bool processRLEData();

	// Processes a set of non-RLE-compressed pixels. Two cases:
	// * inRLE = true: the data is inside an RLE-encoded bitmap. Tries to
	// process \|numPixels\| pixels on the current row.
	// * inRLE = false: the data is inside a non-RLE-encoded bitmap.
	// \|numPixels\| is ignored. Expects \|m_coord\| to point at the
	// beginning of the next row to be decoded. Tries to process as
	// many complete rows as possible. Returns InsufficientData if
	// there wasn't enough data to decode the whole image.
	//
	// This function returns a ProcessingResult instead of a bool so that it
	// can avoid calling m_parent->setFailed(), which could lead to memory
	// corruption since that will delete \|this\| but some callers still want
	// to access member variables after this returns.
	ProcessingResult processNonRLEData(bool inRLE, int numPixels);

	// Returns true if the current y-coordinate plus \|numRows\| would be past
	// the end of the image. Here "plus" means "toward the end of the
	// image", so downwards for m_isTopDown images and upwards otherwise.
	inline bool pastEndOfImage(int numRows)
	{
	return m_isTopDown ? ((m_coord.y() + numRows) >= m_parent->size().height()) : ((m_coord.y() - numRows) < 0);
	}

	// Returns the pixel data for the current X coordinate in a uint32_t.
	// Assumes m_decodedOffset has been set to the beginning of the current
	// row.
	// NOTE: Only as many bytes of the return value as are needed to hold
	// the pixel data will actually be set.
	inline uint32_t readCurrentPixel(int bytesPerPixel) const
	{
	const int offset = m_coord.x() * bytesPerPixel;
	switch (bytesPerPixel) {
	case 2:
	return readUint16(offset);

	case 3: {
	// It doesn't matter that we never set the most significant byte
	// of the return value here in little-endian mode, the caller
	// won't read it.
	uint32_t pixel;
	memcpy(&pixel, &m_data->data()[m_decodedOffset + offset], 3);
	#if CPU(BIG_ENDIAN)
	pixel = ((pixel & 0xff00) << 8) \| ((pixel & 0xff0000) >> 8) \| ((pixel & 0xff000000) >> 24);
	#endif
	return pixel;
	}

	case 4:
	return readUint32(offset);

	default:
	ASSERT_NOT_REACHED();
	return 0;
	}
	}

	// Returns the value of the desired component (0, 1, 2, 3 == R, G, B, A)
	// in the given pixel data.
	inline unsigned getComponent(uint32_t pixel, int component) const
	{
	return ((pixel & m_bitMasks[component]) >> m_bitShiftsRight[component]) << m_bitShiftsLeft[component];
	}

	inline unsigned getAlpha(uint32_t pixel) const
	{
	// For images without alpha, return alpha of 0xff.
	return m_bitMasks[3] ? getComponent(pixel, 3) : 0xff;
	}

	// Sets the current pixel to the color given by \|colorIndex\|. This also
	// increments the relevant local variables to move the current pixel
	// right by one.
	inline void setI(size_t colorIndex)
	{
	setPixel(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, m_colorTable[colorIndex].rgbBlue, 0xff);
	}

	// Like setI(), but with the individual component values specified.
	inline void setPixel(unsigned red, unsigned green, unsigned blue, unsigned alpha)
	{
	m_buffer->backingStore()->setPixel(m_coord.x(), m_coord.y(), red, green, blue, alpha);
	m_coord.move(1, 0);
	}

	// Fills pixels from the current X-coordinate up to, but not including,
	// \|endCoord\| with the color given by the individual components. This
	// also increments the relevant local variables to move the current
	// pixel right to \|endCoord\|.
	inline void fillRGBA(int endCoord, unsigned red, unsigned green, unsigned blue, unsigned alpha)
	{
	if (endCoord <= m_coord.x())
	return;
	m_buffer->backingStore()->fillRect(IntRect(m_coord.x(), m_coord.y(), endCoord - m_coord.x(), 1), red, green, blue, alpha);
	m_coord.setX(endCoord);
	}

	// Resets the relevant local variables to start drawing at the left edge
	// of the "next" row, where "next" is above or below the current row
	// depending on the value of \|m_isTopDown\|.
	void moveBufferToNextRow();

	// The decoder that owns us.
	ScalableImageDecoder* m_parent;

	// The destination for the pixel data.
	ScalableImageDecoderFrame* m_buffer;

	// The file to decode.
	RefPtr<const SharedBuffer> m_data;

	// An index into \|m_data\| representing how much we've already decoded.
	size_t m_decodedOffset;

	// The file offset at which the BMP info header starts.
	size_t m_headerOffset;

	// The file offset at which the actual image bits start. When decoding
	// ICO files, this is set to 0, since it's not stored anywhere in a
	// header; the reader functions expect the image data to start
	// immediately after the header and (if necessary) color table.
	size_t m_imgDataOffset;

	// The BMP info header.
	BitmapInfoHeader m_infoHeader;

	// True if this is an OS/2 1.x (aka Windows 2.x) BMP. The struct
	// layouts for this type of BMP are slightly different from the later,
	// more common formats.
	bool m_isOS21x;

	// True if this is an OS/2 2.x BMP. The meanings of compression types 3
	// and 4 for this type of BMP differ from Windows V3+ BMPs.
	//
	// This will be falsely negative in some cases, but only ones where the
	// way we misinterpret the data is irrelevant.
	bool m_isOS22x;

	// True if the BMP is not vertically flipped, that is, the first line of
	// raster data in the file is the top line of the image.
	bool m_isTopDown;

	// These flags get set to false as we finish each processing stage.
	bool m_needToProcessBitmasks;
	bool m_needToProcessColorTable;

	// Masks/offsets for the color values for non-palette formats. These
	// are bitwise, with array entries 0, 1, 2, 3 corresponding to R, G, B,
	// A.
	//
	// The right/left shift values are meant to be applied after the masks.
	// We need to right shift to compensate for the bitfields' offsets into
	// the 32 bits of pixel data, and left shift to scale the color values
	// up for fields with less than 8 bits of precision. Sadly, we can't
	// just combine these into one shift value because the net shift amount
	// could go either direction. (If only "<< -x" were equivalent to
	// ">> x"...)
	uint32_t m_bitMasks[4];
	int m_bitShiftsRight[4];
	int m_bitShiftsLeft[4];

	// The color palette, for paletted formats.
	size_t m_tableSizeInBytes;
	Vector<RGBTriple> m_colorTable;

	// The coordinate to which we've decoded the image.
	IntPoint m_coord;

	// Variables that track whether we've seen pixels with alpha values != 0
	// and == 0, respectively. See comments in processNonRLEData() on how
	// these are used.
	bool m_seenNonZeroAlphaPixel;
	bool m_seenZeroAlphaPixel;

	// ICOs store a 1bpp "mask" immediately after the main bitmap image data
	// (and, confusingly, add its height to the biHeight value in the info
	// header, thus doubling it). This variable tracks whether we have such
	// a mask and if we've started decoding it yet.
	AndMaskState m_andMaskState;
	};

	} // namespace WebCore