Roll skia/third_party/skcms 23e7777f421d..51fba282d9a0 (1 commits)
https://skia.googlesource.com/skcms.git/+log/23e7777f421d..51fba282d9a0
2018-07-30 mtklein@google.com start cleaning up src/Transform_inl.h with C++
The AutoRoll server is located here: https://skcms-skia-roll.skia.org
Documentation for the AutoRoller is here:
https://skia.googlesource.com/buildbot/+/master/autoroll/README.md
If the roll is causing failures, please contact the current sheriff, who should
be CC'd on the roll, and stop the roller if necessary.
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel
TBR=scroggo@google.com
Change-Id: I3005cfe39088dae5564a8ddd9fffd6eefd122065
Reviewed-on: https://skia-review.googlesource.com/144296
Reviewed-by: skcms-skia-autoroll <skcms-skia-autoroll@skia-buildbots.google.com.iam.gserviceaccount.com>
Commit-Queue: skcms-skia-autoroll <skcms-skia-autoroll@skia-buildbots.google.com.iam.gserviceaccount.com>
diff --git a/third_party/skcms/skcms.cc b/third_party/skcms/skcms.cc
index 0a82062..3595088 100644
--- a/third_party/skcms/skcms.cc
+++ b/third_party/skcms/skcms.cc
@@ -13,6 +13,12 @@
#include <stdlib.h>
#include <string.h>
+#if defined(__ARM_NEON)
+ #include <arm_neon.h>
+#elif defined(__SSE__)
+ #include <immintrin.h>
+#endif
+
// sizeof(x) will return size_t, which is 32-bit on some machines and 64-bit on others.
// We have better testing on 64-bit machines, so force 32-bit machines to behave like 64-bit.
//
@@ -1806,174 +1812,108 @@
#endif
#if defined(__clang__)
- typedef float __attribute__((ext_vector_type(4))) Fx4;
- typedef int32_t __attribute__((ext_vector_type(4))) I32x4;
- typedef uint64_t __attribute__((ext_vector_type(4))) U64x4;
- typedef uint32_t __attribute__((ext_vector_type(4))) U32x4;
- typedef uint16_t __attribute__((ext_vector_type(4))) U16x4;
- typedef uint8_t __attribute__((ext_vector_type(4))) U8x4;
-
- typedef float __attribute__((ext_vector_type(8))) Fx8;
- typedef int32_t __attribute__((ext_vector_type(8))) I32x8;
- typedef uint64_t __attribute__((ext_vector_type(8))) U64x8;
- typedef uint32_t __attribute__((ext_vector_type(8))) U32x8;
- typedef uint16_t __attribute__((ext_vector_type(8))) U16x8;
- typedef uint8_t __attribute__((ext_vector_type(8))) U8x8;
-
- typedef float __attribute__((ext_vector_type(16))) Fx16;
- typedef int32_t __attribute__((ext_vector_type(16))) I32x16;
- typedef uint64_t __attribute__((ext_vector_type(16))) U64x16;
- typedef uint32_t __attribute__((ext_vector_type(16))) U32x16;
- typedef uint16_t __attribute__((ext_vector_type(16))) U16x16;
- typedef uint8_t __attribute__((ext_vector_type(16))) U8x16;
+ template <int N, typename T> using Vec = T __attribute__((ext_vector_type(N)));
#elif defined(__GNUC__)
- typedef float __attribute__((vector_size(16))) Fx4;
- typedef int32_t __attribute__((vector_size(16))) I32x4;
- typedef uint64_t __attribute__((vector_size(32))) U64x4;
- typedef uint32_t __attribute__((vector_size(16))) U32x4;
- typedef uint16_t __attribute__((vector_size( 8))) U16x4;
- typedef uint8_t __attribute__((vector_size( 4))) U8x4;
+ // For some reason GCC accepts this nonsense, but not the more straightforward version,
+ // template <int N, typename T> using Vec = T __attribute__((vector_size(N*sizeof(T))));
+ template <int N, typename T>
+ struct VecHelper { typedef T __attribute__((vector_size(N*sizeof(T)))) V; };
- typedef float __attribute__((vector_size(32))) Fx8;
- typedef int32_t __attribute__((vector_size(32))) I32x8;
- typedef uint64_t __attribute__((vector_size(64))) U64x8;
- typedef uint32_t __attribute__((vector_size(32))) U32x8;
- typedef uint16_t __attribute__((vector_size(16))) U16x8;
- typedef uint8_t __attribute__((vector_size( 8))) U8x8;
-
- typedef float __attribute__((vector_size( 64))) Fx16;
- typedef int32_t __attribute__((vector_size( 64))) I32x16;
- typedef uint64_t __attribute__((vector_size(128))) U64x16;
- typedef uint32_t __attribute__((vector_size( 64))) U32x16;
- typedef uint16_t __attribute__((vector_size( 32))) U16x16;
- typedef uint8_t __attribute__((vector_size( 16))) U8x16;
+ template <int N, typename T> using Vec = typename VecHelper<N,T>::V;
#endif
// First, instantiate our default exec_ops() implementation using the default compiliation target.
+namespace baseline {
#if defined(SKCMS_PORTABLE) || !(defined(__clang__) || defined(__GNUC__))
#define N 1
-
- #define F float
- #define U64 uint64_t
- #define U32 uint32_t
- #define I32 int32_t
- #define U16 uint16_t
- #define U8 uint8_t
-
- #define F0 0.0f
- #define F1 1.0f
+ using F = float;
+ using U64 = uint64_t;
+ using U32 = uint32_t;
+ using I32 = int32_t;
+ using U16 = uint16_t;
+ using U8 = uint8_t;
#elif defined(__AVX512F__)
#define N 16
-
- #define F Fx16
- #define U64 U64x16
- #define U32 U32x16
- #define I32 I32x16
- #define U16 U16x16
- #define U8 U8x16
-
- #define F0 F{0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0}
- #define F1 F{1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1}
+ using F = Vec<N,float>;
+ using I32 = Vec<N,int32_t>;
+ using U64 = Vec<N,uint64_t>;
+ using U32 = Vec<N,uint32_t>;
+ using U16 = Vec<N,uint16_t>;
+ using U8 = Vec<N,uint8_t>;
#elif defined(__AVX__)
#define N 8
-
- #define F Fx8
- #define U64 U64x8
- #define U32 U32x8
- #define I32 I32x8
- #define U16 U16x8
- #define U8 U8x8
-
- #define F0 F{0,0,0,0, 0,0,0,0}
- #define F1 F{1,1,1,1, 1,1,1,1}
+ using F = Vec<N,float>;
+ using I32 = Vec<N,int32_t>;
+ using U64 = Vec<N,uint64_t>;
+ using U32 = Vec<N,uint32_t>;
+ using U16 = Vec<N,uint16_t>;
+ using U8 = Vec<N,uint8_t>;
#else
#define N 4
-
- #define F Fx4
- #define U64 U64x4
- #define U32 U32x4
- #define I32 I32x4
- #define U16 U16x4
- #define U8 U8x4
-
- #define F0 F{0,0,0,0}
- #define F1 F{1,1,1,1}
+ using F = Vec<N,float>;
+ using I32 = Vec<N,int32_t>;
+ using U64 = Vec<N,uint64_t>;
+ using U32 = Vec<N,uint32_t>;
+ using U16 = Vec<N,uint16_t>;
+ using U8 = Vec<N,uint8_t>;
#endif
-#define NS(id) id
-#define ATTR
+ #define ATTR
#include "src/Transform_inl.h"
-#undef N
-#undef F
-#undef U64
-#undef U32
-#undef I32
-#undef U16
-#undef U8
-#undef F0
-#undef F1
-#undef NS
-#undef ATTR
+ #undef N
+ #undef ATTR
+}
// Now, instantiate any other versions of run_program() we may want for runtime detection.
#if !defined(SKCMS_PORTABLE) && (defined(__clang__) || defined(__GNUC__)) \
&& defined(__x86_64__) && !defined(__AVX2__)
- #define N 8
- #define F Fx8
- #define U64 U64x8
- #define U32 U32x8
- #define I32 I32x8
- #define U16 U16x8
- #define U8 U8x8
- #define F0 F{0,0,0,0, 0,0,0,0}
- #define F1 F{1,1,1,1, 1,1,1,1}
- #define NS(id) id ## _hsw
- #define ATTR __attribute__((target("avx2,f16c")))
+ namespace hsw {
+ #define N 8
+ using F = Vec<N,float>;
+ using I32 = Vec<N,int32_t>;
+ using U64 = Vec<N,uint64_t>;
+ using U32 = Vec<N,uint32_t>;
+ using U16 = Vec<N,uint16_t>;
+ using U8 = Vec<N,uint8_t>;
- // We check these guards to see if we have support for these features.
- // They're likely _not_ defined here in our baseline build config.
- #ifndef __AVX__
- #define __AVX__ 1
- #define UNDEF_AVX
- #endif
- #ifndef __F16C__
- #define __F16C__ 1
- #define UNDEF_F16C
- #endif
- #ifndef __AVX2__
- #define __AVX2__ 1
- #define UNDEF_AVX2
- #endif
+ #define ATTR __attribute__((target("avx2,f16c")))
- #include "src/Transform_inl.h"
+ // We check these guards to see if we have support for these features.
+ // They're likely _not_ defined here in our baseline build config.
+ #ifndef __AVX__
+ #define __AVX__ 1
+ #define UNDEF_AVX
+ #endif
+ #ifndef __F16C__
+ #define __F16C__ 1
+ #define UNDEF_F16C
+ #endif
+ #ifndef __AVX2__
+ #define __AVX2__ 1
+ #define UNDEF_AVX2
+ #endif
- #undef N
- #undef F
- #undef U64
- #undef U32
- #undef I32
- #undef U16
- #undef U8
- #undef F0
- #undef F1
- #undef NS
- #undef ATTR
+ #include "src/Transform_inl.h"
- #ifdef UNDEF_AVX
- #undef __AVX__
- #undef UNDEF_AVX
- #endif
- #ifdef UNDEF_F16C
- #undef __F16C__
- #undef UNDEF_F16C
- #endif
- #ifdef UNDEF_AVX2
- #undef __AVX2__
- #undef UNDEF_AVX2
- #endif
+ #undef N
+ #undef ATTR
+
+ #ifdef UNDEF_AVX
+ #undef __AVX__
+ #undef UNDEF_AVX
+ #endif
+ #ifdef UNDEF_F16C
+ #undef __F16C__
+ #undef UNDEF_F16C
+ #endif
+ #ifdef UNDEF_AVX2
+ #undef __AVX2__
+ #undef UNDEF_AVX2
+ #endif
+ }
#define TEST_FOR_HSW
@@ -2319,11 +2259,9 @@
case skcms_PixelFormat_RGBA_ffff >> 1: *ops++ = Op_store_ffff; break;
}
- void (*run)(const Op*, const void**, const char*, char*, int, size_t,size_t) = run_program;
+ auto run = baseline::run_program;
#if defined(TEST_FOR_HSW)
- if (hsw_ok()) {
- run = run_program_hsw;
- }
+ if (hsw_ok()) { run = hsw::run_program; }
#endif
run(program, arguments, (const char*)src, (char*)dst, n, src_bpp,dst_bpp);
return true;
diff --git a/third_party/skcms/src/Transform_inl.h b/third_party/skcms/src/Transform_inl.h
index 09183bf..4d09fed 100644
--- a/third_party/skcms/src/Transform_inl.h
+++ b/third_party/skcms/src/Transform_inl.h
@@ -7,30 +7,28 @@
// Intentionally NO #pragma once... included multiple times.
-// This file is included from skcms.c with some values and types pre-defined:
+// This file is included from skcms.cc with some pre-defined macros:
// N: depth of all vectors, 1,4,8, or 16
-//
+// ATTR: an __attribute__ to apply to functions
+// and inside a namespace, with some types already defined:
// F: a vector of N float
// I32: a vector of N int32_t
// U64: a vector of N uint64_t
// U32: a vector of N uint32_t
// U16: a vector of N uint16_t
// U8: a vector of N uint8_t
-//
-// F0: a vector of N floats set to zero
-// F1: a vector of N floats set to one
-//
-// NS(id): a macro that returns unique identifiers
-// ATTR: an __attribute__ to apply to functions
#if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
// TODO(mtklein): this build supports FP16 compute
#endif
-#if defined(__ARM_NEON)
- #include <arm_neon.h>
-#elif defined(__SSE__)
- #include <immintrin.h>
+#if defined(__GNUC__) && !defined(__clang__)
+ // Once again, GCC is kind of weird, not allowing vector = scalar directly.
+ static constexpr F F0 = F() + 0.0f,
+ F1 = F() + 1.0f;
+#else
+ static constexpr F F0 = 0.0f,
+ F1 = 1.0f;
#endif
#if N == 4 && defined(__ARM_NEON)
@@ -83,8 +81,7 @@
// When we convert from float to fixed point, it's very common to want to round,
// and for some reason compilers generate better code when converting to int32_t.
// To serve both those ends, we use this function to_fixed() instead of direct CASTs.
-SI ATTR I32 NS(to_fixed_)(F f) { return CAST(I32, f + 0.5f); }
-#define to_fixed NS(to_fixed_)
+SI ATTR I32 to_fixed(F f) { return CAST(I32, f + 0.5f); }
// Comparisons result in bool when N == 1, in an I32 mask when N > 1.
// We've made this a macro so it can be type-generic...
@@ -96,23 +93,23 @@
#endif
#if defined(USING_NEON_F16C)
- SI ATTR F NS(F_from_Half_(U16 half)) { return vcvt_f32_f16((float16x4_t)half); }
- SI ATTR U16 NS(Half_from_F_(F f)) { return (U16)vcvt_f16_f32( f); }
+ SI ATTR F F_from_Half(U16 half) { return vcvt_f32_f16((float16x4_t)half); }
+ SI ATTR U16 Half_from_F(F f) { return (U16)vcvt_f16_f32( f); }
#elif defined(__AVX512F__)
- SI ATTR F NS(F_from_Half_)(U16 half) { return (F)_mm512_cvtph_ps((__m256i)half); }
- SI ATTR U16 NS(Half_from_F_)(F f) {
+ SI ATTR F F_from_Half(U16 half) { return (F)_mm512_cvtph_ps((__m256i)half); }
+ SI ATTR U16 Half_from_F(F f) {
return (U16)_mm512_cvtps_ph((__m512 )f, _MM_FROUND_CUR_DIRECTION );
}
#elif defined(USING_AVX_F16C)
- SI ATTR F NS(F_from_Half_)(U16 half) {
+ SI ATTR F F_from_Half(U16 half) {
typedef int16_t __attribute__((vector_size(16))) I16;
return __builtin_ia32_vcvtph2ps256((I16)half);
}
- SI ATTR U16 NS(Half_from_F_)(F f) {
+ SI ATTR U16 Half_from_F(F f) {
return (U16)__builtin_ia32_vcvtps2ph256(f, 0x04/*_MM_FROUND_CUR_DIRECTION*/);
}
#else
- SI ATTR F NS(F_from_Half_)(U16 half) {
+ SI ATTR F F_from_Half(U16 half) {
U32 wide = CAST(U32, half);
// A half is 1-5-10 sign-exponent-mantissa, with 15 exponent bias.
U32 s = wide & 0x8000,
@@ -127,7 +124,7 @@
return (F)if_then_else(em < 0x0400, F0, norm);
}
- SI ATTR U16 NS(Half_from_F_)(F f) {
+ SI ATTR U16 Half_from_F(F f) {
// A float is 1-8-23 sign-exponent-mantissa, with 127 exponent bias.
U32 sem;
small_memcpy(&sem, &f, sizeof(sem));
@@ -141,36 +138,28 @@
}
#endif
-#define F_from_Half NS(F_from_Half_)
-#define Half_from_F NS(Half_from_F_)
-
// Swap high and low bytes of 16-bit lanes, converting between big-endian and little-endian.
#if defined(USING_NEON)
- SI ATTR U16 NS(swap_endian_16_)(U16 v) {
+ SI ATTR U16 swap_endian_16(U16 v) {
return (U16)vrev16_u8((uint8x8_t) v);
}
- #define swap_endian_16 NS(swap_endian_16_)
#endif
// Passing by U64* instead of U64 avoids ABI warnings. It's all moot when inlined.
-SI ATTR void NS(swap_endian_16x4_)(U64* rgba) {
+SI ATTR void swap_endian_16x4(U64* rgba) {
*rgba = (*rgba & 0x00ff00ff00ff00ff) << 8
| (*rgba & 0xff00ff00ff00ff00) >> 8;
}
-#define swap_endian_16x4 NS(swap_endian_16x4_)
#if defined(USING_NEON)
- SI ATTR F NS(min__)(F x, F y) { return (F)vminq_f32((float32x4_t)x, (float32x4_t)y); }
- SI ATTR F NS(max__)(F x, F y) { return (F)vmaxq_f32((float32x4_t)x, (float32x4_t)y); }
+ SI ATTR F min_(F x, F y) { return (F)vminq_f32((float32x4_t)x, (float32x4_t)y); }
+ SI ATTR F max_(F x, F y) { return (F)vmaxq_f32((float32x4_t)x, (float32x4_t)y); }
#else
- SI ATTR F NS(min__)(F x, F y) { return (F)if_then_else(x > y, y, x); }
- SI ATTR F NS(max__)(F x, F y) { return (F)if_then_else(x < y, y, x); }
+ SI ATTR F min_(F x, F y) { return (F)if_then_else(x > y, y, x); }
+ SI ATTR F max_(F x, F y) { return (F)if_then_else(x < y, y, x); }
#endif
-#define min_ NS(min__)
-#define max_ NS(max__)
-
-SI ATTR F NS(floor__)(F x) {
+SI ATTR F floor_(F x) {
#if N == 1
return floorf_(x);
#elif defined(__aarch64__)
@@ -191,9 +180,8 @@
// the range an integer can represent. We expect most x to be small.
#endif
}
-#define floor_ NS(floor__)
-SI ATTR F NS(approx_log2_)(F x) {
+SI ATTR F approx_log2(F x) {
// The first approximation of log2(x) is its exponent 'e', minus 127.
I32 bits;
small_memcpy(&bits, &x, sizeof(bits));
@@ -209,9 +197,8 @@
- 1.498030302f*m
- 1.725879990f/(0.3520887068f + m);
}
-#define approx_log2 NS(approx_log2_)
-SI ATTR F NS(approx_exp2_)(F x) {
+SI ATTR F approx_exp2(F x) {
F fract = x - floor_(x);
I32 bits = CAST(I32, (1.0f * (1<<23)) * (x + 121.274057500f
@@ -220,16 +207,14 @@
small_memcpy(&x, &bits, sizeof(x));
return x;
}
-#define approx_exp2 NS(approx_exp2_)
-SI ATTR F NS(approx_pow_)(F x, float y) {
+SI ATTR F approx_pow(F x, float y) {
return (F)if_then_else((x == F0) | (x == F1), x
, approx_exp2(approx_log2(x) * y));
}
-#define approx_pow NS(approx_pow_)
// Return tf(x).
-SI ATTR F NS(apply_tf_)(const skcms_TransferFunction* tf, F x) {
+SI ATTR F apply_tf(const skcms_TransferFunction* tf, F x) {
F sign = (F)if_then_else(x < 0, -F1, F1);
x *= sign;
@@ -238,7 +223,6 @@
return sign * (F)if_then_else(x < tf->d, linear, nonlinear);
}
-#define apply_tf NS(apply_tf_)
// Strided loads and stores of N values, starting from p.
#if N == 1
@@ -283,7 +267,7 @@
(p)[48] = (v)[12]; (p)[52] = (v)[13]; (p)[56] = (v)[14]; (p)[60] = (v)[15]
#endif
-SI ATTR U8 NS(gather_8_)(const uint8_t* p, I32 ix) {
+SI ATTR U8 gather_8(const uint8_t* p, I32 ix) {
#if N == 1
U8 v = p[ix];
#elif N == 4
@@ -299,17 +283,15 @@
#endif
return v;
}
-#define gather_8 NS(gather_8_)
// Helper for gather_16(), loading the ix'th 16-bit value from p.
-SI ATTR uint16_t NS(load_16_)(const uint8_t* p, int ix) {
+SI ATTR uint16_t load_16(const uint8_t* p, int ix) {
uint16_t v;
small_memcpy(&v, p + 2*ix, 2);
return v;
}
-#define load_16 NS(load_16_)
-SI ATTR U16 NS(gather_16_)(const uint8_t* p, I32 ix) {
+SI ATTR U16 gather_16(const uint8_t* p, I32 ix) {
#if N == 1
U16 v = load_16(p,ix);
#elif N == 4
@@ -325,25 +307,22 @@
#endif
return v;
}
-#define gather_16 NS(gather_16_)
#if !defined(__AVX2__)
// Helpers for gather_24/48(), loading the ix'th 24/48-bit value from p, and 1/2 extra bytes.
- SI ATTR uint32_t NS(load_24_32_)(const uint8_t* p, int ix) {
+ SI ATTR uint32_t load_24_32(const uint8_t* p, int ix) {
uint32_t v;
small_memcpy(&v, p + 3*ix, 4);
return v;
}
- SI ATTR uint64_t NS(load_48_64_)(const uint8_t* p, int ix) {
+ SI ATTR uint64_t load_48_64(const uint8_t* p, int ix) {
uint64_t v;
small_memcpy(&v, p + 6*ix, 8);
return v;
}
- #define load_24_32 NS(load_24_32_)
- #define load_48_64 NS(load_48_64_)
#endif
-SI ATTR U32 NS(gather_24_)(const uint8_t* p, I32 ix) {
+SI ATTR U32 gather_24(const uint8_t* p, I32 ix) {
// First, back up a byte. Any place we're gathering from has a safe junk byte to read
// in front of it, either a previous table value, or some tag metadata.
p -= 1;
@@ -379,10 +358,9 @@
// Shift off the junk byte, leaving r,g,b in low 24 bits (and zero in the top 8).
return v >> 8;
}
-#define gather_24 NS(gather_24_)
#if !defined(__arm__)
- SI ATTR void NS(gather_48_)(const uint8_t* p, I32 ix, U64* v) {
+ SI ATTR void gather_48(const uint8_t* p, I32 ix, U64* v) {
// As in gather_24(), with everything doubled.
p -= 2;
@@ -433,32 +411,28 @@
*v >>= 16;
}
- #define gather_48 NS(gather_48_)
#endif
-SI ATTR F NS(F_from_U8_)(U8 v) {
+SI ATTR F F_from_U8(U8 v) {
return CAST(F, v) * (1/255.0f);
}
-#define F_from_U8 NS(F_from_U8_)
-SI ATTR F NS(F_from_U16_BE_)(U16 v) {
+SI ATTR F F_from_U16_BE(U16 v) {
// All 16-bit ICC values are big-endian, so we byte swap before converting to float.
// MSVC catches the "loss" of data here in the portable path, so we also make sure to mask.
v = (U16)( ((v<<8)|(v>>8)) & 0xffff );
return CAST(F, v) * (1/65535.0f);
}
-#define F_from_U16_BE NS(F_from_U16_BE_)
-SI ATTR F NS(minus_1_ulp_)(F v) {
+SI ATTR F minus_1_ulp(F v) {
I32 bits;
small_memcpy(&bits, &v, sizeof(bits));
bits = bits - 1;
small_memcpy(&v, &bits, sizeof(bits));
return v;
}
-#define minus_1_ulp NS(minus_1_ulp_)
-SI ATTR F NS(table_8_)(const skcms_Curve* curve, F v) {
+SI ATTR F table_8(const skcms_Curve* curve, F v) {
// Clamp the input to [0,1], then scale to a table index.
F ix = max_(F0, min_(v, F1)) * (float)(curve->table_entries - 1);
@@ -476,7 +450,7 @@
return l + (h-l)*t;
}
-SI ATTR F NS(table_16_)(const skcms_Curve* curve, F v) {
+SI ATTR F table_16(const skcms_Curve* curve, F v) {
// All just as in table_8() until the gathers.
F ix = max_(F0, min_(v, F1)) * (float)(curve->table_entries - 1);
@@ -492,7 +466,7 @@
}
// Color lookup tables, by input dimension and bit depth.
-SI ATTR void NS(clut_0_8_)(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) {
+SI ATTR void clut_0_8(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) {
U32 rgb = gather_24(a2b->grid_8, ix);
*r = CAST(F, (rgb >> 0) & 0xff) * (1/255.0f);
@@ -502,7 +476,7 @@
(void)a;
(void)stride;
}
-SI ATTR void NS(clut_0_16_)(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) {
+SI ATTR void clut_0_16(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) {
#if defined(__arm__)
// This is up to 2x faster on 32-bit ARM than the #else-case fast path.
*r = F_from_U16_BE(gather_16(a2b->grid_16, 3*ix+0));
@@ -532,28 +506,28 @@
// These are all the same basic approach: handle one dimension, then the rest recursively.
// We let "I" be the current dimension, and "J" the previous dimension, I-1. "B" is the bit depth.
-#define DEF_CLUT(I,J,B) \
- MAYBE_SI ATTR \
- void NS(clut_##I##_##B##_)(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) { \
- I32 limit = CAST(I32, F0); \
- limit += a2b->grid_points[I-1]; \
- \
- const F* srcs[] = { r,g,b,&a }; \
- F src = *srcs[I-1]; \
- \
- F x = max_(F0, min_(src, F1)) * CAST(F, limit - 1); \
- \
- I32 lo = CAST(I32, x ), \
- hi = CAST(I32, minus_1_ulp(x+1.0f)); \
- F lr = *r, lg = *g, lb = *b, \
- hr = *r, hg = *g, hb = *b; \
- NS(clut_##J##_##B##_)(a2b, stride*lo + ix, stride*limit, &lr,&lg,&lb,a); \
- NS(clut_##J##_##B##_)(a2b, stride*hi + ix, stride*limit, &hr,&hg,&hb,a); \
- \
- F t = x - CAST(F, lo); \
- *r = lr + (hr-lr)*t; \
- *g = lg + (hg-lg)*t; \
- *b = lb + (hb-lb)*t; \
+#define DEF_CLUT(I,J,B) \
+ MAYBE_SI ATTR \
+ void clut_##I##_##B(const skcms_A2B* a2b, I32 ix, I32 stride, F* r, F* g, F* b, F a) { \
+ I32 limit = CAST(I32, F0); \
+ limit += a2b->grid_points[I-1]; \
+ \
+ const F* srcs[] = { r,g,b,&a }; \
+ F src = *srcs[I-1]; \
+ \
+ F x = max_(F0, min_(src, F1)) * CAST(F, limit - 1); \
+ \
+ I32 lo = CAST(I32, x ), \
+ hi = CAST(I32, minus_1_ulp(x+1.0f)); \
+ F lr = *r, lg = *g, lb = *b, \
+ hr = *r, hg = *g, hb = *b; \
+ clut_##J##_##B(a2b, stride*lo + ix, stride*limit, &lr,&lg,&lb,a); \
+ clut_##J##_##B(a2b, stride*hi + ix, stride*limit, &hr,&hg,&hb,a); \
+ \
+ F t = x - CAST(F, lo); \
+ *r = lr + (hr-lr)*t; \
+ *g = lg + (hg-lg)*t; \
+ *b = lb + (hb-lb)*t; \
}
DEF_CLUT(1,0,8)
@@ -567,8 +541,8 @@
DEF_CLUT(4,3,16)
ATTR
-static void NS(exec_ops)(const Op* ops, const void** args,
- const char* src, char* dst, int i) {
+static void exec_ops(const Op* ops, const void** args,
+ const char* src, char* dst, int i) {
F r = F0, g = F0, b = F0, a = F0;
while (true) {
switch (*ops++) {
@@ -863,36 +837,36 @@
case Op_tf_b:{ b = apply_tf((const skcms_TransferFunction*)*args++, b); } break;
case Op_tf_a:{ a = apply_tf((const skcms_TransferFunction*)*args++, a); } break;
- case Op_table_8_r: { r = NS(table_8_ )((const skcms_Curve*)*args++, r); } break;
- case Op_table_8_g: { g = NS(table_8_ )((const skcms_Curve*)*args++, g); } break;
- case Op_table_8_b: { b = NS(table_8_ )((const skcms_Curve*)*args++, b); } break;
- case Op_table_8_a: { a = NS(table_8_ )((const skcms_Curve*)*args++, a); } break;
+ case Op_table_8_r: { r = table_8((const skcms_Curve*)*args++, r); } break;
+ case Op_table_8_g: { g = table_8((const skcms_Curve*)*args++, g); } break;
+ case Op_table_8_b: { b = table_8((const skcms_Curve*)*args++, b); } break;
+ case Op_table_8_a: { a = table_8((const skcms_Curve*)*args++, a); } break;
- case Op_table_16_r:{ r = NS(table_16_)((const skcms_Curve*)*args++, r); } break;
- case Op_table_16_g:{ g = NS(table_16_)((const skcms_Curve*)*args++, g); } break;
- case Op_table_16_b:{ b = NS(table_16_)((const skcms_Curve*)*args++, b); } break;
- case Op_table_16_a:{ a = NS(table_16_)((const skcms_Curve*)*args++, a); } break;
+ case Op_table_16_r:{ r = table_16((const skcms_Curve*)*args++, r); } break;
+ case Op_table_16_g:{ g = table_16((const skcms_Curve*)*args++, g); } break;
+ case Op_table_16_b:{ b = table_16((const skcms_Curve*)*args++, b); } break;
+ case Op_table_16_a:{ a = table_16((const skcms_Curve*)*args++, a); } break;
case Op_clut_3D_8:{
const skcms_A2B* a2b = (const skcms_A2B*) *args++;
- NS(clut_3_8_)(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
+ clut_3_8(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
} break;
case Op_clut_3D_16:{
const skcms_A2B* a2b = (const skcms_A2B*) *args++;
- NS(clut_3_16_)(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
+ clut_3_16(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
} break;
case Op_clut_4D_8:{
const skcms_A2B* a2b = (const skcms_A2B*) *args++;
- NS(clut_4_8_)(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
+ clut_4_8(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
// 'a' was really a CMYK K, so our output is actually opaque.
a = F1;
} break;
case Op_clut_4D_16:{
const skcms_A2B* a2b = (const skcms_A2B*) *args++;
- NS(clut_4_16_)(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
+ clut_4_16(a2b, CAST(I32,F0),CAST(I32,F1), &r,&g,&b,a);
// 'a' was really a CMYK K, so our output is actually opaque.
a = F1;
} break;
@@ -1098,12 +1072,12 @@
}
ATTR
-static void NS(run_program)(const Op* program, const void** arguments,
- const char* src, char* dst, int n,
- const size_t src_bpp, const size_t dst_bpp) {
+static void run_program(const Op* program, const void** arguments,
+ const char* src, char* dst, int n,
+ const size_t src_bpp, const size_t dst_bpp) {
int i = 0;
while (n >= N) {
- NS(exec_ops)(program, arguments, src, dst, i);
+ exec_ops(program, arguments, src, dst, i);
i += N;
n -= N;
}
@@ -1112,7 +1086,7 @@
tmp_dst[4*4*N] = {0};
memcpy(tmp_src, (const char*)src + (size_t)i*src_bpp, (size_t)n*src_bpp);
- NS(exec_ops)(program, arguments, tmp_src, tmp_dst, 0);
+ exec_ops(program, arguments, tmp_src, tmp_dst, 0);
memcpy((char*)dst + (size_t)i*dst_bpp, tmp_dst, (size_t)n*dst_bpp);
}
}
diff --git a/third_party/skcms/version.sha1 b/third_party/skcms/version.sha1
index 746a312..5554bc6 100755
--- a/third_party/skcms/version.sha1
+++ b/third_party/skcms/version.sha1
@@ -1 +1 @@
-23e7777f421d11992e8245771641141aa273556b
\ No newline at end of file
+51fba282d9a06baa9f8ed2e3d679c5f439420322
\ No newline at end of file