Line data    Source code

       1             : /*
       2             :  * Copyright 2016 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #ifndef SkSRGB_DEFINED
       9             : #define SkSRGB_DEFINED
      10             : 
      11             : #include "SkNx.h"
      12             : 
      13             : /** Components for building our canonical sRGB -> linear and linear -> sRGB transformations.
      14             :  *
      15             :  *  Current best practices:
      16             :  *      - for sRGB -> linear, lookup R,G,B in sk_linear_from_srgb;
      17             :  *      - for linear -> sRGB, call sk_linear_to_srgb() for R,G,B;
      18             :  *      - the alpha channel is linear in both formats, needing at most *(1/255.0f) or *255.0f.
      19             :  *
      20             :  *  sk_linear_to_srgb() will run a little faster than usual when compiled with SSE4.1+.
      21             :  */
      22             : 
      23             : extern const float    sk_linear_from_srgb[256];
      24             : extern const uint16_t sk_linear12_from_srgb[256];
      25             : extern const uint8_t  sk_linear12_to_srgb[4096];
      26             : 
      27             : template <typename V>
      28          81 : static inline V sk_clamp_0_255(const V& x) {
      29             :     // The order of the arguments is important here.  We want to make sure that NaN
      30             :     // clamps to zero.  Note that max(NaN, 0) = 0, while max(0, NaN) = NaN.
      31         162 :     return V::Min(V::Max(x, 0.0f), 255.0f);
      32             : }
      33             : 
      34             : // [0.0f, 1.0f] -> [0.0f, 255.xf], for small x.  Correct after truncation.
      35             : template <typename V>
      36          81 : static inline V sk_linear_to_srgb_needs_trunc(const V& x) {
      37             :     // Approximation of the sRGB gamma curve (within 1 when scaled to 8-bit pixels).
      38             :     //
      39             :     // Constants tuned by brute force to minimize (in order of importance) after truncation:
      40             :     //    1) the number of bytes that fail to round trip (0 of 256);
      41             :     //    2) the number of points in [FLT_MIN, 1.0f] that are non-monotonic (0 of ~1 billion);
      42             :     //    3) the number of points halfway between bytes that hit the wrong byte (131 of 255).
      43          81 :     auto rsqrt = x.rsqrt(),
      44          81 :          sqrt  = rsqrt.invert(),
      45          81 :          ftrt  = rsqrt.rsqrt();
      46             : 
      47          81 :     auto lo = (13.0471f * 255.0f) * x;
      48             : 
      49          81 :     auto hi = SkNx_fma(V{+0.412999f  * 255.0f}, ftrt,
      50         162 :               SkNx_fma(V{+0.687999f  * 255.0f}, sqrt,
      51          81 :                        V{-0.0974983f * 255.0f}));
      52         162 :     return (x < 0.0048f).thenElse(lo, hi);
      53             : }
      54             : 
      55             : // [0.0f, 1.0f] -> [0.0f, 1.0f].  Correct after rounding.
      56             : template <typename V>
      57           0 : static inline V sk_linear_to_srgb_needs_round(const V& x) {
      58             :     // Tuned to round trip each sRGB byte after rounding.
      59           0 :     auto rsqrt = x.rsqrt(),
      60           0 :          sqrt  = rsqrt.invert(),
      61           0 :          ftrt  = rsqrt.rsqrt();
      62             : 
      63           0 :     auto lo = 12.46f * x;
      64             : 
      65           0 :     auto hi = V::Min(1.0f, SkNx_fma(V{+0.411192f}, ftrt,
      66           0 :                            SkNx_fma(V{+0.689206f}, sqrt,
      67           0 :                                     V{-0.0988f})));
      68           0 :     return (x < 0.0043f).thenElse(lo, hi);
      69             : }
      70             : 
      71             : template <int N>
      72          81 : static inline SkNx<N,int> sk_linear_to_srgb(const SkNx<N,float>& x) {
      73          81 :     auto f = sk_linear_to_srgb_needs_trunc(x);
      74         162 :     return SkNx_cast<int>(sk_clamp_0_255(f));
      75             : }
      76             : 
      77             : 
      78             : // sRGB -> linear, using math instead of table lookups.
      79             : template <typename V>
      80           0 : static inline V sk_linear_from_srgb_math(const V& x) {
      81             :     // Non-linear segment of sRGB curve approximated by
      82             :     // l = 0.0025 + 0.6975x^2 + 0.3x^3
      83             :     const V k0 = 0.0025f,
      84             :             k2 = 0.6975f,
      85             :             k3 = 0.3000f;
      86           0 :     auto hi = SkNx_fma(x*x, SkNx_fma(x, k3, k2), k0);
      87             : 
      88             :     // Linear segment of sRGB curve: the normal slope, extended a little further than normal.
      89           0 :     auto lo = x * (1/12.92f);
      90             : 
      91           0 :     return (x < 0.055f).thenElse(lo, hi);
      92             : }
      93             : 
      94             : // Same as above, starting from ints.
      95             : template <int N>
      96             : static inline SkNx<N,float> sk_linear_from_srgb_math(const SkNx<N,int>& s) {
      97             :     auto x = SkNx_cast<float>(s);
      98             : 
      99             :     // Same math as above, but working with x in [0,255], so x^n needs scaling by u^n.
     100             :     const float u = 1/255.0f;
     101             : 
     102             :     const SkNx<N,float> k0 = 0.0025f,
     103             :                         k2 = 0.6975f * u*u,
     104             :                         k3 = 0.3000f * u*u*u;
     105             :     auto hi = SkNx_fma(x*x, SkNx_fma(x, k3, k2), k0);
     106             :     auto lo = x * (u/12.92f);
     107             :     return (x < (0.055f/u)).thenElse(lo, hi);
     108             : }
     109             : 
     110             : #endif//SkSRGB_DEFINED