bmpimagereader.h

linux下开源浏览器WebKit的源码,市面上的很多商用浏览器都是移植自WebKit

/*
 * 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