Do not consolidate data in BMPImageDecoder

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

 /*
  * 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 148 matching lines @@
         m_buffer->setPixelsChanged(true);
     return (result == Failure) ? m_parent->setFailed() : (result == Success);
 }
 
 bool BMPImageReader::readInfoHeaderSize()
 {
     // Get size of info header.
     ASSERT(m_decodedOffset == m_headerOffset);
     if ((m_decodedOffset > m_data->size()) || ((m_data->size() - m_decodedOffset) < 4))
         return false;
-    m_infoHeader.biSize = readUint32(0);
+
+    FastSharedBufferReader fastReader(m_data);
+    m_infoHeader.biSize = readUint32(&fastReader, 0);
     // Don't increment m_decodedOffset here, it just makes the code in
     // processInfoHeader() more confusing.
 
     // Don't allow the header to overflow (which would be harmless here, but
     // problematic or at least confusing in other places), or to overrun the
     // image data.
     const size_t headerEnd = m_headerOffset + m_infoHeader.biSize;
     if ((headerEnd < m_headerOffset) || (m_imgDataOffset && (m_imgDataOffset < headerEnd)))
         return m_parent->setFailed();
 
@@ skipping 54 matching lines @@
 
     return true;
 }
 
 bool BMPImageReader::readInfoHeader()
 {
     // Pre-initialize some fields that not all headers set.
     m_infoHeader.biCompression = RGB;
     m_infoHeader.biClrUsed = 0;
 
+    FastSharedBufferReader fastReader(m_data);
+
     if (m_isOS21x) {
-        m_infoHeader.biWidth = readUint16(4);
-        m_infoHeader.biHeight = readUint16(6);
+        m_infoHeader.biWidth = readUint16(&fastReader, 4);
+        m_infoHeader.biHeight = readUint16(&fastReader, 6);
         ASSERT(!m_isInICO); // ICO is a Windows format, not OS/2!
-        m_infoHeader.biBitCount = readUint16(10);
+        m_infoHeader.biBitCount = readUint16(&fastReader, 10);
         return true;
     }
 
-    m_infoHeader.biWidth = readUint32(4);
-    m_infoHeader.biHeight = readUint32(8);
+    m_infoHeader.biWidth = readUint32(&fastReader, 4);
+    m_infoHeader.biHeight = readUint32(&fastReader, 8);
     if (m_isInICO)
         m_infoHeader.biHeight /= 2;
-    m_infoHeader.biBitCount = readUint16(14);
+    m_infoHeader.biBitCount = readUint16(&fastReader, 14);
 
     // Read compression type, if present.
     if (m_infoHeader.biSize >= 20) {
-        uint32_t biCompression = readUint32(16);
+        uint32_t biCompression = readUint32(&fastReader, 16);
 
         // Detect OS/2 2.x-specific compression types.
         if ((biCompression == 3) && (m_infoHeader.biBitCount == 1)) {
             m_infoHeader.biCompression = HUFFMAN1D;
             m_isOS22x = true;
         } else if ((biCompression == 4) && (m_infoHeader.biBitCount == 24)) {
             m_infoHeader.biCompression = RLE24;
             m_isOS22x = true;
         } else if (biCompression > 5)
             return m_parent->setFailed(); // Some type we don't understand.
         else
             m_infoHeader.biCompression = static_cast<CompressionType>(biCompression);
     }
 
     // Read colors used, if present.
-    if (m_infoHeader.biSize >= 36)
-        m_infoHeader.biClrUsed = readUint32(32);
+    if (m_infoHeader.biSize >= 36) {

[Peter Kasting, 2015/08/31 19:53:42]

Nit: No {}

[scroggo_chromium, 2015/09/01 22:50:30]

Done.

+        m_infoHeader.biClrUsed = readUint32(&fastReader, 32);
+    }
 
     // Windows V4+ can safely read the four bitmasks from 40-56 bytes in, so do
     // that here. If the bit depth is less than 16, these values will be ignored
     // by the image data decoders. If the bit depth is at least 16 but the
     // compression format isn't BITFIELDS, the RGB bitmasks will be ignored and
     // overwritten in processBitmasks(). (The alpha bitmask will never be
     // overwritten: images that actually want alpha have to specify a valid
     // alpha mask. See comments in processBitmasks().)
     //
     // For non-Windows V4+, m_bitMasks[] et. al will be initialized later
     // during processBitmasks().
     if (isWindowsV4Plus()) {
-        m_bitMasks[0] = readUint32(40);
-        m_bitMasks[1] = readUint32(44);
-        m_bitMasks[2] = readUint32(48);
-        m_bitMasks[3] = readUint32(52);
+        m_bitMasks[0] = readUint32(&fastReader, 40);
+        m_bitMasks[1] = readUint32(&fastReader, 44);
+        m_bitMasks[2] = readUint32(&fastReader, 48);
+        m_bitMasks[3] = readUint32(&fastReader, 52);
     }
 
     // Detect top-down BMPs.
     if (m_infoHeader.biHeight < 0) {
         m_isTopDown = true;
         m_infoHeader.biHeight = -m_infoHeader.biHeight;
     }
 
     return true;
 }
@@ skipping 119 matching lines @@
         // Fail if we don't have enough file space for the bitmasks.
         const size_t headerEnd = m_headerOffset + m_infoHeader.biSize;
         const size_t bitmasksSize = 12;
         const size_t bitmasksEnd = headerEnd + bitmasksSize;
         if ((bitmasksEnd < headerEnd) || (m_imgDataOffset && (m_imgDataOffset < bitmasksEnd)))
             return m_parent->setFailed();
 
         // Read bitmasks.
         if ((m_data->size() - m_decodedOffset) < bitmasksSize)
             return false;
-        m_bitMasks[0] = readUint32(0);
-        m_bitMasks[1] = readUint32(4);
-        m_bitMasks[2] = readUint32(8);
+
+        FastSharedBufferReader fastReader(m_data);
+        m_bitMasks[0] = readUint32(&fastReader, 0);
+        m_bitMasks[1] = readUint32(&fastReader, 4);
+        m_bitMasks[2] = readUint32(&fastReader, 8);
 
         m_decodedOffset += bitmasksSize;
     }
 
     // Alpha is a poorly-documented and inconsistently-used feature.
     //
     // Windows V4+ has an alpha bitmask in the info header. Unlike the R/G/B
     // bitmasks, the MSDN docs don't indicate that it is only valid for the
     // BITFIELDS compression format, so we respect it at all times.
     //
@@ skipping 89 matching lines @@
     const size_t tableSizeInBytes = m_infoHeader.biClrUsed * (m_isOS21x ? 3 : 4);
     const size_t tableEnd = headerEnd + tableSizeInBytes;
     if ((tableEnd < headerEnd) || (m_imgDataOffset && (m_imgDataOffset < tableEnd)))
         return m_parent->setFailed();
 
     // Read color table.
     if ((m_decodedOffset > m_data->size()) || ((m_data->size() - m_decodedOffset) < tableSizeInBytes))
         return false;
     m_colorTable.resize(m_infoHeader.biClrUsed);
     for (size_t i = 0; i < m_infoHeader.biClrUsed; ++i) {
-        m_colorTable[i].rgbBlue = m_data->data()[m_decodedOffset++];
-        m_colorTable[i].rgbGreen = m_data->data()[m_decodedOffset++];
-        m_colorTable[i].rgbRed = m_data->data()[m_decodedOffset++];
+        m_colorTable[i].rgbBlue = getByte(m_decodedOffset++);
+        m_colorTable[i].rgbGreen = getByte(m_decodedOffset++);
+        m_colorTable[i].rgbRed = getByte(m_decodedOffset++);
         // Skip padding byte (not present on OS/2 1.x).
         if (!m_isOS21x)
             ++m_decodedOffset;
     }
 
     // We've now decoded all the non-image data we care about.  Skip anything
     // else before the actual raster data.
     if (m_imgDataOffset)
         m_decodedOffset = m_imgDataOffset;
     m_needToProcessColorTable = false;
@@ skipping 29 matching lines @@
     // Impossible to decode row-at-a-time, so just do things as a stream of
     // bytes.
     while (true) {
         // Every entry takes at least two bytes; bail if there isn't enough
         // data.
         if ((m_data->size() - m_decodedOffset) < 2)
             return InsufficientData;
 
         // For every entry except EOF, we'd better not have reached the end of
         // the image.
-        const uint8_t count = m_data->data()[m_decodedOffset];
-        const uint8_t code = m_data->data()[m_decodedOffset + 1];
+        const uint8_t count = getByte(m_decodedOffset);
+        const uint8_t code = getByte(m_decodedOffset + 1);
         if ((count || (code != 1)) && pastEndOfImage(0))
             return Failure;
 
         // Decode.
         if (!count) {
             switch (code) {
             case 0:  // Magic token: EOL
                 // Skip any remaining pixels in this row.
                 if (m_coord.x() < m_parent->size().width())
                     m_buffer->setHasAlpha(true);
@@ skipping 13 matching lines @@
                 return Success;
 
             case 2: {  // Magic token: Delta
                 // The next two bytes specify dx and dy.  Bail if there isn't
                 // enough data.
                 if ((m_data->size() - m_decodedOffset) < 4)
                     return InsufficientData;
 
                 // Fail if this takes us past the end of the desired row or
                 // past the end of the image.
-                const uint8_t dx = m_data->data()[m_decodedOffset + 2];
-                const uint8_t dy = m_data->data()[m_decodedOffset + 3];
+                const uint8_t dx = getByte(m_decodedOffset + 2);
+                const uint8_t dy = getByte(m_decodedOffset + 3);
                 if (dx || dy)
                     m_buffer->setHasAlpha(true);
                 if (((m_coord.x() + dx) > m_parent->size().width()) || pastEndOfImage(dy))
                     return Failure;
 
                 // Skip intervening pixels.
                 m_coord.move(dx, m_isTopDown ? dy : -dy);
 
                 m_decodedOffset += 4;
                 break;
@@ skipping 19 matching lines @@
             // Strangely, some BMPs seem to specify excessively large counts
             // here; ignore pixels past the end of the row.
             const int endX = std::min(m_coord.x() + count, m_parent->size().width());
 
             if (m_infoHeader.biCompression == RLE24) {
                 // Bail if there isn't enough data.
                 if ((m_data->size() - m_decodedOffset) < 4)
                     return InsufficientData;
 
                 // One BGR triple that we copy |count| times.
-                fillRGBA(endX, m_data->data()[m_decodedOffset + 3], m_data->data()[m_decodedOffset + 2], code, 0xff);
+                fillRGBA(endX, getByte(m_decodedOffset + 3), getByte(m_decodedOffset + 2), code, 0xff);
                 m_decodedOffset += 4;
             } else {
                 // RLE8 has one color index that gets repeated; RLE4 has two
                 // color indexes in the upper and lower 4 bits of the byte,
                 // which are alternated.
                 size_t colorIndexes[2] = {code, code};
                 if (m_infoHeader.biCompression == RLE4) {
                     colorIndexes[0] = (colorIndexes[0] >> 4) & 0xf;
                     colorIndexes[1] &= 0xf;
                 }
@@ skipping 42 matching lines @@
         // Bail if we don't have enough data for the desired number of pixels.
         if ((m_data->size() - m_decodedOffset) < paddedNumBytes)
             return InsufficientData;
 
         if (m_infoHeader.biBitCount < 16) {
             // Paletted data.  Pixels are stored little-endian within bytes.
             // Decode pixels one byte at a time, left to right (so, starting at
             // the most significant bits in the byte).
             const uint8_t mask = (1 << m_infoHeader.biBitCount) - 1;
             for (size_t byte = 0; byte < unpaddedNumBytes; ++byte) {
-                uint8_t pixelData = m_data->data()[m_decodedOffset + byte];
+                uint8_t pixelData = getByte(m_decodedOffset + byte);
                 for (size_t pixel = 0; (pixel < pixelsPerByte) && (m_coord.x() < endX); ++pixel) {
                     const size_t colorIndex = (pixelData >> (8 - m_infoHeader.biBitCount)) & mask;
                     if (m_decodingAndMask) {
                         // There's no way to accurately represent an AND + XOR
                         // operation as an RGBA image, so where the AND values
                         // are 1, we simply set the framebuffer pixels to fully
                         // transparent, on the assumption that most ICOs on the
                         // web will not be doing a lot of inverting.
                         if (colorIndex) {
                             setRGBA(0, 0, 0, 0);
                             m_buffer->setHasAlpha(true);
                         } else
                             m_coord.move(1, 0);
                     } else {
                         // See comments near the end of processRLEData().
                         if (colorIndex < m_infoHeader.biClrUsed)
                             setI(colorIndex);
                         else
                             setRGBA(0, 0, 0, 255);
                     }
                     pixelData <<= m_infoHeader.biBitCount;
                 }
             }
         } else {
+            FastSharedBufferReader fastReader(m_data);
+
             // RGB data.  Decode pixels one at a time, left to right.
             while (m_coord.x() < endX) {
-                const uint32_t pixel = readCurrentPixel(bytesPerPixel);
+                const uint32_t pixel = readCurrentPixel(&fastReader, bytesPerPixel);
 
                 // Some BMPs specify an alpha channel but don't actually use it
                 // (it contains all 0s).  To avoid displaying these images as
                 // fully-transparent, decode as if images are fully opaque
                 // until we actually see a non-zero alpha value; at that point,
                 // reset any previously-decoded pixels to fully transparent and
                 // continue decoding based on the real alpha channel values.
                 // As an optimization, avoid setting "hasAlpha" to true for
                 // images where all alpha values are 255; opaque images are
                 // faster to draw.
@@ skipping 25 matching lines @@
     // Finished decoding whole image.
     return Success;
 }
 
 void BMPImageReader::moveBufferToNextRow()
 {
     m_coord.move(-m_coord.x(), m_isTopDown ? 1 : -1);
 }
 
 } // namespace blink