Interlaced gifs without the iterator

src/codec/SkCodec_libgif.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_libgif.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
-#include "SkGifInterlaceIter.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 #include "SkUtils.h"
 
 /*
  * Checks the start of the stream to see if the image is a gif
  */
 bool SkGifCodec::IsGif(SkStream* stream) {
     char buf[GIF_STAMP_LEN];
     if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) {
@@ skipping 86 matching lines @@
             // There should only be one graphics control extension for the image frame
             break;
         }
     }
 
     // Use maximum unsigned int (surely an invalid index) to indicate that a valid
     // index was not found.
     return SK_MaxU32;
 }
 
+static inline uint32_t ceil_div(uint32_t a, uint32_t b) {
+    return (a + b - 1) / b;
+}
+
+/*
+ * Gets the output row corresponding to the encoded row for interlaced gifs
+ */
+static uint32_t get_output_row_interlaced(uint32_t encodedRow, uint32_t height) {
+    SkASSERT(encodedRow < height);
+    // First pass
+    if (encodedRow * 8 < height) {
+        return encodedRow * 8;
+    }
+    // Second pass
+    if (encodedRow * 4 < height) {
+        return 4 + 8 * (encodedRow - ceil_div(height, 8));
+    }
+    // Third pass
+    if (encodedRow * 2 < height) {
+        return 2 + 4 * (encodedRow - ceil_div(height, 4));
+    }
+    // Fourth pass
+    return 1 + 2 * (encodedRow - ceil_div(height, 2));
+}
+
 /*
  * Read enough of the stream to initialize the SkGifCodec.
  * Returns a bool representing success or failure.
  *
  * @param codecOut
  * If it returned true, and codecOut was not nullptr,
  * codecOut will be set to a new SkGifCodec.
  *
  * @param gifOut
  * If it returned true, and codecOut was nullptr,
@@ skipping 273 matching lines @@
                     swizzler.reset(SkSwizzler::CreateSwizzler(
                             SkSwizzler::kIndex, colorTable, dstInfo, 
                             zeroInit, this->getInfo()));
                 }
 
                 // Stores output from dgiflib and input to the swizzler
                 SkAutoTDeleteArray<uint8_t> buffer(new uint8_t[innerWidth]);
 
                 // Check the interlace flag and iterate over rows of the input
                 if (fGif->Image.Interlace) {
-                    // In interlace mode, the rows of input are rearranged in
-                    // the output image.  We use an iterator to take care of
-                    // the rearranging.
-                    SkGifInterlaceIter iter(innerHeight);
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(), innerWidth)) {
                             // Recover from error by filling remainder of image
                             if (!skipBackground) {
                                 memset(buffer.get(), fillIndex, innerWidth);
                                 for (; y < innerHeight; y++) {
-                                    void* dstRow = SkTAddOffset<void>(dst,
-                                                                      dstRowBytes * iter.nextY());
+                                    void* dstRow = SkTAddOffset<void>(dst, dstRowBytes *
+                                            get_output_row_interlaced(y, innerHeight));
                                     swizzler->swizzle(dstRow, buffer.get());
                                 }
                             }
                             return gif_error(SkStringPrintf(
                                     "Could not decode line %d of %d.\n",
                                     y, height - 1).c_str(), kIncompleteInput);
                         }
-                        void* dstRow = SkTAddOffset<void>(dst, dstRowBytes * iter.nextY());
+                        void* dstRow = SkTAddOffset<void>(dst,
+                                dstRowBytes * get_output_row_interlaced(y, innerHeight));
                         swizzler->swizzle(dstRow, buffer.get());
                     }
                 } else {
                     // Standard mode
                     void* dstRow = dst;
                     for (int32_t y = 0; y < innerHeight; y++) {
                         if (GIF_ERROR == DGifGetLine(fGif, buffer.get(), innerWidth)) {
                             if (!skipBackground) {
                                 SkSwizzler::Fill(dstRow, dstInfo, dstRowBytes,
                                                  innerHeight - y, fillIndex, colorTable);
@@ skipping 62 matching lines @@
             default:
                 // giflib returns an error code if the record type is not known.
                 // We should catch this error immediately.
                 SkASSERT(false);
                 break;
         }
     } while (TERMINATE_RECORD_TYPE != recordType);
 
     return gif_error("Could not find any images to decode in gif file.\n", kInvalidInput);
 }