Bmp Image Decoding

src/codec/SkCodec_libbmp.cpp

+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkCodec_libbmp.h"
+#include "SkColorPriv.h"
+#include "SkStream.h"
+
+/*
+ *
+ * Checks if the conversion between the input image and the requested output
+ * image has been implemented
+ *
+ */
+static bool conversion_possible(const SkImageInfo& dst,
+                                const SkImageInfo& src) {
+    // All of the swizzles convert to kN32
+    // TODO: Update this when more swizzles are supported
+    if (kN32_SkColorType != dst.colorType()) {
+        return false;
+    }
+    // Support the swizzle if the requested alpha type is the same as our guess
+    // for the input alpha type
+    if (src.alphaType() == dst.alphaType()) {
+        return true;
+    }
+    // Also support requests for premul in the unpremul case, despite the fact
+    // that all of the swizzles currently create an unpremul image
+    // TODO: Update the swizzles so this makes more sense
+    return premul_and_unpremul(dst.alphaType(), src.alphaType())
+            || premul_and_unpremul(dst.alphaType(), src.alphaType());
+}
+
+/*
+ *
+ * Defines the version and type of the second bitmap header
+ *
+ */
+enum BitmapHeaderType {
+    kInfoV1_BitmapHeaderType,
+    kInfoV2_BitmapHeaderType,
+    kInfoV3_BitmapHeaderType,
+    kInfoV4_BitmapHeaderType,
+    kInfoV5_BitmapHeaderType,
+    kOS2V1_BitmapHeaderType,
+    kOS2VX_BitmapHeaderType,
+    kUnknown_BitmapHeaderType
+};
+
+/*
+ *
+ * Possible bitmap compression types
+ *
+ */
+enum BitmapCompressionMethod {
+    kNone_BitmapCompressionMethod =          0,
+    k8BitRLE_BitmapCompressionMethod =       1,
+    k4BitRLE_BitmapCompressionMethod =       2,
+    kBitMasks_BitmapCompressionMethod =      3,
+    kJpeg_BitmapCompressionMethod =          4,
+    kPng_BitmapCompressionMethod =           5,
+    kAlphaBitMasks_BitmapCompressionMethod = 6,
+    kCMYK_BitmapCompressionMethod =          11,
+    kCMYK8BitRLE_BitmapCompressionMethod =   12,
+    kCMYK4BitRLE_BitmapCompressionMethod =   13
+};
+
+/*
+ *
+ * Checks the start of the stream to see if the image is a bitmap
+ *
+ */
+bool SkBmpCodec::IsBmp(SkStream* stream) {
+    // TODO: Support "IC", "PT", "CI", "CP", "BA"
+    // TODO: ICO files may contain a BMP and need to use this decoder
+    const char bmpSig[] = { 'B', 'M' };
+    char buffer[sizeof(bmpSig)];
+    return stream->read(buffer, sizeof(bmpSig)) == sizeof(bmpSig) &&
+            !memcmp(buffer, bmpSig, sizeof(bmpSig));
+}
+
+/*
+ *
+ * Assumes IsBmp was called and returned true
+ * Creates a bitmap decoder
+ * Reads enough of the stream to determine the image format
+ *
+ */
+SkCodec* SkBmpCodec::NewFromStream(SkStream* stream) {
+    // Header size constants
+    static const uint32_t kBmpHeaderBytes = 14;
+    static const uint32_t kBmpHeaderBytesPlusFour = kBmpHeaderBytes + 4;
+    static const uint32_t kBmpOS2V1Bytes = 12;
+    static const uint32_t kBmpOS2V2Bytes = 64;
+    static const uint32_t kBmpInfoBaseBytes = 16;
+    static const uint32_t kBmpInfoV1Bytes = 40;
+    static const uint32_t kBmpInfoV2Bytes = 52;
+    static const uint32_t kBmpInfoV3Bytes = 56;
+    static const uint32_t kBmpInfoV4Bytes = 108;
+    static const uint32_t kBmpInfoV5Bytes = 124;
+    static const uint32_t kBmpMaskBytes = 12;
+
+    // Read the first header and the size of the second header
+    SkAutoTDeleteArray<uint8_t> hBuffer(
+            SkNEW_ARRAY(uint8_t, kBmpHeaderBytesPlusFour));
+    if (stream->read(hBuffer.get(), kBmpHeaderBytesPlusFour) !=
+            kBmpHeaderBytesPlusFour) {
+        SkDebugf("Error: unable to read first bitmap header.\n");
+        return NULL;
+    }
+
+    // The total bytes in the bmp file
+    // We only need to use this value for RLE decoding, so we will only check
+    // that it is valid in the RLE case.
+    const uint32_t totalBytes = get_int(hBuffer.get(), 2);
+
+    // The offset from the start of the file where the pixel data begins
+    const uint32_t offset = get_int(hBuffer.get(), 10);
+    if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) {
+        SkDebugf("Error: invalid starting location for pixel data\n");
+        return NULL;
+    }
+
+    // The size of the second (info) header in bytes
+    // The size is the first field of the second header, so we have already
+    // read the first four infoBytes.
+    const uint32_t infoBytes = get_int(hBuffer.get(), 14);
+    if (infoBytes < kBmpOS2V1Bytes) {
+        SkDebugf("Error: invalid second header size.\n");
+        return NULL;
+    }
+    const uint32_t infoBytesRemaining = infoBytes - 4;
+    hBuffer.free();
+
+    // Read the second header
+    SkAutoTDeleteArray<uint8_t> iBuffer(
+            SkNEW_ARRAY(uint8_t, infoBytesRemaining));
+    if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) {
+        SkDebugf("Error: unable to read second bitmap header.\n");
+        return NULL;
+    }
+
+    // The number of bits used per pixel in the pixel data
+    uint16_t bitsPerPixel;
+
+    // The compression method for the pixel data
+    uint32_t compression = kNone_BitmapCompressionMethod;
+
+    // Number of colors in the color table, defaults to 0 or max (see below)
+    uint32_t numColors = 0;
+
+    // Bytes per color in the color table, early versions use 3, most use 4
+    uint32_t bytesPerColor;
+
+    // The image width and height
+    int width, height;
+
+    // Determine image information depending on second header format
+    BitmapHeaderType headerType;
+    if (infoBytes >= kBmpInfoBaseBytes) {
+        // Check the version of the header
+        switch (infoBytes) {
+            case kBmpInfoV1Bytes:
+                headerType = kInfoV1_BitmapHeaderType;
+                break;
+            case kBmpInfoV2Bytes:
+                headerType = kInfoV2_BitmapHeaderType;
+                break;
+            case kBmpInfoV3Bytes:
+                headerType = kInfoV3_BitmapHeaderType;
+                break;
+            case kBmpInfoV4Bytes:
+                headerType = kInfoV4_BitmapHeaderType;
+                break;
+            case kBmpInfoV5Bytes:
+                headerType = kInfoV5_BitmapHeaderType;
+                break;
+            case 16:
+            case 20:
+            case 24:
+            case 28:
+            case 32:
+            case 36:
+            case 42:
+            case 46:
+            case 48:
+            case 60:
+            case kBmpOS2V2Bytes:
+                headerType = kOS2VX_BitmapHeaderType;
+                break;
+            default:
+                // We do not signal an error here because there is the
+                // possibility of new or undocumented bmp header types.  Most
+                // of the newer versions of bmp headers are similar to and
+                // build off of the older versions, so we may still be able to
+                // decode the bmp.
+                SkDebugf("Warning: unknown bmp header format.\n");
+                headerType = kUnknown_BitmapHeaderType;
+                break;
+        }
+        // We check the size of the header before entering the if statement.
+        // We should not reach this point unless the size is large enough for
+        // these required fields.
+        SkASSERT(infoBytesRemaining >= 12);
+        width = get_int(iBuffer.get(), 0);
+        height = get_int(iBuffer.get(), 4);
+        bitsPerPixel = get_short(iBuffer.get(), 10);
+
+        // Some versions do not have these fields, so we check before
+        // overwriting the default value.
+        if (infoBytesRemaining >= 16) {
+            compression = get_int(iBuffer.get(), 12);
+            if (infoBytesRemaining >= 32) {
+                numColors = get_int(iBuffer.get(), 28);
+            }
+        }
+
+        // All of the headers that reach this point, store color table entries
+        // using 4 bytes per pixel.
+        bytesPerColor = 4;
+    } else if (infoBytes >= kBmpOS2V1Bytes) {
+        // The OS2V1 is treated separately because it has a unique format
+        headerType = kOS2V1_BitmapHeaderType;
+        width = (int) get_short(iBuffer.get(), 0);
+        height = (int) get_short(iBuffer.get(), 2);
+        bitsPerPixel = get_short(iBuffer.get(), 6);
+        bytesPerColor = 3;
+    } else {
+        // There are no valid bmp headers
+        SkDebugf("Error: second bitmap header size is invalid.\n");
+        return NULL;
+    }
+
+    // Check for valid dimensions from header
+    RowOrder rowOrder = kBottomUp_RowOrder;
+    if (height < 0) {
+        height = -height;
+        rowOrder = kTopDown_RowOrder;
+    }
+    static const int kBmpMaxDim = 1 << 16;
+    if (width < 0 || width >= kBmpMaxDim || height >= kBmpMaxDim) {
+        // TODO: Decide if we want to support really large bmps.
+        SkDebugf("Error: invalid bitmap dimensions.\n");
+        return NULL;
+    }
+
+    // Create mask struct
+    SkMasks::InputMasks inputMasks;
+    memset(&inputMasks, 0, 4*sizeof(uint32_t));
+
+    // Determine the input compression format and set bit masks if necessary
+    uint32_t maskBytes = 0;
+    BitmapInputFormat inputFormat = kUnknown_BitmapInputFormat;
+    switch (compression) {
+        case kNone_BitmapCompressionMethod:
+            inputFormat = kStandard_BitmapInputFormat;
+            break;
+        case k8BitRLE_BitmapCompressionMethod:
+            if (bitsPerPixel != 8) {
+                SkDebugf("Warning: correcting invalid bitmap format.\n");
+                bitsPerPixel = 8;
+            }
+            inputFormat = kRLE_BitmapInputFormat;
+            break;
+        case k4BitRLE_BitmapCompressionMethod:
+            if (bitsPerPixel != 4) {
+                SkDebugf("Warning: correcting invalid bitmap format.\n");
+                bitsPerPixel = 4;
+            }
+            inputFormat = kRLE_BitmapInputFormat;
+            break;
+        case kAlphaBitMasks_BitmapCompressionMethod:
+        case kBitMasks_BitmapCompressionMethod:
+            // Load the masks
+            inputFormat = kBitMask_BitmapInputFormat;
+            switch (headerType) {
+                case kInfoV1_BitmapHeaderType: {
+                    // The V1 header stores the bit masks after the header
+                    SkAutoTDeleteArray<uint8_t> mBuffer(
+                            SkNEW_ARRAY(uint8_t, kBmpMaskBytes));
+                    if (stream->read(mBuffer.get(), kBmpMaskBytes) !=
+                            kBmpMaskBytes) {
+                        SkDebugf("Error: unable to read bit inputMasks.\n");
+                        return NULL;
+                    }
+                    maskBytes = kBmpMaskBytes;
+                    inputMasks.red = get_int(mBuffer.get(), 0);
+                    inputMasks.green = get_int(mBuffer.get(), 4);
+                    inputMasks.blue = get_int(mBuffer.get(), 8);
+                    break;
+                }
+                case kInfoV2_BitmapHeaderType:
+                case kInfoV3_BitmapHeaderType:
+                case kInfoV4_BitmapHeaderType:
+                case kInfoV5_BitmapHeaderType:
+                    // Header types are matched based on size.  If the header
+                    // is V2+, we are guaranteed to be able to read at least
+                    // this size.
+                    SkASSERT(infoBytesRemaining >= 48);
+                    inputMasks.red = get_int(iBuffer.get(), 36);
+                    inputMasks.green = get_int(iBuffer.get(), 40);
+                    inputMasks.blue = get_int(iBuffer.get(), 44);
+                    break;
+                case kOS2VX_BitmapHeaderType:
+                    // TODO: Decide if we intend to support this.
+                    //       It is unsupported in the previous version and
+                    //       in chromium.  I have not come across a test case
+                    //       that uses this format.
+                    SkDebugf("Error: huffman format unsupported.\n");
+                    return NULL;
+                default:
+                   SkDebugf("Error: invalid bmp bit masks header.\n");
+                   return NULL;
+            }
+            break;
+        case kJpeg_BitmapCompressionMethod:
+            if (24 == bitsPerPixel) {
+                inputFormat = kRLE_BitmapInputFormat;
+                break;
+            }
+            // Fall through
+        case kPng_BitmapCompressionMethod:
+            // TODO: Decide if we intend to support this.
+            //       It is unsupported in the previous version and
+            //       in chromium.  I think it is used mostly for printers.
+            SkDebugf("Error: compression format not supported.\n");
+            return NULL;
+        case kCMYK_BitmapCompressionMethod:
+        case kCMYK8BitRLE_BitmapCompressionMethod:
+        case kCMYK4BitRLE_BitmapCompressionMethod:
+            // TODO: Same as above.
+            SkDebugf("Error: CMYK not supported for bitmap decoding.\n");
+            return NULL;
+        default:
+            SkDebugf("Error: invalid format for bitmap decoding.\n");
+            return NULL;
+    }
+
+    // Most versions of bmps should be rendered as opaque.  Either they do
+    // not have an alpha channel, or they expect the alpha channel to be
+    // ignored.  V4+ bmp files introduce an alpha mask and allow the creator
+    // of the image to use the alpha channels.  However, many of these images
+    // leave the alpha channel blank and expect to be rendered as opaque.  For
+    // this reason, we set the alpha type to kUnknown for V4+ bmps and figure
+    // out the alpha type during the decode.
+    SkAlphaType alphaType = kOpaque_SkAlphaType;
+    if (kInfoV4_BitmapHeaderType == headerType ||
+            kInfoV5_BitmapHeaderType == headerType) {
+        // Header types are matched based on size.  If the header is
+        // V4+, we are guaranteed to be able to read at least this size.
+        SkASSERT(infoBytesRemaining > 52);
+        inputMasks.alpha = get_int(iBuffer.get(), 48);
+        if (inputMasks.alpha != 0) {
+            alphaType = kUnpremul_SkAlphaType;
+        }
+    }
+    iBuffer.free();
+
+    // Check for valid bits per pixel input
+    switch (bitsPerPixel) {
+        // In addition to more standard pixel compression formats, bmp supports
+        // the use of bit masks to determine pixel components.  The standard
+        // format for representing 16-bit colors is 555 (XRRRRRGGGGGBBBBB),
+        // which does not map well to any Skia color formats.  For this reason,
+        // we will always enable mask mode with 16 bits per pixel.
+        case 16:
+            if (kBitMask_BitmapInputFormat != inputFormat) {
+                inputMasks.red = 0x7C00;
+                inputMasks.green = 0x03E0;
+                inputMasks.blue = 0x001F;
+                inputFormat = kBitMask_BitmapInputFormat;
+            }
+            break;
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+        case 24:
+        case 32:
+            break;
+        default:
+            SkDebugf("Error: invalid input value for bits per pixel.\n");
+            return NULL;
+    }
+
+    // Check that input bit masks are valid and create the masks object
+    SkAutoTDelete<SkMasks>
+            masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
+    if (NULL == masks) {
+        SkDebugf("Error: invalid input masks.\n");
+        return NULL;
+    }
+
+    // Process the color table
+    uint32_t colorBytes = 0;
+    SkPMColor* colorTable = NULL;
+    if (bitsPerPixel < 16) {
+        // Verify the number of colors for the color table
+        const uint32_t maxColors = 1 << bitsPerPixel;
+        // Zero is a default for maxColors
+        // Also set numColors to maxColors when input is too large
+        if (numColors <= 0 || numColors > maxColors) {
+            numColors = maxColors;
+        }
+        colorTable = SkNEW_ARRAY(SkPMColor, maxColors);
+
+        // Construct the color table
+        colorBytes = numColors * bytesPerColor;
+        SkAutoTDeleteArray<uint8_t> cBuffer(SkNEW_ARRAY(uint8_t, colorBytes));
+        if (stream->read(cBuffer.get(), colorBytes) != colorBytes) {
+            SkDebugf("Error: unable to read color table.\n");
+            return NULL;
+        }
+
+        // Fill in the color table (colors are stored unpremultiplied)
+        uint32_t i = 0;
+        for (; i < numColors; i++) {
+            uint8_t blue = get_byte(cBuffer.get(), i*bytesPerColor);
+            uint8_t green = get_byte(cBuffer.get(), i*bytesPerColor + 1);
+            uint8_t red = get_byte(cBuffer.get(), i*bytesPerColor + 2);
+            uint8_t alpha = 0xFF;
+            if (kOpaque_SkAlphaType != alphaType) {
+                alpha = (inputMasks.alpha >> 24) &
+                        get_byte(cBuffer.get(), i*bytesPerColor + 3);
+            }
+            // Store the unpremultiplied color
+            colorTable[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
+        }
+
+        // To avoid segmentation faults on bad pixel data, fill the end of the
+        // color table with black.  This is the same the behavior as the
+        // chromium decoder.
+        for (; i < maxColors; i++) {
+            colorTable[i] = SkPackARGB32NoCheck(0xFF, 0, 0, 0);
+        }
+    } else {
+        // We will not use the color table if bitsPerPixel >= 16, but if there
+        // is a color table, we may need to skip the color table bytes.
+        // We will assume that the maximum color table size is the same as when
+        // there are 8 bits per pixel (the largest color table actually used).
+        // Color tables for greater than 8 bits per pixel are somewhat
+        // undocumented.  It is indicated that they may exist to store a list
+        // of colors for optimization on devices with limited color display
+        // capacity.  While we do not know for sure, we will guess that any
+        // value of numColors greater than this maximum is invalid.
+        if (numColors <= (1 << 8)) {
+            colorBytes = numColors * bytesPerColor;
+            if (stream->skip(colorBytes) != colorBytes) {
+                SkDebugf("Error: Could not skip color table bytes.\n");
+                return NULL;
+            }
+        }
+    }
+
+    // Ensure that the stream now points to the start of the pixel array
+    uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes + colorBytes;
+
+    // Check that we have not read past the pixel array offset
+    if(bytesRead > offset) {
+        // This may occur on OS 2.1 and other old versions where the color
+        // table defaults to max size, and the bmp tries to use a smaller color
+        // table.  This is invalid, and our decision is to indicate an error,
+        // rather than try to guess the intended size of the color table and
+        // rewind the stream to display the image.
+        SkDebugf("Error: pixel data offset less than header size.\n");
+        return NULL;
+    }
+
+    // Skip to the start of the pixel array
+    if (stream->skip(offset - bytesRead) != offset - bytesRead) {
+        SkDebugf("Error: unable to skip to image data.\n");
+        return NULL;
+    }
+
+    // Remaining bytes is only used for RLE
+    const int remainingBytes = totalBytes - offset;
+    if (remainingBytes <= 0 && kRLE_BitmapInputFormat == inputFormat) {
+        SkDebugf("Error: RLE requires valid input size.\n");
+        return NULL;
+    }
+
+    // Return the codec
+    // We will use ImageInfo to store width, height, and alpha type.  We will
+    // choose kN32_SkColorType as the input color type because that is the
+    // expected choice for a destination color type.  In reality, the input
+    // color type has many possible formats.
+    const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
+            kN32_SkColorType, alphaType);
+    return SkNEW_ARGS(SkBmpCodec, (imageInfo, stream, bitsPerPixel,
+                                   inputFormat, masks.detach(), colorTable,
+                                   rowOrder, remainingBytes));
+}
+
+/*
+ *
+ * Creates an instance of the decoder
+ * Called only by NewFromStream
+ *
+ */
+SkBmpCodec::SkBmpCodec(const SkImageInfo& info, SkStream* stream,
+                       uint16_t bitsPerPixel, BitmapInputFormat inputFormat,
+                       SkMasks* masks, SkPMColor* colorTable,
+                       RowOrder rowOrder,
+                       const uint32_t remainingBytes)
+    : INHERITED(info, stream)
+    , fBitsPerPixel(bitsPerPixel)
+    , fInputFormat(inputFormat)
+    , fMasks(masks)
+    , fColorTable(colorTable)
+    , fRowOrder(rowOrder)
+    , fRemainingBytes(remainingBytes)
+{}
+
+/*
+ *
+ * Initiates the bitmap decode
+ *
+ */
+SkCodec::Result SkBmpCodec::onGetPixels(const SkImageInfo& dstInfo,
+                                        void* dst, size_t dstRowBytes,
+                                        SkPMColor*, int*) {
+    if (!this->rewindIfNeeded()) {
+        return kCouldNotRewind;
+    }
+    if (dstInfo.dimensions() != this->getOriginalInfo().dimensions()) {
+        SkDebugf("Error: scaling not supported.\n");
+        return kInvalidScale;
+    }
+    if (!conversion_possible(dstInfo, this->getOriginalInfo())) {
+        SkDebugf("Error: cannot convert input type to output type.\n");
+        return kInvalidConversion;
+    }
+
+    switch (fInputFormat) {
+        case kBitMask_BitmapInputFormat:
+            return decodeMask(dstInfo, dst, dstRowBytes);
+        case kRLE_BitmapInputFormat:
+            return decodeRLE(dstInfo, dst, dstRowBytes);
+        case kStandard_BitmapInputFormat:
+            return decode(dstInfo, dst, dstRowBytes);
+        default:
+            SkASSERT(false);
+            return kInvalidInput;
+    }
+}
+
+/*
+ *
+ * Performs the bitmap decoding for bit masks input format
+ *
+ */
+SkCodec::Result SkBmpCodec::decodeMask(const SkImageInfo& dstInfo,
+                                       void* dst, uint32_t dstRowBytes) {
+    // Set constant values
+    const int width = dstInfo.width();
+    const int height = dstInfo.height();
+    const size_t rowBytes = SkAlign4(compute_row_bytes(width, fBitsPerPixel));
+
+    // Allocate space for a row buffer and a source for the swizzler
+    SkAutoTDeleteArray<uint8_t> srcBuffer(SkNEW_ARRAY(uint8_t, rowBytes));
+
+    // Get the destination start row and delta
+    SkPMColor* dstRow;
+    int32_t delta;
+    if (kTopDown_RowOrder == fRowOrder) {
+        dstRow = (SkPMColor*) dst;
+        delta = dstRowBytes;
+    } else {
+        dstRow = (SkPMColor*) SkTAddOffset<void>(dst, (height-1) * dstRowBytes);
+        delta = -dstRowBytes;
+    }
+
+    // Create the swizzler
+    SkMaskSwizzler* swizzler = SkMaskSwizzler::CreateMaskSwizzler(
+            dstInfo, fMasks, fBitsPerPixel);
+
+    // Iterate over rows of the image
+    bool transparent = true;
+    for (int y = 0; y < height; y++) {
+        // Read a row of the input
+        if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
+            SkDebugf("Warning: incomplete input stream.\n");
+            return kIncompleteInput;
+        }
+
+        // Decode the row in destination format
+        SkSwizzler::ResultAlpha r = swizzler->next(dstRow, srcBuffer.get());
+        transparent &= SkSwizzler::IsTransparent(r);
+
+        // Move to the next row
+        dstRow = SkTAddOffset<SkPMColor>(dstRow, delta);
+    }
+
+    // Many fully transparent bmp images are intended to be opaque.  Here, we
+    // correct for this possibility.
+    dstRow = (SkPMColor*) dst;
+    if (transparent) {
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width; x++) {
+                dstRow[x] |= 0xFF000000;
+            }
+            dstRow = SkTAddOffset<SkPMColor>(dstRow, dstRowBytes);
+        }
+    }
+
+    // Finished decoding the entire image
+    return kSuccess;
+}
+
+/*
+ *
+ * Set an RLE pixel using the color table
+ *
+ */
+void SkBmpCodec::setRLEPixel(SkPMColor* dst, uint32_t dstRowBytes, int height,
+                             uint32_t x, uint32_t y, uint8_t index) {
+    if (kBottomUp_RowOrder == fRowOrder) {
+        y = height - y - 1;
+    }
+    SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, y * dstRowBytes);
+    dstRow[x] = fColorTable.get()[index];
+}
+
+/*
+ *
+ * Performs the bitmap decoding for RLE input format
+ * RLE decoding is performed all at once, rather than a one row at a time
+ *
+ */
+SkCodec::Result SkBmpCodec::decodeRLE(const SkImageInfo& dstInfo,
+                                      void* dst, uint32_t dstRowBytes) {
+    // Set RLE flags
+    static const uint8_t RLE_ESCAPE = 0;
+    static const uint8_t RLE_EOL = 0;
+    static const uint8_t RLE_EOF = 1;
+    static const uint8_t RLE_DELTA = 2;
+
+    // Set constant values
+    const int width = dstInfo.width();
+    const int height = dstInfo.height();
+
+    // Input buffer parameters
+    uint32_t currByte = 0;
+    SkAutoTDeleteArray<uint8_t> buffer(SkNEW_ARRAY(uint8_t, fRemainingBytes));
+    uint32_t totalBytes = stream()->read(buffer.get(), fRemainingBytes);
+    if (totalBytes < fRemainingBytes) {
+        SkDebugf("Warning: incomplete RLE file.\n");
+    } else if (totalBytes <= 0) {
+        SkDebugf("Error: could not read RLE image data.\n");
+        return kInvalidInput;
+    }
+
+    // Destination parameters
+    int x = 0;
+    int y = 0;
+    // If the code skips pixels, remaining pixels are transparent or black
+    // TODO: Skip this if memory was already zeroed.
+    memset(dst, 0, dstRowBytes * height);
+    SkPMColor* dstPtr = (SkPMColor*) dst;
+
+    while (true) {
+        // Every entry takes at least two bytes
+        if (totalBytes - currByte < 2) {
+            SkDebugf("Warning: incomplete RLE input.\n");
+            return kIncompleteInput;
+        }
+
+        // Read the next two bytes.  These bytes have different meanings
+        // depending on their values.  In the first interpretation, the first
+        // byte is an escape flag and the second byte indicates what special
+        // task to perform.
+        const uint8_t flag = buffer.get()[currByte++];
+        const uint8_t task = buffer.get()[currByte++];
+
+        // If we have reached a row that is beyond the image size, and the RLE
+        // code does not indicate end of file, abort and signal a warning.
+        if (y >= height && (flag != RLE_ESCAPE || (task != RLE_EOF))) {
+            SkDebugf("Warning: invalid RLE input.\n");
+            return kIncompleteInput;
+        }
+
+        // Perform decoding
+        if (RLE_ESCAPE == flag) {
+            switch (task) {
+                case RLE_EOL:
+                    x = 0;
+                    y++;
+                    break;
+                case RLE_EOF:
+                    return kSuccess;
+                case RLE_DELTA: {
+                    // Two bytes are needed to specify delta
+                    if (totalBytes - currByte < 2) {
+                        SkDebugf("Warning: incomplete RLE input\n");
+                        return kIncompleteInput;
+                    }
+                    // Modify x and y
+                    const uint8_t dx = buffer.get()[currByte++];
+                    const uint8_t dy = buffer.get()[currByte++];
+                    x += dx;
+                    y += dy;
+                    if (x > width || y > height) {
+                        SkDebugf("Warning: invalid RLE input.\n");
+                        return kIncompleteInput;
+                    }
+                    break;
+                }
+                default: {
+                    // If task does not match any of the above signals, it
+                    // indicates that we have a sequence of non-RLE pixels.
+                    // Furthermore, the value of task is equal to the number
+                    // of pixels to interpret.
+                    uint8_t numPixels = task;
+                    const size_t rowBytes = compute_row_bytes(numPixels,
+                            fBitsPerPixel);
+                    // Abort if setting numPixels moves us off the edge of the
+                    // image.  Also abort if there are not enough bytes
+                    // remaining in the stream to set numPixels.
+                    if (x + numPixels > width ||
+                            totalBytes - currByte < SkAlign2(rowBytes)) {
+                        SkDebugf("Warning: invalid RLE input.\n");
+                        return kIncompleteInput;
+                    }
+                    // Set numPixels number of pixels
+                    SkPMColor* dstRow = SkTAddOffset<SkPMColor>(
+                            dstPtr, y * dstRowBytes);
+                    while (numPixels > 0) {
+                        switch(fBitsPerPixel) {
+                            case 4: {
+                                SkASSERT(currByte < totalBytes);
+                                uint8_t val = buffer.get()[currByte++];
+                                setRLEPixel(dstPtr, dstRowBytes, height, x++, y,
+                                        val >> 4);
+                                numPixels--;
+                                if (numPixels != 0) {
+                                    setRLEPixel(dstPtr, dstRowBytes, height,
+                                            x++, y, val & 0xF);
+                                    numPixels--;
+                                }
+                                break;
+                            }
+                            case 8:
+                                SkASSERT(currByte < totalBytes);
+                                setRLEPixel(dstPtr, dstRowBytes, height, x++, y,
+                                        buffer.get()[currByte++]);
+                                numPixels--;
+                                break;
+                            case 24: {
+                                SkASSERT(currByte + 2 < totalBytes);
+                                uint8_t blue = buffer.get()[currByte++];
+                                uint8_t green = buffer.get()[currByte++];
+                                uint8_t red = buffer.get()[currByte++];
+                                SkPMColor color = SkPackARGB32NoCheck(
+                                        0xFF, red, green, blue);
+                                dstRow[x++] = color;
+                                numPixels--;
+                            }
+                            default:
+                                SkASSERT(false);
+                                return kInvalidInput;
+                        }
+                    }
+                    // Skip a byte if necessary to maintain alignment
+                    if (!SkIsAlign2(rowBytes)) {
+                        currByte++;
+                    }
+                    break;
+                }
+            }
+        } else {
+            // If the first byte read is not a flag, it indicates the number of
+            // pixels to set in RLE mode.
+            const uint8_t numPixels = flag;
+            const int endX = SkTMin<int>(x + numPixels, width);
+
+            if (24 == fBitsPerPixel) {
+                // In RLE24, the second byte read is part of the pixel color.
+                // There are two more required bytes to finish encoding the
+                // color.
+                if (totalBytes - currByte < 2) {
+                    SkDebugf("Warning: incomplete RLE input\n");
+                    return kIncompleteInput;
+                }
+
+                // Fill the pixels up to endX with the specified color
+                uint8_t blue = task;
+                uint8_t green = buffer.get()[currByte++];
+                uint8_t red = buffer.get()[currByte++];
+                SkPMColor color = SkPackARGB32NoCheck(0xFF, red, green, blue);
+                SkPMColor* dstRow =
+                        SkTAddOffset<SkPMColor>(dstPtr, y * dstRowBytes);
+                while (x < endX) {
+                    dstRow[x++] = color;
+                }
+            } else {
+                // In RLE8 or RLE4, the second byte read gives the index in the
+                // color table to look up the pixel color.
+                // RLE8 has one color index that gets repeated
+                // RLE4 has two color indexes in the upper and lower 4 bits of
+                // the bytes, which are alternated
+                uint8_t indices[2] = { task, task };
+                if (4 == fBitsPerPixel) {
+                    indices[0] >>= 4;
+                    indices[1] &= 0xf;
+                }
+
+                // Set the indicated number of pixels
+                for (int which = 0; x < endX; x++) {
+                    setRLEPixel(dstPtr, dstRowBytes, height, x, y,
+                            indices[which]);
+                    which = !which;
+                }
+            }
+        }
+    }
+}
+
+/*
+ *
+ * Performs the bitmap decoding for standard input format
+ *
+ */
+SkCodec::Result SkBmpCodec::decode(const SkImageInfo& dstInfo,
+                                   void* dst, uint32_t dstRowBytes) {
+    // Set constant values
+    const int width = dstInfo.width();
+    const int height = dstInfo.height();
+    const size_t rowBytes = SkAlign4(compute_row_bytes(width, fBitsPerPixel));
+    const uint32_t alphaMask = fMasks->getAlphaMask();
+
+    // Get swizzler configuration
+    SkSwizzler::SrcConfig config;
+    switch (fBitsPerPixel) {
+        case 1:
+            config = SkSwizzler::kIndex1;
+            break;
+        case 2:
+            config = SkSwizzler::kIndex2;
+            break;
+        case 4:
+            config = SkSwizzler::kIndex4;
+            break;
+        case 8:
+            config = SkSwizzler::kIndex;
+            break;
+        case 24:
+            config = SkSwizzler::kBGR;
+            break;
+        case 32:
+            if (alphaMask == 0) {
+                config = SkSwizzler::kBGRX;
+            } else {
+                config = SkSwizzler::kBGRA;
+            }
+            break;
+        default:
+            SkASSERT(false);
+            return kInvalidInput;
+    }
+
+    // Create swizzler
+    SkSwizzler* swizzler = SkSwizzler::CreateSwizzler(config, fColorTable.get(),
+            dstInfo, dst, dstRowBytes, false);
+
+    // Allocate space for a row buffer and a source for the swizzler
+    SkAutoTDeleteArray<uint8_t> srcBuffer(SkNEW_ARRAY(uint8_t, rowBytes));
+
+    // Iterate over rows of the image
+    bool transparent = true;
+    for (int y = 0; y < height; y++) {
+        // Read a row of the input
+        if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
+            SkDebugf("Warning: incomplete input stream.\n");
+            return kIncompleteInput;
+        }
+
+        // Decode the row in destination format
+        uint32_t row;
+        if (kTopDown_RowOrder == fRowOrder) {
+            row = y;
+        } else {
+            row = height - 1 - y;
+        }
+        SkSwizzler::ResultAlpha r = swizzler->next(srcBuffer.get(), row);
+        transparent &= SkSwizzler::IsTransparent(r);
+    }
+
+    // Now we adjust the output image with some additional behavior that
+    // SkSwizzler does not support.  Firstly, all bmp images that contain
+    // alpha are masked by the alpha mask.  Secondly, many fully transparent
+    // bmp images are intended to be opaque.  Here, we make those corrections.
+    // Modifying alpha is safe because colors are stored unpremultiplied.
+    SkPMColor* dstRow = (SkPMColor*) dst;
+    if (alphaMask != 0) {
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width; x++) {
+                if (transparent) {
+                    dstRow[x] |= 0xFF000000;
+                } else {
+                    dstRow[x] &= alphaMask;
+                }
+                dstRow = SkTAddOffset<SkPMColor>(dstRow, dstRowBytes);
+            }
+        }
+    }
+
+    // Finished decoding the entire image
+    return kSuccess;
+}