Refactor SkBmpCodec

src/codec/SkBmpCodec.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 "SkBmpCodec.h"
 #include "SkBmpMaskCodec.h"
 #include "SkBmpRLECodec.h"
@@ skipping 268 matching lines @@
     // Create mask struct
     SkMasks::InputMasks inputMasks;
     memset(&inputMasks, 0, sizeof(SkMasks::InputMasks));
 
     // Determine the input compression format and set bit masks if necessary
     uint32_t maskBytes = 0;
     BmpInputFormat inputFormat = kUnknown_BmpInputFormat;
     switch (compression) {
         case kNone_BmpCompressionMethod:
             inputFormat = kStandard_BmpInputFormat;
+
+            // 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.
+            if (16 == bitsPerPixel) {
+                inputMasks.red = 0x7C00;
+                inputMasks.green = 0x03E0;
+                inputMasks.blue = 0x001F;
+                inputFormat = kBitMask_BmpInputFormat;
+            }
             break;
         case k8BitRLE_BmpCompressionMethod:
             if (bitsPerPixel != 8) {
                 SkCodecPrintf("Warning: correcting invalid bitmap format.\n");
                 bitsPerPixel = 8;
             }
             inputFormat = kRLE_BmpInputFormat;
             break;
         case k4BitRLE_BmpCompressionMethod:
             if (bitsPerPixel != 4) {
@@ skipping 25 matching lines @@
                 case kInfoV3_BmpHeaderType:
                 case kInfoV4_BmpHeaderType:
                 case kInfoV5_BmpHeaderType:
                     // 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);
+
+                    if (kInfoV2_BmpHeaderType == headerType ||
+                            (kInfoV3_BmpHeaderType == headerType && !inIco)) {
+                        break;
+                    }
+
+                    // V3+ 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.  This is the
+                    // case for almost all V3 images, so we ignore the alpha mask.  For V4+
+                    // images in kMask mode, we will use the alpha mask.  Additionally, V3
+                    // bmp-in-ico expect us to use the alpha mask.
+                    //
+                    // skbug.com/4116: We should perhaps also apply the alpha mask in kStandard
+                    //                 mode.  We just haven't seen any images that expect this
+                    //                 behavior.
+                    //
+                    // Header types are matched based on size.  If the header is
+                    // V3+, we are guaranteed to be able to read at least this size.
+                    SkASSERT(infoBytesRemaining > 52);
+                    inputMasks.alpha = get_int(iBuffer.get(), 48);
                     break;
                 case kOS2VX_BmpHeaderType:
                     // 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.
                     SkCodecPrintf("Error: huffman format unsupported.\n");
                     return false;
                 default:
                    SkCodecPrintf("Error: invalid bmp bit masks header.\n");
@@ skipping 15 matching lines @@
         case kCMYK_BmpCompressionMethod:
         case kCMYK8BitRLE_BmpCompressionMethod:
         case kCMYK4BitRLE_BmpCompressionMethod:
             // TODO: Same as above.
             SkCodecPrintf("Error: CMYK not supported for bitmap decoding.\n");
             return false;
         default:
             SkCodecPrintf("Error: invalid format for bitmap decoding.\n");
             return false;
     }
-
-    // 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.  V3+ 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.  This
-    // is the case for almost all V3 images, so we render these as opaque.  For
-    // V4+ images in kMask mode, we will use the alpha mask.
-    //
-    // skbug.com/4116: We should perhaps also apply the alpha mask in kStandard
-    //                 mode.  We just haven't seen any images that expect this
-    //                 behavior.
-    //
-    // Additionally, V3 bmp-in-ico may use the alpha mask.
-    SkAlphaType alphaType = kOpaque_SkAlphaType;
-    if ((kInfoV3_BmpHeaderType == headerType && inIco) ||
-            kInfoV4_BmpHeaderType == headerType ||
-            kInfoV5_BmpHeaderType == headerType) {
-        // Header types are matched based on size.  If the header is
-        // V3+, 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.reset();
 
-    // Additionally, 32 bit bmp-in-icos use the alpha channel.
-    // FIXME (msarett): Don't all bmp-in-icos use the alpha channel?
-    // And, RLE inputs may skip pixels, leaving them as transparent.  This
-    // is uncommon, but we cannot be certain that an RLE bmp will be opaque.
-    if ((inIco && 32 == bitsPerPixel) || (kRLE_BmpInputFormat == inputFormat)) {
-        alphaType = kUnpremul_SkAlphaType;
-    }
-
-    // Check for valid bits per pixel.
-    // At the same time, use this information to choose a suggested color type
-    // and to set default masks.
-    SkColorType colorType = kN32_SkColorType;
-    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_BmpInputFormat != inputFormat) {
-                inputMasks.red = 0x7C00;
-                inputMasks.green = 0x03E0;
-                inputMasks.blue = 0x001F;
-                inputFormat = kBitMask_BmpInputFormat;
-            }
-            break;
-        // We want to decode to kIndex_8 for input formats that are already
-        // designed in index format.
-        case 1:
-        case 2:
-        case 4:
-        case 8:
-            // However, we cannot in RLE format since we may need to leave some
-            // pixels as transparent.  Similarly, we also cannot for ICO images
-            // since we may need to apply a transparent mask.
-            if (kRLE_BmpInputFormat != inputFormat && !inIco) {
-                colorType = kIndex_8_SkColorType;
-            }
-
-            // Mask bmps must have 16, 24, or 32 bits per pixel.
-            if (kBitMask_BmpInputFormat == inputFormat) {
-                SkCodecPrintf("Error: invalid input value of bits per pixel for mask bmp.\n");
-                return false;
-            }
-        case 24:
-        case 32:
-            break;
-        default:
-            SkCodecPrintf("Error: invalid input value for bits per pixel.\n");
-            return false;
-    }
-
-    // Check that input bit masks are valid and create the masks object
-    SkAutoTDelete<SkMasks>
-            masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
-    if (nullptr == masks) {
-        SkCodecPrintf("Error: invalid input masks.\n");
-        return false;
-    }
-
-    // Check for a valid number of total bytes when in RLE mode
-    if (totalBytes <= offset && kRLE_BmpInputFormat == inputFormat) {
-        SkCodecPrintf("Error: RLE requires valid input size.\n");
-        return false;
-    }
-    const size_t RLEBytes = totalBytes - offset;
-
     // Calculate the number of bytes read so far
     const uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes;
     if (!inIco && offset < bytesRead) {
         // TODO (msarett): Do we really want to fail if the offset in the header is invalid?
         //                 Seems like we can just assume that the offset is zero and try to decode?
         //                 Maybe we don't want to try to decode corrupt images?
         SkCodecPrintf("Error: pixel data offset less than header size.\n");
         return false;
     }
 
-    // Skip to the start of the pixel array.
-    // We can do this here because there is no color table to read
-    // in bit mask mode.
-    if (!inIco && kBitMask_BmpInputFormat == inputFormat) {
-        if (stream->skip(offset - bytesRead) != offset - bytesRead) {
-            SkCodecPrintf("Error: unable to skip to image data.\n");
-            return false;
-        }
-    }
 
-    if (codecOut) {
-        // BMPs-in-ICOs contain an alpha mask after the image which means we
-        // cannot guarantee that an image is opaque, even if the bmp thinks
-        // it is.
-        bool isOpaque = kOpaque_SkAlphaType == alphaType;
-        if (inIco) {
-            alphaType = kUnpremul_SkAlphaType;
+
+    switch (inputFormat) {
+        case kStandard_BmpInputFormat: {
+            // BMPs-in-ICOs often contain an alpha mask after the image, which
+            // means we cannot guarantee that an image is opaque, even if the
+            // embedded bmp is opaque.
+            // We use |isOpaque| to indicate if the BMP itself is opaque, but
+            // still need to recommend kUnpremul when it is contained in an ICO.
+            SkColorType colorType = kN32_SkColorType;
+            SkAlphaType alphaType = inIco ? kUnpremul_SkAlphaType : kOpaque_SkAlphaType;
+            bool isOpaque = true;
+            switch (bitsPerPixel) {
+                // Palette formats
+                case 1:
+                case 2:
+                case 4:
+                case 8:
+                    // We cannot recommend a palette color type for ICOs because they
+                    // may contain a transparency mask.
+                    if (!inIco) {
+                        colorType = kIndex_8_SkColorType;
+                    }
+                    break;
+                case 24:
+                case 32:
+                    // 32-bit BMP-in-ICOs actually use the alpha channel in place of a
+                    // transparency mask.
+                    if (inIco) {
+                        isOpaque = false;
+                    }
+                    break;
+                default:
+                    SkCodecPrintf("Error: invalid input value for bits per pixel.\n");
+                    return false;
+            }
+
+            if (codecOut) {
+                // We require streams to have a memory base for Bmp-in-Ico decodes.
+                SkASSERT(!inIco || nullptr != stream->getMemoryBase());
+
+                // Set the image info and create a codec.
+                const SkImageInfo imageInfo = SkImageInfo::Make(width, height, colorType,
+                        alphaType);
+                *codecOut = new SkBmpStandardCodec(imageInfo, stream, bitsPerPixel, numColors,
+                        bytesPerColor, offset - bytesRead, rowOrder, isOpaque, inIco);
+
+            }
+            return true;
         }
 
-        // Set the image info
-        const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
-                colorType, alphaType);
+        case kBitMask_BmpInputFormat: {
+            // Bmp-in-Ico must be standard mode
+            if (inIco) {
+                SkCodecPrintf("Error: Icos may not use bit mask format.\n");
+                return false;
+            }
 
-        // Return the codec
-        switch (inputFormat) {
-            case kStandard_BmpInputFormat:
-                // We require streams to have a memory base for Bmp-in-Ico decodes.
-                SkASSERT(!inIco || nullptr != stream->getMemoryBase());
-                *codecOut = new SkBmpStandardCodec(imageInfo, stream, bitsPerPixel, numColors,
-                        bytesPerColor, offset - bytesRead, rowOrder, isOpaque, inIco);
-                return true;
-            case kBitMask_BmpInputFormat:
-                // Bmp-in-Ico must be standard mode
-                if (inIco) {
-                    SkCodecPrintf("Error: Icos may not use bit mask format.\n");
+            switch (bitsPerPixel) {
+                case 16:
+                case 24:
+                case 32:
+                    break;
+                default:
+                    SkCodecPrintf("Error: invalid input value for bits per pixel.\n");
+                    return false;
+            }
+
+            // Skip to the start of the pixel array.
+            // We can do this here because there is no color table to read
+            // in bit mask mode.
+            if (stream->skip(offset - bytesRead) != offset - bytesRead) {
+                SkCodecPrintf("Error: unable to skip to image data.\n");
+                return false;
+            }
+
+            if (codecOut) {
+                // Check that input bit masks are valid and create the masks object
+                SkAutoTDelete<SkMasks> masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
+                if (nullptr == masks) {
+                    SkCodecPrintf("Error: invalid input masks.\n");
                     return false;
                 }
 
+                // Set the image info
+                SkAlphaType alphaType = masks->getAlphaMask() ? kUnpremul_SkAlphaType :
+                        kOpaque_SkAlphaType;
+                const SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType,
+                        alphaType);
                 *codecOut = new SkBmpMaskCodec(imageInfo, stream, bitsPerPixel, masks.release(),
                         rowOrder);
-                return true;
-            case kRLE_BmpInputFormat:
-                // Bmp-in-Ico must be standard mode
-                // When inIco is true, this line cannot be reached, since we
-                // require that RLE Bmps have a valid number of totalBytes, and
-                // Icos skip the header that contains totalBytes.
-                SkASSERT(!inIco);
+            }
+            return true;
+        }
+
+        case kRLE_BmpInputFormat: {
+            // We should not reach this point without a valid value of bitsPerPixel.
+            SkASSERT(4 == bitsPerPixel || 8 == bitsPerPixel || 24 == bitsPerPixel);
+
+            // Check for a valid number of total bytes when in RLE mode
+            if (totalBytes <= offset) {
+                SkCodecPrintf("Error: RLE requires valid input size.\n");
+                return false;
+            }
+            const size_t RLEBytes = totalBytes - offset;
+
+            // Bmp-in-Ico must be standard mode
+            // When inIco is true, this line cannot be reached, since we
+            // require that RLE Bmps have a valid number of totalBytes, and
+            // Icos skip the header that contains totalBytes.
+            SkASSERT(!inIco);
+
+            if (codecOut) {
+                // RLE inputs may skip pixels, leaving them as transparent.  This
+                // is uncommon, but we cannot be certain that an RLE bmp will be
+                // opaque.
+                const SkImageInfo imageInfo = SkImageInfo::Make(width, height, kN32_SkColorType,
+                        kUnpremul_SkAlphaType);
                 *codecOut = new SkBmpRLECodec(imageInfo, stream, bitsPerPixel, numColors,
                         bytesPerColor, offset - bytesRead, rowOrder, RLEBytes);
-                return true;
-            default:
-                SkASSERT(false);
-                return false;
+            }
+            return true;
         }
+        default:
+            SkASSERT(false);
+            return false;
     }
-
-    return true;
 }
 
 /*
  * Creates a bmp decoder
  * Reads enough of the stream to determine the image format
  */
 SkCodec* SkBmpCodec::NewFromStream(SkStream* stream, bool inIco) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     SkCodec* codec = nullptr;
     if (ReadHeader(stream, inIco, &codec)) {
@@ skipping 45 matching lines @@
 }
 
 bool SkBmpCodec::skipRows(int count) {
     const size_t bytesToSkip = count * fSrcRowBytes;
     return this->stream()->skip(bytesToSkip) == bytesToSkip;
 }
 
 bool SkBmpCodec::onSkipScanlines(int count) {
     return this->skipRows(count);
 }