speedup mip builders

src/core/SkMipMap.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMipMap.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 365 matching lines @@
 //
 //  To produce each mip level, we need to filter down by 1/2 (e.g. 100x100 -> 50,50)
 //  If the starting dimension is odd, we floor the size of the lower level (e.g. 101 -> 50)
 //  In those (odd) cases, we use a triangle filter, with 1-pixel overlap between samplings,
 //  else for even cases, we just use a 2x box filter.
 //
 //  This produces 4 possible filters: 2x2 2x3 3x2 3x3 where WxH indicates the number of src pixels
 //  we need to sample in each dimension to produce 1 dst pixel.
 //
 
-template <typename F> void downsample_2_2(void* dst, const void* src, size_t srcRB) {
+template <typename F> void downsample_2_2(void* dst, const void* src, size_t srcRB, int count) {
     auto p0 = static_cast<const typename F::Type*>(src);
     auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
+    auto d = static_cast<typename F::Type*>(dst);
+
+    for (int i = 0; i < count; ++i) {
+        auto c00 = F::Expand(p0[0]);
+        auto c01 = F::Expand(p0[1]);
+        auto c10 = F::Expand(p1[0]);
+        auto c11 = F::Expand(p1[1]);
+        auto c = c00 + c10 + c01 + c11;
+
+        d[i] = F::Compact(c >> 2);
+        p0 += 2;
+        p1 += 2;
+    }
+}
+
+template <typename F> void downsample_3_2(void* dst, const void* src, size_t srcRB, int count) {
+    SkASSERT(count > 0);
+    auto p0 = static_cast<const typename F::Type*>(src);
+    auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
+    auto d = static_cast<typename F::Type*>(dst);
 
     auto c00 = F::Expand(p0[0]);
     auto c01 = F::Expand(p0[1]);
-    auto c10 = F::Expand(p1[0]);
-    auto c11 = F::Expand(p1[1]);
-
-    auto c = c00 + c10 + c01 + c11;
-    *(typename F::Type*)dst = F::Compact(c >> 2);
-}
-
-template <typename F> void downsample_3_2(void* dst, const void* src, size_t srcRB) {
-    auto p0 = static_cast<const typename F::Type*>(src);
-    auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
-
-    auto c00 = F::Expand(p0[0]);
-    auto c01 = F::Expand(p0[1]);
     auto c02 = F::Expand(p0[2]);
     auto c10 = F::Expand(p1[0]);
     auto c11 = F::Expand(p1[1]);
     auto c12 = F::Expand(p1[2]);
+    auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12);
+    d[0] = F::Compact(c >> 3);
 
-    auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12);
-    *(typename F::Type*)dst = F::Compact(c >> 3);
+    for (int i = 1; i < count; ++i) {
+        p0 += 2;
+        p1 += 2;
+        c00 = c02;
+        c01 = F::Expand(p0[1]);
+        c02 = F::Expand(p0[2]);
+        c10 = c12;
+        c11 = F::Expand(p1[1]);
+        c12 = F::Expand(p1[2]);
+        auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12);
+        d[i] = F::Compact(c >> 3);
+    }

[f(malita), 2016/01/16 16:46:10]

Instead of unrolling a full iteration, could we set up just the relevant values
and then fall through a regular 0-based loop?

auto c02 = F::Expand(p0[0]);
auto c12 = F::Expand(p1[0]);

for (int i = 0; i < count; ++i) {
  auto c00 = c02;
  auto c01 = F::Expand(p0[1]);
  c02 = F::Expand(p0[2]);

  auto c10 = c12;
  auto c11 = F::Expand(p1[1]);
  c12 = F::Expand(p1[2]);

  auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12);
  d[i] = F::Compact(c >> 3);

  p0 += 2;
  p1 += 2;
}

[reed1, 2016/01/16 17:03:10]

Good catch! Thanks.

 }
 
-template <typename F> void downsample_2_3(void* dst, const void* src, size_t srcRB) {
+template <typename F> void downsample_2_3(void* dst, const void* src, size_t srcRB, int count) {
     auto p0 = static_cast<const typename F::Type*>(src);
     auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
     auto p2 = (const typename F::Type*)((const char*)p1 + srcRB);
+    auto d = static_cast<typename F::Type*>(dst);
+    
+    for (int i = 0; i < count; ++i) {
+        auto c00 = F::Expand(p0[0]);
+        auto c01 = F::Expand(p0[1]);
+        auto c10 = F::Expand(p1[0]);
+        auto c11 = F::Expand(p1[1]);
+        auto c20 = F::Expand(p2[0]);
+        auto c21 = F::Expand(p2[1]);
+        auto c = add_121(c00, c10, c20) + add_121(c01, c11, c21);
 
-    auto c00 = F::Expand(p0[0]);
-    auto c01 = F::Expand(p0[1]);
-    auto c10 = F::Expand(p1[0]);
-    auto c11 = F::Expand(p1[1]);
-    auto c20 = F::Expand(p2[0]);
-    auto c21 = F::Expand(p2[1]);
-    auto c = add_121(c00, c10, c20) + add_121(c01, c11, c21);
-    *(typename F::Type*)dst = F::Compact(c >> 3);
+        d[i] = F::Compact(c >> 3);
+        p0 += 2;
+        p1 += 2;
+        p2 += 2;
+    }
 }
 
-template <typename F> void downsample_3_3(void* dst, const void* src, size_t srcRB) {
+template <typename F> void downsample_3_3(void* dst, const void* src, size_t srcRB, int count) {
     auto p0 = static_cast<const typename F::Type*>(src);
     auto p1 = (const typename F::Type*)((const char*)p0 + srcRB);
     auto p2 = (const typename F::Type*)((const char*)p1 + srcRB);
-
+    auto d = static_cast<typename F::Type*>(dst);
+    
     auto c00 = F::Expand(p0[0]);
     auto c01 = F::Expand(p0[1]);
     auto c02 = F::Expand(p0[2]);
     auto c10 = F::Expand(p1[0]);
     auto c11 = F::Expand(p1[1]);
     auto c12 = F::Expand(p1[2]);
     auto c20 = F::Expand(p2[0]);
     auto c21 = F::Expand(p2[1]);
     auto c22 = F::Expand(p2[2]);
+    auto c = add_121(c00, c01, c02) + (add_121(c10, c11, c12) << 1) + add_121(c20, c21, c22);
+    d[0] = F::Compact(c >> 4);
 
-    auto c = add_121(c00, c01, c02) + (add_121(c10, c11, c12) << 1) + add_121(c20, c21, c22);
-    *(typename F::Type*)dst = F::Compact(c >> 4);
+    for (int i = 1; i < count; ++i) {
+        c00 = c02;
+        c01 = F::Expand(p0[1]);
+        c02 = F::Expand(p0[2]);
+        c10 = c12;
+        c11 = F::Expand(p1[1]);
+        c12 = F::Expand(p1[2]);
+        c20 = c22;
+        c21 = F::Expand(p2[1]);
+        c22 = F::Expand(p2[2]);
+        c = add_121(c00, c01, c02) + (add_121(c10, c11, c12) << 1) + add_121(c20, c21, c22);
+
+        d[i] = F::Compact(c >> 4);
+        p0 += 2;
+        p1 += 2;
+        p2 += 2;
+    }

[f(malita), 2016/01/16 16:46:10]

Ditto.

[reed1, 2016/01/16 17:03:10]

Done.

 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 size_t SkMipMap::AllocLevelsSize(int levelCount, size_t pixelSize) {
     if (levelCount < 0) {
         return 0;
     }
     int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
     if (!sk_64_isS32(size)) {
         return 0;
     }
     return sk_64_asS32(size);
 }
 
 SkMipMap* SkMipMap::Build(const SkBitmap& src, SkDiscardableFactoryProc fact) {
-    typedef void FilterProc(void*, const void* srcPtr, size_t srcRB);
+    typedef void FilterProc(void*, const void* srcPtr, size_t srcRB, int count);
 
     FilterProc* proc_2_2 = nullptr;
     FilterProc* proc_2_3 = nullptr;
     FilterProc* proc_3_2 = nullptr;
     FilterProc* proc_3_3 = nullptr;
 
     const SkColorType ct = src.colorType();
     const SkAlphaType at = src.alphaType();
     switch (ct) {
         case kRGBA_8888_SkColorType:
@@ skipping 94 matching lines @@
         rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
 
         levels[i].fPixels   = addr;
         levels[i].fWidth    = width;
         levels[i].fHeight   = height;
         levels[i].fRowBytes = rowBytes;
         levels[i].fScale    = (float)width / src.width();
 
         SkPixmap dstPM(SkImageInfo::Make(width, height, ct, at), addr, rowBytes);
 
-        const size_t pixelSize = srcPM.info().bytesPerPixel();
-
         const void* srcBasePtr = srcPM.addr();
         void* dstBasePtr = dstPM.writable_addr();
 
         FilterProc* proc;
         if (prevH & 1) {        // src-height is 3
             if (prevW & 1) {    // src-width is 3
                 proc = proc_3_3;
             } else {            // src-width is 2
                 proc = proc_2_3;
             }
         } else {                // src-height is 2
             if (prevW & 1) {    // src-width is 3
                 proc = proc_3_2;
             } else {            // src-width is 2
                 proc = proc_2_2;
             }
         }
 
         const size_t srcRB = srcPM.rowBytes();
         for (int y = 0; y < height; y++) {
-            const void* srcPtr = srcBasePtr;
-            void* dstPtr = dstBasePtr;
-
-            for (int x = 0; x < width; x++) {
-                proc(dstPtr, srcPtr, srcRB);
-                srcPtr = (char*)srcPtr + pixelSize * 2;
-                dstPtr = (char*)dstPtr + pixelSize;
-            }
-
+            proc(dstBasePtr, srcBasePtr, srcRB, width);
             srcBasePtr = (char*)srcBasePtr + srcRB * 2; // jump two rows
             dstBasePtr = (char*)dstBasePtr + dstPM.rowBytes();
         }
         srcPM = dstPM;
         addr += height * rowBytes;
         prevW = width;
         prevH = height;
     }
     SkASSERT(addr == baseAddr + size);
 
@@ skipping 27 matching lines @@
     }
 
     if (level > fCount) {
         level = fCount;
     }
     if (levelPtr) {
         *levelPtr = fLevels[level - 1];
     }
     return true;
 }