Make SkAndroidCodec support bmp

src/codec/SkSampledCodec.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.h"
 #include "SkCodecPriv.h"
 #include "SkMath.h"
@@ skipping 208 matching lines @@
                     if (!fCodec->skipScanlines(sampleY - 1)) {
                         fCodec->fillIncompleteImage(info, pixels, rowBytes,
                                 options.fZeroInitialized, dstHeight, y + 1);
                         return SkCodec::kIncompleteInput;
                     }
                 }
                 pixelPtr = SkTAddOffset<void>(pixelPtr, rowBytes);
             }
             return SkCodec::kSuccess;
         }
+        case SkCodec::kBottomUp_SkScanlineOrder: {
+            // Note that this mode does not support subsetting.
+            SkASSERT(0 == subsetY && nativeSize.height() == subsetHeight);
+            SkCodec::Result result = SkCodec::kSuccess;
+            int y;
+            for (y = 0; y < nativeSize.height(); y++) {
+                int srcY = fCodec->nextScanline();
+                if (is_coord_necessary(srcY, sampleY, dstHeight)) {
+                    void* pixelPtr = SkTAddOffset<void>(pixels,
+                            rowBytes * get_dst_coord(srcY, sampleY));
+                    if (1 != fCodec->getScanlines(pixelPtr, 1, rowBytes)) {
+                        result = SkCodec::kIncompleteInput;

[scroggo, 2015/11/17 15:33:17]

This might be 6 of one, half a dozen of the other, but I think the following
might be a little simpler (it at least eliminates a variable):

if (1 != fCodec->getScanlines(...)) {
  break;
}
...
if (!fCodec->skipScanlines(1)) {
  break;
}

if (nativeSize.height() == y) {
  return SkCodec::kSuccess;
}

// fill uninitialized memory
return SkCodec::kIncompleteInput;

[msarett, 2015/11/17 16:06:24]

I think this approach makes things a little clearer.  I've changed this.

+                        break;
+                    }
+                } else {
+                    if (!fCodec->skipScanlines(1)) {
+                        result = SkCodec::kIncompleteInput;
+                        break;
+                    }
+                }
+            }
+
+            // We handle filling uninitialized memory here instead of using fCodec.
+            // fCodec does not know that we are sampling.
+            if (SkCodec::kIncompleteInput == result) {
+                const uint32_t fillValue = fCodec->getFillValue(info.colorType(),
+                        info.alphaType());
+                for (; y < nativeSize.height(); y++) {
+                    int srcY = fCodec->outputScanline(y);
+                    if (is_coord_necessary(srcY, sampleY, dstHeight)) {
+                        void* pixelPtr = SkTAddOffset<void>(pixels,
+                                rowBytes * get_dst_coord(srcY, sampleY));
+                        SkSampler::Fill(info.makeWH(info.width(), 1), pixelPtr, rowBytes, fillValue,
+                                options.fZeroInitialized);
+                    }
+                }
+            }
+            return result;
+        }
         case SkCodec::kNone_SkScanlineOrder: {
             const int linesNeeded = subsetHeight - samplingOffsetY;
             SkAutoMalloc storage(linesNeeded * rowBytes);
             uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
 
             if (!fCodec->skipScanlines(startY)) {
                 fCodec->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                         dstHeight, 0);
                 return SkCodec::kIncompleteInput;
             }
             int scanlines = fCodec->getScanlines(storagePtr, linesNeeded, rowBytes);
 
             for (int y = 0; y < dstHeight; y++) {
                 memcpy(pixels, storagePtr, info.minRowBytes());
                 storagePtr += sampleY * rowBytes;
                 pixels = SkTAddOffset<void>(pixels, rowBytes);
             }
 
             if (scanlines < dstHeight) {
                 // fCodec has already handled filling uninitialized memory.
                 return SkCodec::kIncompleteInput;
             }
             return SkCodec::kSuccess;
         }
         default:
             SkASSERT(false);
             return SkCodec::kUnimplemented;
     }
 }