Fix GL readback code to handle rowbytes correctly for non-32bit formats

tests/ReadPixelsTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkMathPriv.h"
@@ skipping 206 matching lines @@
     }
     return true;
 }
 
 enum BitmapInit {
     kFirstBitmapInit = 0,
 
     kNoPixels_BitmapInit = kFirstBitmapInit,
     kTight_BitmapInit,
     kRowBytes_BitmapInit,
+    kRowBytesOdd_BitmapInit,
 
-    kBitmapInitCnt
+    kLastAligned_BitmapInit = kRowBytes_BitmapInit,
+    kLast_BitmapInit = kRowBytesOdd_BitmapInit
 };
 
 static BitmapInit nextBMI(BitmapInit bmi) {
     int x = bmi;
     return static_cast<BitmapInit>(++x);
 }
 
 static void init_bitmap(SkBitmap* bitmap, const SkIRect& rect, BitmapInit init, SkColorType ct,
                         SkAlphaType at) {
     SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), ct, at);
     size_t rowBytes = 0;
     bool alloc = true;
     switch (init) {
         case kNoPixels_BitmapInit:
             alloc = false;
         case kTight_BitmapInit:
             break;
         case kRowBytes_BitmapInit:
             rowBytes = (info.width() + 16) * sizeof(SkPMColor);
             break;
+        case kRowBytesOdd_BitmapInit:
+            rowBytes = (info.width() * sizeof(SkPMColor)) + 3;
+            break;
         default:
             SkASSERT(0);
             break;
     }
 
     if (alloc) {
-        bitmap->allocPixels(info);
+        bitmap->allocPixels(info, rowBytes);
     } else {
         bitmap->setInfo(info, rowBytes);
     }
 }
 
 static const struct {
     SkColorType fColorType;
     SkAlphaType fAlphaType;
 } gReadPixelsConfigs[] = {
     { kRGBA_8888_SkColorType,   kPremul_SkAlphaType },
@@ skipping 41 matching lines @@
     // overlapping bottom left and bottom right corners
     SkIRect::MakeLTRB(-10, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
     // touching entire left edge
     SkIRect::MakeLTRB(0, DEV_H, DEV_W, DEV_H + 10),
     // overlapping bottom right corner
     SkIRect::MakeLTRB(3 * DEV_W / 4, 3 * DEV_H / 4, DEV_W + 10, DEV_H + 10),
     // overlapping top right and bottom right corners
     SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H + 10),
 };
 
-static void test_readpixels(skiatest::Reporter* reporter, SkSurface* surface) {
+static void test_readpixels(skiatest::Reporter* reporter, SkSurface* surface,
+                            BitmapInit lastBitmapInit) {
     SkCanvas* canvas = surface->getCanvas();
     fill_src_canvas(canvas);
     for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
         const SkIRect& srcRect = gReadPixelsTestRects[rect];
-        for (BitmapInit bmi = kFirstBitmapInit; bmi < kBitmapInitCnt; bmi = nextBMI(bmi)) {
+        for (BitmapInit bmi = kFirstBitmapInit; bmi <= lastBitmapInit; bmi = nextBMI(bmi)) {
             for (size_t c = 0; c < SK_ARRAY_COUNT(gReadPixelsConfigs); ++c) {
                 SkBitmap bmp;
                 init_bitmap(&bmp, srcRect, bmi,
                             gReadPixelsConfigs[c].fColorType, gReadPixelsConfigs[c].fAlphaType);
 
                 // if the bitmap has pixels allocated before the readPixels,
                 // note that and fill them with pattern
                 bool startsWithPixels = !bmp.isNull();
                 if (startsWithPixels) {
                     fill_dst_bmp_with_init_data(&bmp);
@@ skipping 32 matching lines @@
                            clippedRect.fTop, true, false);
             } else {
                 REPORTER_ASSERT(reporter, !success);
             }
         }
     }
 }
 DEF_TEST(ReadPixels, reporter) {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
-    test_readpixels(reporter, surface);
+    // SW readback fails a premul check when reading back to an unaligned rowbytes.
+    test_readpixels(reporter, surface, kLastAligned_BitmapInit);
 }
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu, reporter, context) {
     for (auto& origin : {kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin}) {
         GrSurfaceDesc desc;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fWidth = DEV_W;
         desc.fHeight = DEV_H;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fOrigin = origin;
         SkAutoTUnref<GrTexture> surfaceTexture(
             context->textureProvider()->createTexture(desc, false));
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(surfaceTexture->asRenderTarget()));
         desc.fFlags = kNone_GrSurfaceFlags;
-        test_readpixels(reporter, surface);
+        test_readpixels(reporter, surface, kLast_BitmapInit);
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 static void test_readpixels_texture(skiatest::Reporter* reporter, GrTexture* texture) {
     fill_src_texture(texture);
     for (size_t rect = 0; rect < SK_ARRAY_COUNT(gReadPixelsTestRects); ++rect) {
         const SkIRect& srcRect = gReadPixelsTestRects[rect];
-        for (BitmapInit bmi = kFirstBitmapInit; bmi < kBitmapInitCnt; bmi = nextBMI(bmi)) {
+        for (BitmapInit bmi = kFirstBitmapInit; bmi <= kLast_BitmapInit; bmi = nextBMI(bmi)) {
             for (size_t c = 0; c < SK_ARRAY_COUNT(gReadPixelsConfigs); ++c) {
                 SkBitmap bmp;
                 init_bitmap(&bmp, srcRect, bmi,
                             gReadPixelsConfigs[c].fColorType, gReadPixelsConfigs[c].fAlphaType);
 
                 // if the bitmap has pixels allocated before the readPixels,
                 // note that and fill them with pattern
                 bool startsWithPixels = !bmp.isNull();
                 // Try doing the read directly from a non-renderable texture
                 if (startsWithPixels) {
@@ skipping 194 matching lines @@
         SkAutoTUnref<SkData> dataB(draw_into_surface(surfB, tx_subset, quality));
 
         REPORTER_ASSERT(reporter, dataA->equals(dataB));
         if (false) {
             dump_to_file("test_image_A.png", dataA);
             dump_to_file("test_image_B.png", dataB);
         }
     }
 }
 #endif