SkFloatConvert

src/core/SkHalf.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkHalf_DEFINED
 #define SkHalf_DEFINED
 
+#include "SkOpts.h"
 #include "SkNx.h"
 #include "SkTypes.h"
 
 // 16-bit floating point value
 // format is 1 bit sign, 5 bits exponent, 10 bits mantissa
 // only used for storage
 typedef uint16_t SkHalf;
 
 #define SK_HalfMin      0x0400   // 2^-24  (minimum positive normal value)
 #define SK_HalfMax      0x7bff   // 65504
 #define SK_HalfEpsilon  0x1400   // 2^-10
 
 // convert between half and single precision floating point
 float SkHalfToFloat(SkHalf h);
 SkHalf SkFloatToHalf(float f);
 
 // Convert between half and single precision floating point, but pull any dirty
 // trick we can to make it faster as long as it's correct enough for values in [0,1].
 static inline     Sk4f SkHalfToFloat_01(uint64_t);
 static inline uint64_t SkFloatToHalf_01(const Sk4f&);
 
+struct SkFloatConvert {
+    // The compiler can't hoist SkOpts::has_f16c out of loops, so we cache it locally.
+    // TODO: similar has_fp16 for ARMv7
+    const bool has_f16c = SkOpts::has_f16c;
+
+    Sk4f halfToFloat(uint64_t h) const {
+    #if !defined(SKNX_NO_SIMD) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+        if (has_f16c) {
+            __m128 v = _mm_castsi128_ps(_mm_loadl_epi64((const __m128i*)&h));
+            asm("vcvtph2ps %[v], %[v]" : [v] "+x" (v));
+            return v;
+        }
+    #endif
+        return SkHalfToFloat_01(h);
+    }
+
+    uint64_t floatToHalf(const Sk4f& f) const {
+    #if !defined(SKNX_NO_SIMD) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
+        if (has_f16c) {
+            __m128 v = f.fVec;
+            asm("vcvtps2ph $0, %[v], %[v]" : [v] "+x" (v));
+
+            uint64_t h;
+            _mm_storel_epi64((__m128i*)&h, _mm_castps_si128(v));
+            return h;
+        }
+    #endif
+        return SkFloatToHalf_01(f);
+    }
+};
+
 // ~~~~~~~~~~~ impl ~~~~~~~~~~~~~~ //
 
 // Like the serial versions in SkHalf.cpp, these are based on
 // https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
 
 // GCC 4.9 lacks the intrinsics to use ARMv8 f16<->f32 instructions, so we use inline assembly.
 
 static inline Sk4f SkHalfToFloat_01(uint64_t hs) {
 #if !defined(SKNX_NO_SIMD) && defined(SK_CPU_ARM64)
     float32x4_t fs;
@@ skipping 73 matching lines @@
     }
     r = (uint64_t)hs[3] << 48
       | (uint64_t)hs[2] << 32
       | (uint64_t)hs[1] << 16
       | (uint64_t)hs[0] <<  0;
 #endif
     return r;
 }
 
 #endif