/* * 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. */ #include "config.h" #include "BMPImageReader.h" namespace WebCore { BMPImageReader::BMPImageReader() : m_decodedOffset(0) , m_headerOffset(0) , m_imgDataOffset(0) , m_andMaskState(None) , m_isOS21x(false) , m_isOS22x(false) , m_isTopDown(false) , m_needToProcessBitmasks(false) , m_needToProcessColorTable(false) , m_tableSizeInBytes(0) , m_seenNonZeroAlphaPixel(false) , m_seenZeroAlphaPixel(false) { m_frameBufferCache.resize(1); // Clue-in decodeBMP() that we need to detect the correct info header size. memset(&m_infoHeader, 0, sizeof(m_infoHeader)); } void BMPImageReader::setData(SharedBuffer* data, bool allDataReceived) { ImageDecoder::setData(data, allDataReceived); // NOTE: This function intentionally uses frameBufferAtIndex() instead of // checking m_frameBufferCache.first() directly, so that it will do the // right thing for ICOImageDecoder, which needs to override this accessor // to support ICOs which contain PNGs. // Return quickly when we can't do any more work. if (m_failed || data->isEmpty() || (frameBufferAtIndex(0)->status() == RGBA32Buffer::FrameComplete)) return; // Decode as much as we can. This assumes |data| starts at the beginning // of the image data, rather than containing just the latest chunk. decodeImage(data); if (m_failed) { // Handle failure before getting the framebuffer below. m_colorTable.clear(); return; } // If we got all the data but couldn't finish decoding, fail. const bool finished = (frameBufferAtIndex(0)->status() == RGBA32Buffer::FrameComplete); if (allDataReceived && !finished) m_failed = true; // Release the color table when we no longer need it. if (finished || m_failed) m_colorTable.clear(); } RGBA32Buffer* BMPImageReader::frameBufferAtIndex(size_t index) { return index ? 0 : &m_frameBufferCache.first(); } void BMPImageReader::decodeBMP(SharedBuffer* data) { // Calculate size of info header. if (!m_infoHeader.biSize && !getInfoHeaderSize(data)) return; // Read and process info header. if ((m_decodedOffset < (m_headerOffset + m_infoHeader.biSize)) && !processInfoHeader(data)) return; // Read and process the bitmasks, if needed. if (m_needToProcessBitmasks && !processBitmasks(data)) return; // Read and process the color table, if needed. if (m_needToProcessColorTable && !processColorTable(data)) return; // Initialize frame buffer state, if needed. if (m_frameBufferCache.first().status() == RGBA32Buffer::FrameEmpty) { m_frameBufferCache.first().setRect(IntRect(IntPoint(), size())); m_frameBufferCache.first().setStatus(RGBA32Buffer::FramePartial); if (!m_frameBufferCache.first().setSize(m_infoHeader.biWidth, m_infoHeader.biHeight)) { // Unable to allocate. m_failed = true; return; } // setSize() calls eraseARGB(), which resets the alpha flag, so we force // it back to false here. We'll set it true below in all cases where // these 0s could actually show through. m_frameBufferCache.first().setHasAlpha(false); if (!m_isTopDown) m_coord.setY(size().height() - 1); } // Decode the data. if ((m_andMaskState != Decoding) && !pastEndOfImage(0)) { if ((m_infoHeader.biCompression == RLE4) || (m_infoHeader.biCompression == RLE8) || (m_infoHeader.biCompression == RLE24)) { if (!processRLEData(data)) return; } else if (!processNonRLEData(data, false, 0)) return; } // If the image has an AND mask and there was no alpha data, process the // mask. if ((m_andMaskState == NotYetDecoded) && !m_frameBufferCache.first().hasAlpha()) { // Reset decoding coordinates to start of image. m_coord.setX(0); m_coord.setY(m_isTopDown ? 0 : (size().height() - 1)); // The AND mask is stored as 1-bit data. m_infoHeader.biBitCount = 1; m_andMaskState = Decoding; } if ((m_andMaskState == Decoding) && !processNonRLEData(data, false, 0)) return; // Done! m_frameBufferCache.first().setStatus(RGBA32Buffer::FrameComplete); } bool BMPImageReader::getInfoHeaderSize(SharedBuffer* data) { // Get size of info header. ASSERT(m_decodedOffset == m_headerOffset); if ((m_decodedOffset > data->size()) || ((data->size() - m_decodedOffset) < 4)) return false; m_infoHeader.biSize = readUint32(data, 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. if (((m_headerOffset + m_infoHeader.biSize) < m_headerOffset) || (m_imgDataOffset && (m_imgDataOffset < (m_headerOffset + m_infoHeader.biSize)))) { m_failed = true; return false; } // See if this is a header size we understand: // OS/2 1.x: 12 if (m_infoHeader.biSize == 12) m_isOS21x = true; // Windows V3: 40 else if ((m_infoHeader.biSize == 40) || isWindowsV4Plus()) ; // OS/2 2.x: any multiple of 4 between 16 and 64, inclusive, or 42 or 46 else if ((m_infoHeader.biSize >= 16) && (m_infoHeader.biSize <= 64) && (((m_infoHeader.biSize & 3) == 0) || (m_infoHeader.biSize == 42) || (m_infoHeader.biSize == 46))) m_isOS22x = true; else m_failed = true; return !m_failed; } bool BMPImageReader::processInfoHeader(SharedBuffer* data) { // Read info header. ASSERT(m_decodedOffset == m_headerOffset); if ((m_decodedOffset > data->size()) || ((data->size() - m_decodedOffset) < m_infoHeader.biSize) || !readInfoHeader(data)) return false; m_decodedOffset += m_infoHeader.biSize; // Sanity-check header values. if (!isInfoHeaderValid()) { m_failed = true; return false; } // Make our size available to the caller. if (!setSize(m_infoHeader.biWidth, m_infoHeader.biHeight)) { m_failed = true; return false; } // For paletted images, bitmaps can set biClrUsed to 0 to mean "all // colors", so set it to the maximum number of colors for this bit depth. // Also do this for bitmaps that put too large a value here. if (m_infoHeader.biBitCount < 16) { const uint32_t maxColors = static_cast(1) << m_infoHeader.biBitCount; if ((m_infoHeader.biClrUsed == 0) || (m_infoHeader.biClrUsed > maxColors)) m_infoHeader.biClrUsed = maxColors; } // For any bitmaps that set their BitCount to the wrong value, reset the // counts now that we've calculated the number of necessary colors, since // other code relies on this value being correct. if (m_infoHeader.biCompression == RLE8) m_infoHeader.biBitCount = 8; else if (m_infoHeader.biCompression == RLE4) m_infoHeader.biBitCount = 4; // Tell caller what still needs to be processed. if (m_infoHeader.biBitCount >= 16) m_needToProcessBitmasks = true; else if (m_infoHeader.biBitCount > 0) m_needToProcessColorTable = true; return true; } bool BMPImageReader::readInfoHeader(SharedBuffer* data) { // Pre-initialize some fields that not all headers set. m_infoHeader.biCompression = RGB; m_infoHeader.biClrUsed = 0; if (m_isOS21x) { m_infoHeader.biWidth = readUint16(data, 4); m_infoHeader.biHeight = readUint16(data, 6); ASSERT(m_andMaskState == None); // ICO is a Windows format, not OS/2! m_infoHeader.biBitCount = readUint16(data, 10); return true; } m_infoHeader.biWidth = readUint32(data, 4); m_infoHeader.biHeight = readUint32(data, 8); if (m_andMaskState != None) m_infoHeader.biHeight /= 2; m_infoHeader.biBitCount = readUint16(data, 14); // Read compression type, if present. if (m_infoHeader.biSize >= 20) { uint32_t biCompression = readUint32(data, 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) { // Some type we don't understand. m_failed = true; return false; } else m_infoHeader.biCompression = static_cast(biCompression); } // Read colors used, if present. if (m_infoHeader.biSize >= 36) m_infoHeader.biClrUsed = readUint32(data, 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, these values will be ignored and // overwritten* in processBitmasks(). // NOTE: We allow alpha here. Microsoft doesn't really document this well, // but some BMPs appear to use it. // // For non-Windows V4+, m_bitMasks[] et. al will be initialized later // during processBitmasks(). // // *Except the alpha channel. Bizarrely, some RGB bitmaps expect decoders // to pay attention to the alpha mask here, so there's a special case in // processBitmasks() that doesn't always overwrite that value. if (isWindowsV4Plus()) { m_bitMasks[0] = readUint32(data, 40); m_bitMasks[1] = readUint32(data, 44); m_bitMasks[2] = readUint32(data, 48); m_bitMasks[3] = readUint32(data, 52); } // Detect top-down BMPs. if (m_infoHeader.biHeight < 0) { m_isTopDown = true; m_infoHeader.biHeight = -m_infoHeader.biHeight; } return true; } bool BMPImageReader::isInfoHeaderValid() const { // Non-positive widths/heights are invalid. (We've already flipped the // sign of the height for top-down bitmaps.) if ((m_infoHeader.biWidth <= 0) || (m_infoHeader.biHeight == 0)) return false; // Only Windows V3+ has top-down bitmaps. if (m_isTopDown && (m_isOS21x || m_isOS22x)) return false; // Only bit depths of 1, 4, 8, or 24 are universally supported. if ((m_infoHeader.biBitCount != 1) && (m_infoHeader.biBitCount != 4) && (m_infoHeader.biBitCount != 8) && (m_infoHeader.biBitCount != 24)) { // Windows V3+ additionally supports bit depths of 0 (for embedded // JPEG/PNG images), 16, and 32. if (m_isOS21x || m_isOS22x) return false; if ((m_infoHeader.biBitCount != 0) && (m_infoHeader.biBitCount != 16) && (m_infoHeader.biBitCount != 32)) return false; } // Each compression type is only valid with certain bit depths (except RGB, // which can be used with any bit depth). Also, some formats do not // some compression types. switch (m_infoHeader.biCompression) { case RGB: if (m_infoHeader.biBitCount == 0) return false; break; case RLE8: // Supposedly there are undocumented formats like "BitCount = 1, // Compression = RLE4" (which means "4 bit, but with a 2-color table"), // so also allow the paletted RLE compression types to have too low a // bit count; we'll correct this later. if (m_infoHeader.biBitCount == 0 || m_infoHeader.biBitCount > 8) return false; break; case RLE4: // See comments in RLE8. if (m_infoHeader.biBitCount == 0 || m_infoHeader.biBitCount > 4) return false; break; case BITFIELDS: // Only valid for Windows V3+. if (m_isOS21x || m_isOS22x) return false; if ((m_infoHeader.biBitCount != 16) && (m_infoHeader.biBitCount != 32)) return false; break; case JPEG: case PNG: // Only valid for Windows V3+. if (m_isOS21x || m_isOS22x) return false; if (m_infoHeader.biBitCount != 0) return false; break; case HUFFMAN1D: // Only valid for OS/2 2.x. if (!m_isOS22x) return false; if (m_infoHeader.biBitCount != 1) return false; break; case RLE24: // Only valid for OS/2 2.x. if (!m_isOS22x) return false; if (m_infoHeader.biBitCount != 24) return false; break; default: // Some type we don't understand. This should have been caught in // readInfoHeader(). ASSERT_NOT_REACHED(); return false; } // Top-down bitmaps cannot be compressed; they must be RGB or BITFIELDS. if (m_isTopDown && (m_infoHeader.biCompression != RGB) && (m_infoHeader.biCompression != BITFIELDS)) return false; // Reject the following valid bitmap types that we don't currently bother // decoding. Few other people decode these either, they're unlikely to be // in much use. // TODO(pkasting): Consider supporting these someday. // * Bitmaps larger than 2^16 pixels in either dimension (Windows // probably doesn't draw these well anyway, and the decoded data would // take a lot of memory). if ((m_infoHeader.biWidth >= (1 << 16)) || (m_infoHeader.biHeight >= (1 << 16))) return false; // * Windows V3+ JPEG-in-BMP and PNG-in-BMP bitmaps (supposedly not found // in the wild, only used to send data to printers?). if ((m_infoHeader.biCompression == JPEG) || (m_infoHeader.biCompression == PNG)) return false; // * OS/2 2.x Huffman-encoded monochrome bitmaps (see // http://www.fileformat.info/mirror/egff/ch09_05.htm , re: "G31D" // algorithm). if (m_infoHeader.biCompression == HUFFMAN1D) return false; return true; } bool BMPImageReader::processBitmasks(SharedBuffer* data) { // Create m_bitMasks[] values. if (m_infoHeader.biCompression != BITFIELDS) { // The format doesn't actually use bitmasks. To simplify the decode // logic later, create bitmasks for the RGB data. For Windows V4+, // this overwrites the masks we read from the header, which are // supposed to be ignored in non-BITFIELDS cases. // 16 bits: MSB <- xRRRRRGG GGGBBBBB -> LSB // 24/32 bits: MSB <- [AAAAAAAA] RRRRRRRR GGGGGGGG BBBBBBBB -> LSB const int numBits = (m_infoHeader.biBitCount == 16) ? 5 : 8; for (int i = 0; i <= 2; ++i) { m_bitMasks[i] = ((static_cast(1) << (numBits * (3 - i))) - 1) ^ ((static_cast(1) << (numBits * (2 - i))) - 1); } // For Windows V4+ 32-bit RGB, don't overwrite the alpha mask from the // header (see note in readInfoHeader()). if (m_infoHeader.biBitCount < 32) m_bitMasks[3] = 0; else if (!isWindowsV4Plus()) m_bitMasks[3] = static_cast(0xff000000); } else if (!isWindowsV4Plus()) { // For Windows V4+ BITFIELDS mode bitmaps, this was already done when // we read the info header. // Fail if we don't have enough file space for the bitmasks. static const int SIZEOF_BITMASKS = 12; if (((m_headerOffset + m_infoHeader.biSize + SIZEOF_BITMASKS) < (m_headerOffset + m_infoHeader.biSize)) || (m_imgDataOffset && (m_imgDataOffset < (m_headerOffset + m_infoHeader.biSize + SIZEOF_BITMASKS)))) { m_failed = true; return false; } // Read bitmasks. if ((data->size() - m_decodedOffset) < SIZEOF_BITMASKS) return false; m_bitMasks[0] = readUint32(data, 0); m_bitMasks[1] = readUint32(data, 4); m_bitMasks[2] = readUint32(data, 8); // No alpha in anything other than Windows V4+. m_bitMasks[3] = 0; m_decodedOffset += SIZEOF_BITMASKS; } // 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_needToProcessBitmasks = false; // Check masks and set shift values. for (int i = 0; i < 4; ++i) { // Trim the mask to the allowed bit depth. Some Windows V4+ BMPs // specify a bogus alpha channel in bits that don't exist in the pixel // data (for example, bits 25-31 in a 24-bit RGB format). if (m_infoHeader.biBitCount < 32) m_bitMasks[i] &= ((static_cast(1) << m_infoHeader.biBitCount) - 1); // For empty masks (common on the alpha channel, especially after the // trimming above), quickly clear the shifts and continue, to avoid an // infinite loop in the counting code below. uint32_t tempMask = m_bitMasks[i]; if (!tempMask) { m_bitShiftsRight[i] = m_bitShiftsLeft[i] = 0; continue; } // Make sure bitmask does not overlap any other bitmasks. for (int j = 0; j < i; ++j) { if (tempMask & m_bitMasks[j]) { m_failed = true; return false; } } // Count offset into pixel data. for (m_bitShiftsRight[i] = 0; !(tempMask & 1); tempMask >>= 1) ++m_bitShiftsRight[i]; // Count size of mask. for (m_bitShiftsLeft[i] = 8; tempMask & 1; tempMask >>= 1) --m_bitShiftsLeft[i]; // Make sure bitmask is contiguous. if (tempMask) { m_failed = true; return false; } // Since RGBABuffer tops out at 8 bits per channel, adjust the shift // amounts to use the most significant 8 bits of the channel. if (m_bitShiftsLeft[i] < 0) { m_bitShiftsRight[i] -= m_bitShiftsLeft[i]; m_bitShiftsLeft[i] = 0; } } return true; } bool BMPImageReader::processColorTable(SharedBuffer* data) { m_tableSizeInBytes = m_infoHeader.biClrUsed * (m_isOS21x ? 3 : 4); // Fail if we don't have enough file space for the color table. if (((m_headerOffset + m_infoHeader.biSize + m_tableSizeInBytes) < (m_headerOffset + m_infoHeader.biSize)) || (m_imgDataOffset && (m_imgDataOffset < (m_headerOffset + m_infoHeader.biSize + m_tableSizeInBytes)))) { m_failed = true; return false; } // Read color table. if ((m_decodedOffset > data->size()) || ((data->size() - m_decodedOffset) < m_tableSizeInBytes)) return false; m_colorTable.resize(m_infoHeader.biClrUsed); for (size_t i = 0; i < m_infoHeader.biClrUsed; ++i) { m_colorTable[i].rgbBlue = data->data()[m_decodedOffset++]; m_colorTable[i].rgbGreen = data->data()[m_decodedOffset++]; m_colorTable[i].rgbRed = data->data()[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; return true; } bool BMPImageReader::processRLEData(SharedBuffer* data) { if (m_decodedOffset > data->size()) return false; // RLE decoding is poorly specified. Two main problems: // (1) Are EOL markers necessary? What happens when we have too many // pixels for one row? // http://www.fileformat.info/format/bmp/egff.htm says extra pixels // should wrap to the next line. Real BMPs I've encountered seem to // instead expect extra pixels to be ignored until the EOL marker is // seen, although this has only happened in a few cases and I suspect // those BMPs may be invalid. So we only change lines on EOL (or Delta // with dy > 0), and fail in most cases when pixels extend past the end // of the line. // (2) When Delta, EOL, or EOF are seen, what happens to the "skipped" // pixels? // http://www.daubnet.com/formats/BMP.html says these should be filled // with color 0. However, the "do nothing" and "don't care" comments // of other references suggest leaving these alone, i.e. letting them // be transparent to the background behind the image. This seems to // match how MSPAINT treats BMPs, so we do that. Note that when we // actually skip pixels for a case like this, we need to note on the // framebuffer that we have alpha. // 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 ((data->size() - m_decodedOffset) < 2) return false; // For every entry except EOF, we'd better not have reached the end of // the image. const uint8_t count = data->data()[m_decodedOffset]; const uint8_t code = data->data()[m_decodedOffset + 1]; if (((count != 0) || (code != 1)) && pastEndOfImage(0)) { m_failed = true; return false; } // Decode. if (count == 0) { switch (code) { case 0: // Magic token: EOL // Skip any remaining pixels in this row. if (m_coord.x() < size().width()) m_frameBufferCache.first().setHasAlpha(true); moveBufferToNextRow(); m_decodedOffset += 2; break; case 1: // Magic token: EOF // Skip any remaining pixels in the image. if ((m_coord.x() < size().width()) || (m_isTopDown ? (m_coord.y() < (size().height() - 1)) : (m_coord.y() > 0))) m_frameBufferCache.first().setHasAlpha(true); return true; case 2: { // Magic token: Delta // The next two bytes specify dx and dy. Bail if there isn't // enough data. if ((data->size() - m_decodedOffset) < 4) return false; // Fail if this takes us past the end of the desired row or // past the end of the image. const uint8_t dx = data->data()[m_decodedOffset + 2]; const uint8_t dy = data->data()[m_decodedOffset + 3]; if ((dx != 0) || (dy != 0)) m_frameBufferCache.first().setHasAlpha(true); if (((m_coord.x() + dx) > size().width()) || pastEndOfImage(dy)) { m_failed = true; return false; } // Skip intervening pixels. m_coord.move(dx, m_isTopDown ? dy : -dy); m_decodedOffset += 4; break; } default: // Absolute mode // |code| pixels specified as in BI_RGB, zero-padded at the end // to a multiple of 16 bits. // Because processNonRLEData() expects m_decodedOffset to // point to the beginning of the pixel data, bump it past // the escape bytes and then reset if decoding failed. m_decodedOffset += 2; if (!processNonRLEData(data, true, code)) { m_decodedOffset -= 2; return false; } break; } } else { // Encoded mode // The following color data is repeated for |count| total pixels. // 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, size().width()); if (m_infoHeader.biCompression == RLE24) { // Bail if there isn't enough data. if ((data->size() - m_decodedOffset) < 4) return false; // One BGR triple that we copy |count| times. fillRGBA(endX, data->data()[m_decodedOffset + 3], data->data()[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; } if ((colorIndexes[0] >= m_infoHeader.biClrUsed) || (colorIndexes[1] >= m_infoHeader.biClrUsed)) { m_failed = true; return false; } for (int which = 0; m_coord.x() < endX; ) { setI(colorIndexes[which]); which = !which; } m_decodedOffset += 2; } } } } bool BMPImageReader::processNonRLEData(SharedBuffer* data, bool inRLE, int numPixels) { if (m_decodedOffset > data->size()) return false; if (!inRLE) numPixels = size().width(); // Fail if we're being asked to decode more pixels than remain in the row. const int endX = m_coord.x() + numPixels; if (endX > size().width()) { m_failed = true; return false; } // Determine how many bytes of data the requested number of pixels // requires. const size_t pixelsPerByte = 8 / m_infoHeader.biBitCount; const size_t bytesPerPixel = m_infoHeader.biBitCount / 8; const size_t unpaddedNumBytes = (m_infoHeader.biBitCount < 16) ? ((numPixels + pixelsPerByte - 1) / pixelsPerByte) : (numPixels * bytesPerPixel); // RLE runs are zero-padded at the end to a multiple of 16 bits. Non-RLE // data is in rows and is zero-padded to a multiple of 32 bits. const size_t alignBits = inRLE ? 1 : 3; const size_t paddedNumBytes = (unpaddedNumBytes + alignBits) & ~alignBits; // Decode as many rows as we can. (For RLE, where we only want to decode // one row, we've already checked that this condition is true.) while (!pastEndOfImage(0)) { // Bail if we don't have enough data for the desired number of pixels. if ((data->size() - m_decodedOffset) < paddedNumBytes) return false; 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 = data->data()[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_andMaskState == Decoding) { // 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_frameBufferCache.first().setHasAlpha(true); } else m_coord.move(1, 0); } else { if (colorIndex >= m_infoHeader.biClrUsed) { m_failed = true; return false; } setI(colorIndex); } pixelData <<= m_infoHeader.biBitCount; } } } else { // RGB data. Decode pixels one at a time, left to right. while (m_coord.x() < endX) { const uint32_t pixel = readCurrentPixel(data, 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. int alpha = getAlpha(pixel); if (!m_seenNonZeroAlphaPixel && (alpha == 0)) { m_seenZeroAlphaPixel = true; alpha = 255; } else { m_seenNonZeroAlphaPixel = true; if (m_seenZeroAlphaPixel) { // The eraseARGB() call here also sets "hasAlpha" true. m_frameBufferCache.first().bitmap().eraseARGB(0, 0, 0, 0); m_seenZeroAlphaPixel = false; } else if (alpha != 255) m_frameBufferCache.first().setHasAlpha(true); } setRGBA(getComponent(pixel, 0), getComponent(pixel, 1), getComponent(pixel, 2), alpha); } } // Success, keep going. m_decodedOffset += paddedNumBytes; if (inRLE) return true; moveBufferToNextRow(); } // Finished decoding whole image. return true; } void BMPImageReader::moveBufferToNextRow() { m_coord.move(-m_coord.x(), m_isTopDown ? 1 : -1); } } // namespace WebCore