Do not consolidate data in BMPImageDecoder

Source/platform/image-decoders/bmp/BMPImageReader.h

 /*
  * 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
@@ skipping 13 matching lines @@
  * 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 "platform/image-decoders/FastSharedBufferReader.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "wtf/CPU.h"
+#include <stdint.h>
 
 namespace blink {
 
 // 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 PLATFORM_EXPORT BMPImageReader {
     WTF_MAKE_FAST_ALLOCATED(BMPImageReader);
 public:
-    // Read a value from |data[offset]|, converting from little to native
-    // endianness.
-    static inline uint16_t readUint16(SharedBuffer* data, int offset)
+    // Read a value from |buffer|, converting to an int assuming little
+    // endianness
+    static inline uint16_t readUint16(const char* buffer)
     {
-        uint16_t result;
-        memcpy(&result, &data->data()[offset], 2);
-    #if CPU(BIG_ENDIAN)
-        result = ((result & 0xff) << 8) | ((result & 0xff00) >> 8);
-    #endif
-        return result;
+        return *reinterpret_cast<const uint16_t*>(buffer);
     }
 
-    static inline uint32_t readUint32(SharedBuffer* data, int offset)
+    static inline uint32_t readUint32(const char* buffer)
     {
-        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;
+        return *reinterpret_cast<const uint32_t*>(buffer);
     }
 
     // |parent| is the decoder that owns us.
     // |startOffset| points to the start of the BMP within the file.
     // |buffer| points at an empty ImageFrame that we'll initialize and
     // fill with decoded data.
     BMPImageReader(ImageDecoder* parent, size_t decodedAndHeaderOffset, size_t imgDataOffset, bool isInICO);
 
     void setBuffer(ImageFrame* buffer) { m_buffer = buffer; }
-    void setData(SharedBuffer* data) { m_data = data; }
+    void setData(SharedBuffer* data)
+    {
+        m_data = data;
+        m_fastReader.setData(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);
 
     // Helper for decodeBMP() which will call either processRLEData() or
     // processNonRLEData(), depending on the value of |nonRLE|, call any
     // appropriate notifications to deal with the result, then return whether
     // decoding succeeded.
@@ skipping 32 matching lines @@
         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
+    inline uint16_t readUint16(int offset)
     {
-        return readUint16(m_data.get(), m_decodedOffset + offset);
+        char buffer[2];
+        const char* data = m_fastReader.getConsecutiveData(m_decodedOffset + offset, 2, buffer);
+        return readUint16(data);
     }
 
-    inline uint32_t readUint32(int offset) const
+    inline uint32_t readUint32(int offset)
     {
-        return readUint32(m_data.get(), m_decodedOffset + offset);
+        char buffer[4];
+        const char* data = m_fastReader.getConsecutiveData(m_decodedOffset + offset, 4, buffer);
+        return readUint32(data);
     }
 
     // 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();
 
@@ skipping 44 matching lines @@
     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
+    inline uint32_t readCurrentPixel(int bytesPerPixel)
     {
+        // We need at most 4 bytes, starting at m_decodedOffset + offset.
+        char buffer[4];
         const int offset = m_coord.x() * bytesPerPixel;
+        const char* encodedPixel = m_fastReader.getConsecutiveData(m_decodedOffset + offset, bytesPerPixel, buffer);
         switch (bytesPerPixel) {
         case 2:
-            return readUint16(offset);
+            return readUint16(encodedPixel);
 
         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.
+            // of the return value, 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
+            memcpy(&pixel, encodedPixel, 3);
             return pixel;
         }
 
         case 4:
-            return readUint32(offset);
+            return readUint32(encodedPixel);
 
         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
     {
         uint8_t value = (pixel & m_bitMasks[component]) >> m_bitShiftsRight[component];
         return m_lookupTableAddresses[component] ? m_lookupTableAddresses[component][value] : value;
     }
 
     inline unsigned getAlpha(uint32_t pixel) const
     {
         // For images without alpha, return alpha of 0xff.
         return m_bitMasks[3] ? getComponent(pixel, 3) : 0xff;
     }
 
+    // Retrieve one byte from |m_data| at |offset|.
+    uint8_t getByte(size_t offset)

[Peter Kasting, 2015/09/02 23:48:44]

Nit: Maybe this should be readUint8() and be up by readUint16() and
readUint32().

[scroggo_chromium, 2015/09/03 15:28:36]

Good idea!

For consistency, it now adds m_decodedOffset as well.

+    {
+        return m_fastReader.getOneByte(offset);
+    }
+
+
     // 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,
@@ skipping 25 matching lines @@
     void moveBufferToNextRow();
 
     // The decoder that owns us.
     ImageDecoder* m_parent;
 
     // The destination for the pixel data.
     ImageFrame* m_buffer;
 
     // The file to decode.
     RefPtr<SharedBuffer> m_data;
+    FastSharedBufferReader m_fastReader;
 
     // 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
@@ skipping 57 matching lines @@
     // 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). If |m_isInICO| is true, this variable tracks
     // whether we've begun decoding this mask yet.
     bool m_decodingAndMask;
 };
 
 } // namespace blink
 
 #endif