| /* |
| * 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. |
| */ |
| |
| #ifndef BMPImageReader_h |
| #define BMPImageReader_h |
| |
| #include <stdint.h> |
| #include "ImageDecoder.h" |
| |
| namespace WebCore { |
| |
| // This class decodes a BMP image. It is used as a base for the BMP and ICO |
| // decoders, which wrap it in the appropriate code to read file headers, etc. |
| class BMPImageReader : public ImageDecoder { |
| public: |
| BMPImageReader(); |
| |
| // Does the actual decoding. |data| starts at the beginning of the file, |
| // but may be incomplete. |
| virtual void decodeImage(SharedBuffer* data) = 0; |
| |
| // ImageDecoder |
| virtual void setData(SharedBuffer* data, bool allDataReceived); |
| virtual RGBA32Buffer* frameBufferAtIndex(size_t index); |
| |
| protected: |
| enum AndMaskState { |
| None, |
| NotYetDecoded, |
| Decoding, |
| }; |
| |
| // Decodes a single BMP, starting with an info header. |
| void decodeBMP(SharedBuffer* data); |
| |
| // Read a value from |data[m_decodedOffset + additionalOffset]|, converting |
| // from little to native endianness. |
| inline uint16_t readUint16(SharedBuffer* data, int additionalOffset) const |
| { |
| uint16_t result; |
| memcpy(&result, &data->data()[m_decodedOffset + additionalOffset], 2); |
| #if PLATFORM(BIG_ENDIAN) |
| result = ((result & 0xff) << 8) | ((result & 0xff00) >> 8); |
| #endif |
| return result; |
| } |
| |
| inline uint32_t readUint32(SharedBuffer* data, int additionalOffset) const |
| { |
| uint32_t result; |
| memcpy(&result, &data->data()[m_decodedOffset + additionalOffset], 4); |
| #if PLATFORM(BIG_ENDIAN) |
| result = ((result & 0xff) << 24) | ((result & 0xff00) << 8) | |
| ((result & 0xff0000) >> 8) | ((result & 0xff000000) >> 24); |
| #endif |
| return result; |
| } |
| |
| // 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; |
| |
| // 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; |
| |
| 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 |
| }; |
| |
| // 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; |
| }; |
| |
| // Determines the size of the BMP info header. Returns true if the size is |
| // valid. |
| bool getInfoHeaderSize(SharedBuffer* data); |
| |
| // Processes the BMP info header. Returns true if the info header could be |
| // decoded. |
| bool processInfoHeader(SharedBuffer* data); |
| |
| // Helper function for processInfoHeader() which does the actual reading of |
| // header values from the byte stream. Returns false on error. |
| bool readInfoHeader(SharedBuffer* data); |
| |
| // 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(SharedBuffer* data); |
| |
| // For paletted images, allocates and initializes the m_colorTable[] array. |
| bool processColorTable(SharedBuffer* data); |
| |
| // Processes an RLE-encoded image. Returns true if the entire image was |
| // decoded. |
| bool processRLEData(SharedBuffer* data); |
| |
| // 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; returns true on |
| // success. |
| // * 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 true if the whole image was decoded. |
| bool processNonRLEData(SharedBuffer* data, 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) >= 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(SharedBuffer* data, int bytesPerPixel) const |
| { |
| const int additionalOffset = m_coord.x() * bytesPerPixel; |
| switch (bytesPerPixel) { |
| case 2: |
| return readUint16(data, additionalOffset); |
| |
| 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, |
| &data->data()[m_decodedOffset + additionalOffset], 3); |
| #if PLATFORM(BIG_ENDIAN) |
| pixel = ((pixel & 0xff00) << 8) | ((pixel & 0xff0000) >> 8) | |
| ((pixel & 0xff000000) >> 24); |
| #endif |
| return pixel; |
| } |
| |
| case 4: |
| return readUint32(data, additionalOffset); |
| |
| 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. |
| if (m_bitMasks[3] == 0) |
| return 0xff; |
| |
| return getComponent(pixel, 3); |
| } |
| |
| // 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) |
| { |
| setRGBA(m_colorTable[colorIndex].rgbRed, m_colorTable[colorIndex].rgbGreen, |
| m_colorTable[colorIndex].rgbBlue, 0xff); |
| } |
| |
| // Like setI(), but with the individual component values specified. |
| inline void setRGBA(unsigned red, unsigned green, unsigned blue, unsigned alpha) |
| { |
| RGBA32Buffer::setRGBA( |
| m_frameBufferCache.first().bitmap().getAddr32(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) |
| { |
| while (m_coord.x() < endCoord) |
| setRGBA(red, green, blue, alpha); |
| } |
| |
| // 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 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; |
| }; |
| |
| } // namespace WebCore |
| |
| #endif |
