Handle rewinds in SkBmpCodec.

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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 87 matching lines @@
  * Creates a bmp decoder for a bmp embedded in ico
  * Reads enough of the stream to determine the image format
  *
  */
 SkCodec* SkBmpCodec::NewFromIco(SkStream* stream) {
     return SkBmpCodec::NewFromStream(stream, true);
 }
 
 /*
  *
- * Creates a bmp decoder
- * Reads enough of the stream to determine the image format
+ * Read enough of the stream to initialize the SkBmpCodec. Returns a bool
+ * representing success or failure. If it returned true, and codecOut was
+ * not NULL, it will be set to a new SkBmpCodec.
  *
  */
-SkCodec* SkBmpCodec::NewFromStream(SkStream* stream, bool isIco) {
+bool SkBmpCodec::ReadHeader(SkStream* stream, bool isIco, SkCodec** codecOut) {
     // 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;
@@ skipping 10 matching lines @@
     uint32_t infoBytes;
 
     // Bmps embedded in Icos skip the first Bmp header
     if (!isIco) {
         // 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) {
             SkCodecPrintf("Error: unable to read first bitmap header.\n");
-            return NULL;
+            return false;
         }
 
         totalBytes = get_int(hBuffer.get(), 2);
         offset = get_int(hBuffer.get(), 10);
         if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) {
             SkCodecPrintf("Error: invalid starting location for pixel data\n");
-            return NULL;
+            return false;
         }
 
         // 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.
         infoBytes = get_int(hBuffer.get(), 14);
         if (infoBytes < kBmpOS2V1Bytes) {
             SkCodecPrintf("Error: invalid second header size.\n");
-            return NULL;
+            return false;
         }
     } else {
         // This value is only used by RLE compression.  Bmp in Ico files do not
         // use RLE.  If the compression field is incorrectly signaled as RLE,
         // we will catch this and signal an error below.
         totalBytes = 0;
 
         // Bmps in Ico cannot specify an offset.  We will always assume that
         // pixel data begins immediately after the color table.  This value
         // will be corrected below.
         offset = 0;
 
         // Read the size of the second header
         SkAutoTDeleteArray<uint8_t> hBuffer(
                 SkNEW_ARRAY(uint8_t, 4));
         if (stream->read(hBuffer.get(), 4) != 4) {
             SkCodecPrintf("Error: unable to read size of second bitmap header.\n");
-            return NULL;
+            return false;
         }
         infoBytes = get_int(hBuffer.get(), 0);
         if (infoBytes < kBmpOS2V1Bytes) {
             SkCodecPrintf("Error: invalid second header size.\n");
-            return NULL;
+            return false;
         }
     }
 
     // We already read the first four bytes of the info header to get the size
     const uint32_t infoBytesRemaining = infoBytes - 4;
 
     // Read the second header
     SkAutoTDeleteArray<uint8_t> iBuffer(
             SkNEW_ARRAY(uint8_t, infoBytesRemaining));
     if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) {
         SkCodecPrintf("Error: unable to read second bitmap header.\n");
-        return NULL;
+        return false;
     }
 
     // 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;
@@ skipping 70 matching lines @@
     } 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
         SkCodecPrintf("Error: second bitmap header size is invalid.\n");
-        return NULL;
+        return false;
     }
 
     // Check for valid dimensions from header
     RowOrder rowOrder = kBottomUp_RowOrder;
     if (height < 0) {
         height = -height;
         rowOrder = kTopDown_RowOrder;
     }
     // The height field for bmp in ico is double the actual height because they
     // contain an XOR mask followed by an AND mask
     if (isIco) {
         height /= 2;
     }
     static const int kBmpMaxDim = 1 << 16;
     if (width < 0 || width >= kBmpMaxDim || height >= kBmpMaxDim) {
         // TODO: Decide if we want to support really large bmps.
         SkCodecPrintf("Error: invalid bitmap dimensions.\n");
-        return NULL;
+        return false;
     }
 
     // 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;
     BitmapInputFormat inputFormat = kUnknown_BitmapInputFormat;
     switch (compression) {
@@ skipping 19 matching lines @@
             // 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) {
                         SkCodecPrintf("Error: unable to read bit inputMasks.\n");
-                        return NULL;
+                        return false;
                     }
                     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.
                     SkCodecPrintf("Error: huffman format unsupported.\n");
-                    return NULL;
+                    return false;
                 default:
                    SkCodecPrintf("Error: invalid bmp bit masks header.\n");
-                   return NULL;
+                   return false;
             }
             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.
             SkCodecPrintf("Error: compression format not supported.\n");
-            return NULL;
+            return false;
         case kCMYK_BitmapCompressionMethod:
         case kCMYK8BitRLE_BitmapCompressionMethod:
         case kCMYK4BitRLE_BitmapCompressionMethod:
             // TODO: Same as above.
             SkCodecPrintf("Error: CMYK not supported for bitmap decoding.\n");
-            return NULL;
+            return false;
         default:
             SkCodecPrintf("Error: invalid format for bitmap decoding.\n");
-            return NULL;
+            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+, we will use the alpha channel, and fix the image later if it turns
     // out to be fully transparent.
@@ skipping 34 matching lines @@
             break;
         case 1:
         case 2:
         case 4:
         case 8:
         case 24:
         case 32:
             break;
         default:
             SkCodecPrintf("Error: invalid input value for bits per pixel.\n");
-            return NULL;
+            return false;
     }
 
     // Check that input bit masks are valid and create the masks object
     SkAutoTDelete<SkMasks>
             masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
     if (NULL == masks) {
         SkCodecPrintf("Error: invalid input masks.\n");
-        return NULL;
+        return false;
     }
 
     // Check for a valid number of total bytes when in RLE mode
     if (totalBytes <= offset && kRLE_BitmapInputFormat == inputFormat) {
         SkCodecPrintf("Error: RLE requires valid input size.\n");
-        return NULL;
+        return false;
     }
     const size_t RLEBytes = totalBytes - offset;
 
     // Calculate the number of bytes read so far
     const uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes;
     if (!isIco && offset < bytesRead) {
         SkCodecPrintf("Error: pixel data offset less than header size.\n");
-        return NULL;
+        return false;
     }
 
-    // Return the codec
-    // We will use ImageInfo to store width, height, and alpha type.  We will
-    // set color type to kN32_SkColorType because that should be the default
-    // output.
-    const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
-            kN32_SkColorType, alphaType);
-    return SkNEW_ARGS(SkBmpCodec, (imageInfo, stream, bitsPerPixel,
-                                   inputFormat, masks.detach(), numColors,
-                                   bytesPerColor, offset - bytesRead,
-                                   rowOrder, RLEBytes, isIco));
+    if (codecOut) {
+        // Return the codec
+        // We will use ImageInfo to store width, height, and alpha type. We
+        // will set color type to kN32_SkColorType because that should be the
+        // default output.
+        const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
+                kN32_SkColorType, alphaType);
+        *codecOut = SkNEW_ARGS(SkBmpCodec, (imageInfo, stream, bitsPerPixel,
+                                            inputFormat, masks.detach(),
+                                            numColors, bytesPerColor,
+                                            offset - bytesRead, rowOrder,
+                                            RLEBytes, isIco));
+    }
+    return true;
 }
 
 /*
+ *
+ * Creates a bmp decoder
+ * Reads enough of the stream to determine the image format
+ *
+ */
+SkCodec* SkBmpCodec::NewFromStream(SkStream* stream, bool isIco) {
+    SkCodec* codec = NULL;
+    if (ReadHeader(stream, isIco, &codec)) {
+        return codec;
+    }
+    return NULL;
+}
+
+/*
  *
  * Creates an instance of the decoder
  * Called only by NewFromStream
  *
  */
 SkBmpCodec::SkBmpCodec(const SkImageInfo& info, SkStream* stream,
                        uint16_t bitsPerPixel, BitmapInputFormat inputFormat,
                        SkMasks* masks, uint32_t numColors,
                        uint32_t bytesPerColor, uint32_t offset,
                        RowOrder rowOrder, size_t RLEBytes, bool isIco)
@@ skipping 18 matching lines @@
  */
 SkCodec::Result SkBmpCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options&,
                                         SkPMColor*, int*) {
     // Check for proper input and output formats
     SkCodec::RewindState rewindState = this->rewindIfNeeded();
     if (rewindState == kCouldNotRewind_RewindState) {
         return kCouldNotRewind;
     } else if (rewindState == kRewound_RewindState) {
-        return kCouldNotRewind;  // TODO(msarett):  handle rewinds
+        if (!ReadHeader(this->stream(), fIsIco, NULL)) {
+            return kCouldNotRewind;
+        }
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         SkCodecPrintf("Error: scaling not supported.\n");
         return kInvalidScale;
     }
     if (!conversion_possible(dstInfo, this->getInfo())) {
         SkCodecPrintf("Error: cannot convert input type to output type.\n");
         return kInvalidConversion;
     }
 
@@ skipping 568 matching lines @@
                 uint32_t alphaBit =
                         (srcBuffer.get()[quotient] >> shift) & 0x1;
                 dstRow[x] &= alphaBit - 1;
             }
         }
     }
 
     // Finished decoding the entire image
     return kSuccess;
 }