Add mipmap procs for F16 format.

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"
+#include "SkHalf.h"
 #include "SkMath.h"
 #include "SkNx.h"
 #include "SkTypes.h"
 
 //
 // ColorTypeFilter is the "Type" we pass to some downsample template functions.
 // It controls how we expand a pixel into a large type, with space between each component,
 // so we can then perform our simple filter (either box or triangle) and store the intermediates
 // in the expanded type.
 //
@@ skipping 42 matching lines @@
 struct ColorTypeFilter_8 {
     typedef uint8_t Type;
     static unsigned Expand(unsigned x) {
         return x;
     }
     static uint8_t Compact(unsigned x) {
         return (uint8_t)x;
     }
 };
 
+struct ColorTypeFilter_F16 {
+    typedef uint64_t Type; // SkHalf x4
+    static Sk4f Expand(uint64_t x) {
+        return SkHalfToFloat_01(x);
+    }
+    static uint64_t Compact(const Sk4f& x) {
+        return SkFloatToHalf_01(x);
+    }
+};
+
 template <typename T> T add_121(const T& a, const T& b, const T& c) {
     return a + b + b + c;
 }
 
+template <typename T> T shift_right(const T& x, int bits) {
+    return x >> bits;
+}
+
+Sk4f shift_right(const Sk4f& x, int bits) {
+    return x * (1.0f / (1 << bits));
+}
+
+template <typename T> T shift_left(const T& x, int bits) {
+    return x << bits;
+}
+
+Sk4f shift_left(const Sk4f& x, int bits) {
+    return x * (1 << bits);
+}
+
 //
 //  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 isotropic 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.
 //
 //  OpenGL expects a full mipmap stack to contain anisotropic space as well.
 //  This means a 100x1 image would continue down to a 50x1 image, 25x1 image...
 //  Because of this, we need 4 more anisotropic filters: 1x2, 1x3, 2x1, 3x1.
 
 template <typename F> void downsample_1_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);
 
     for (int i = 0; i < count; ++i) {
         auto c00 = F::Expand(p0[0]);
         auto c10 = F::Expand(p1[0]);
 
         auto c = c00 + c10;
-        d[i] = F::Compact(c >> 1);
+        d[i] = F::Compact(shift_right(c, 1));
         p0 += 2;
         p1 += 2;
     }
 }
 
 template <typename F> void downsample_1_3(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 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 c10 = F::Expand(p1[0]);
         auto c20 = F::Expand(p2[0]);
 
         auto c = add_121(c00, c10, c20);
-        d[i] = F::Compact(c >> 2);
+        d[i] = F::Compact(shift_right(c, 2));
         p0 += 2;
         p1 += 2;
         p2 += 2;
     }
 }
 
 template <typename F> void downsample_2_1(void* dst, const void* src, size_t srcRB, int count) {
     SkASSERT(count > 0);
     auto p0 = static_cast<const typename F::Type*>(src);
     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 c = c00 + c01;
-        d[i] = F::Compact(c >> 1);
+        d[i] = F::Compact(shift_right(c, 1));
         p0 += 2;
     }
 }
 
 template <typename F> void downsample_2_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);
 
     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);
+        d[i] = F::Compact(shift_right(c, 2));
         p0 += 2;
         p1 += 2;
     }
 }
 
 template <typename F> void downsample_2_3(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 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);
-        d[i] = F::Compact(c >> 3);
+        d[i] = F::Compact(shift_right(c, 3));
         p0 += 2;
         p1 += 2;
         p2 += 2;
     }
 }
 
 template <typename F> void downsample_3_1(void* dst, const void* src, size_t srcRB, int count) {
     SkASSERT(count > 0);
     auto p0 = static_cast<const typename F::Type*>(src);
     auto d = static_cast<typename F::Type*>(dst);
 
     auto c02 = F::Expand(p0[0]);
     for (int i = 0; i < count; ++i) {
         auto c00 = c02;
         auto c01 = F::Expand(p0[1]);
              c02 = F::Expand(p0[2]);
 
         auto c = add_121(c00, c01, c02);
-        d[i] = F::Compact(c >> 2);
+        d[i] = F::Compact(shift_right(c, 2));
         p0 += 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 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);
+        d[i] = F::Compact(shift_right(c, 3));
         p0 += 2;
         p1 += 2;
     }
 }
 
 template <typename F> void downsample_3_3(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 p2 = (const typename F::Type*)((const char*)p1 + srcRB);
     auto d = static_cast<typename F::Type*>(dst);
 
     auto c02 = F::Expand(p0[0]);
     auto c12 = F::Expand(p1[0]);
     auto c22 = F::Expand(p2[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 c20 = c22;
         auto c21 = F::Expand(p2[1]);
              c22 = F::Expand(p2[2]);
 
-        auto c = add_121(c00, c01, c02) + (add_121(c10, c11, c12) << 1) + add_121(c20, c21, c22);
-        d[i] = F::Compact(c >> 4);
+        auto c =
+            add_121(c00, c01, c02) +
+            shift_left(add_121(c10, c11, c12), 1) +
+            add_121(c20, c21, c22);
+        d[i] = F::Compact(shift_right(c, 4));
         p0 += 2;
         p1 += 2;
         p2 += 2;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 size_t SkMipMap::AllocLevelsSize(int levelCount, size_t pixelSize) {
     if (levelCount < 0) {
@@ skipping 56 matching lines @@
         case kGray_8_SkColorType:
             proc_1_2 = downsample_1_2<ColorTypeFilter_8>;
             proc_1_3 = downsample_1_3<ColorTypeFilter_8>;
             proc_2_1 = downsample_2_1<ColorTypeFilter_8>;
             proc_2_2 = downsample_2_2<ColorTypeFilter_8>;
             proc_2_3 = downsample_2_3<ColorTypeFilter_8>;
             proc_3_1 = downsample_3_1<ColorTypeFilter_8>;
             proc_3_2 = downsample_3_2<ColorTypeFilter_8>;
             proc_3_3 = downsample_3_3<ColorTypeFilter_8>;
             break;
+        case kRGBA_F16_SkColorType:
+            proc_1_2 = downsample_1_2<ColorTypeFilter_F16>;
+            proc_1_3 = downsample_1_3<ColorTypeFilter_F16>;
+            proc_2_1 = downsample_2_1<ColorTypeFilter_F16>;
+            proc_2_2 = downsample_2_2<ColorTypeFilter_F16>;
+            proc_2_3 = downsample_2_3<ColorTypeFilter_F16>;
+            proc_3_1 = downsample_3_1<ColorTypeFilter_F16>;
+            proc_3_2 = downsample_3_2<ColorTypeFilter_F16>;
+            proc_3_3 = downsample_3_3<ColorTypeFilter_F16>;
+            break;
         default:
             // TODO: We could build miplevels for kIndex8 if the levels were in 8888.
             //       Means using more ram, but the quality would be fine.
             return nullptr;
     }
 
     if (src.width() <= 1 && src.height() <= 1) {
         return nullptr;
     }
     // whip through our loop to compute the exact size needed
@@ skipping 207 matching lines @@
         return false;
     }
     if (index > fCount - 1) {
         return false;
     }
     if (levelPtr) {
         *levelPtr = fLevels[index];
     }
     return true;
 }