| Index: src/core/SkColorSpaceXformOpts.h
|
| diff --git a/src/core/SkColorSpaceXformOpts.h b/src/core/SkColorSpaceXformOpts.h
|
| deleted file mode 100644
|
| index e0ff935a31fb04afaeef29c4bbf79a5d6c273d40..0000000000000000000000000000000000000000
|
| --- a/src/core/SkColorSpaceXformOpts.h
|
| +++ /dev/null
|
| @@ -1,406 +0,0 @@
|
| -/*
|
| - * Copyright 2016 Google Inc.
|
| - *
|
| - * Use of this source code is governed by a BSD-style license that can be
|
| - * found in the LICENSE file.
|
| - */
|
| -
|
| -#ifndef SkColorSpaceXformOpts_DEFINED
|
| -#define SkColorSpaceXformOpts_DEFINED
|
| -
|
| -#include "SkNx.h"
|
| -#include "SkColorPriv.h"
|
| -#include "SkHalf.h"
|
| -#include "SkSRGB.h"
|
| -#include "SkTemplates.h"
|
| -
|
| -enum SwapRB {
|
| - kNo_SwapRB,
|
| - kYes_SwapRB,
|
| -};
|
| -
|
| -static inline void load_matrix(const float matrix[16],
|
| - Sk4f& rXgXbX, Sk4f& rYgYbY, Sk4f& rZgZbZ, Sk4f& rTgTbT) {
|
| - rXgXbX = Sk4f::Load(matrix + 0);
|
| - rYgYbY = Sk4f::Load(matrix + 4);
|
| - rZgZbZ = Sk4f::Load(matrix + 8);
|
| - rTgTbT = Sk4f::Load(matrix + 12);
|
| -}
|
| -
|
| -static inline void load_rgb_from_tables(const uint32_t* src,
|
| - Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
|
| - const float* const srcTables[3]) {
|
| - r = { srcTables[0][(src[0] >> 0) & 0xFF],
|
| - srcTables[0][(src[1] >> 0) & 0xFF],
|
| - srcTables[0][(src[2] >> 0) & 0xFF],
|
| - srcTables[0][(src[3] >> 0) & 0xFF], };
|
| - g = { srcTables[1][(src[0] >> 8) & 0xFF],
|
| - srcTables[1][(src[1] >> 8) & 0xFF],
|
| - srcTables[1][(src[2] >> 8) & 0xFF],
|
| - srcTables[1][(src[3] >> 8) & 0xFF], };
|
| - b = { srcTables[2][(src[0] >> 16) & 0xFF],
|
| - srcTables[2][(src[1] >> 16) & 0xFF],
|
| - srcTables[2][(src[2] >> 16) & 0xFF],
|
| - srcTables[2][(src[3] >> 16) & 0xFF], };
|
| - a = 0.0f; // Don't let the compiler complain that |a| is uninitialized.
|
| -}
|
| -
|
| -static inline void load_rgba_from_tables(const uint32_t* src,
|
| - Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
|
| - const float* const srcTables[3]) {
|
| - r = { srcTables[0][(src[0] >> 0) & 0xFF],
|
| - srcTables[0][(src[1] >> 0) & 0xFF],
|
| - srcTables[0][(src[2] >> 0) & 0xFF],
|
| - srcTables[0][(src[3] >> 0) & 0xFF], };
|
| - g = { srcTables[1][(src[0] >> 8) & 0xFF],
|
| - srcTables[1][(src[1] >> 8) & 0xFF],
|
| - srcTables[1][(src[2] >> 8) & 0xFF],
|
| - srcTables[1][(src[3] >> 8) & 0xFF], };
|
| - b = { srcTables[2][(src[0] >> 16) & 0xFF],
|
| - srcTables[2][(src[1] >> 16) & 0xFF],
|
| - srcTables[2][(src[2] >> 16) & 0xFF],
|
| - srcTables[2][(src[3] >> 16) & 0xFF], };
|
| - a = (1.0f / 255.0f) * SkNx_cast<float>(Sk4u::Load(src) >> 24);
|
| -}
|
| -
|
| -static inline void load_rgb_from_tables_1(const uint32_t* src,
|
| - Sk4f& r, Sk4f& g, Sk4f& b, Sk4f&,
|
| - const float* const srcTables[3]) {
|
| - // Splat r,g,b across a register each.
|
| - r = Sk4f(srcTables[0][(*src >> 0) & 0xFF]);
|
| - g = Sk4f(srcTables[1][(*src >> 8) & 0xFF]);
|
| - b = Sk4f(srcTables[2][(*src >> 16) & 0xFF]);
|
| -}
|
| -
|
| -static inline void load_rgba_from_tables_1(const uint32_t* src,
|
| - Sk4f& r, Sk4f& g, Sk4f& b, Sk4f& a,
|
| - const float* const srcTables[3]) {
|
| - // Splat r,g,b across a register each.
|
| - r = Sk4f(srcTables[0][(*src >> 0) & 0xFF]);
|
| - g = Sk4f(srcTables[1][(*src >> 8) & 0xFF]);
|
| - b = Sk4f(srcTables[2][(*src >> 16) & 0xFF]);
|
| - a = (1.0f / 255.0f) * Sk4f(*src >> 24);
|
| -}
|
| -
|
| -static inline void transform_gamut(const Sk4f& r, const Sk4f& g, const Sk4f& b, const Sk4f& a,
|
| - const Sk4f& rXgXbX, const Sk4f& rYgYbY, const Sk4f& rZgZbZ,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da) {
|
| - dr = rXgXbX[0]*r + rYgYbY[0]*g + rZgZbZ[0]*b;
|
| - dg = rXgXbX[1]*r + rYgYbY[1]*g + rZgZbZ[1]*b;
|
| - db = rXgXbX[2]*r + rYgYbY[2]*g + rZgZbZ[2]*b;
|
| - da = a;
|
| -}
|
| -
|
| -static inline void transform_gamut_1(const Sk4f& r, const Sk4f& g, const Sk4f& b,
|
| - const Sk4f& rXgXbX, const Sk4f& rYgYbY, const Sk4f& rZgZbZ,
|
| - Sk4f& rgba) {
|
| - rgba = rXgXbX*r + rYgYbY*g + rZgZbZ*b;
|
| -}
|
| -
|
| -static inline void translate_gamut(const Sk4f& rTgTbT, Sk4f& dr, Sk4f& dg, Sk4f& db) {
|
| - dr = dr + rTgTbT[0];
|
| - dg = dg + rTgTbT[1];
|
| - db = db + rTgTbT[2];
|
| -}
|
| -
|
| -static inline void translate_gamut_1(const Sk4f& rTgTbT, Sk4f& rgba) {
|
| - rgba = rgba + rTgTbT;
|
| -}
|
| -
|
| -static inline void premultiply(Sk4f& dr, Sk4f& dg, Sk4f& db, const Sk4f& da) {
|
| - dr = da * dr;
|
| - dg = da * dg;
|
| - db = da * db;
|
| -}
|
| -
|
| -static inline void premultiply_1(const Sk4f& a, Sk4f& rgba) {
|
| - rgba = a * rgba;
|
| -}
|
| -
|
| -static inline void store_srgb(void* dst, const uint32_t* src,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - int kRShift = 0;
|
| - int kGShift = 8;
|
| - int kBShift = 16;
|
| - if (kYes_SwapRB == kSwapRB) {
|
| - kBShift = 0;
|
| - kRShift = 16;
|
| - }
|
| -
|
| - dr = sk_linear_to_srgb_needs_trunc(dr);
|
| - dg = sk_linear_to_srgb_needs_trunc(dg);
|
| - db = sk_linear_to_srgb_needs_trunc(db);
|
| -
|
| - dr = sk_clamp_0_255(dr);
|
| - dg = sk_clamp_0_255(dg);
|
| - db = sk_clamp_0_255(db);
|
| -
|
| - Sk4i da = Sk4i::Load(src) & 0xFF000000;
|
| -
|
| - Sk4i rgba = (SkNx_cast<int>(dr) << kRShift)
|
| - | (SkNx_cast<int>(dg) << kGShift)
|
| - | (SkNx_cast<int>(db) << kBShift)
|
| - | (da );
|
| - rgba.store(dst);
|
| -}
|
| -
|
| -static inline void store_srgb_1(void* dst, const uint32_t* src,
|
| - Sk4f& rgba, const Sk4f&,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - rgba = sk_clamp_0_255(sk_linear_to_srgb_needs_trunc(rgba));
|
| -
|
| - uint32_t tmp;
|
| - SkNx_cast<uint8_t>(SkNx_cast<int32_t>(rgba)).store(&tmp);
|
| - tmp = (*src & 0xFF000000) | (tmp & 0x00FFFFFF);
|
| - if (kYes_SwapRB == kSwapRB) {
|
| - tmp = SkSwizzle_RB(tmp);
|
| - }
|
| -
|
| - *(uint32_t*)dst = tmp;
|
| -}
|
| -
|
| -static inline Sk4f linear_to_2dot2(const Sk4f& x) {
|
| - // x^(29/64) is a very good approximation of the true value, x^(1/2.2).
|
| - auto x2 = x.rsqrt(), // x^(-1/2)
|
| - x32 = x2.rsqrt().rsqrt().rsqrt().rsqrt(), // x^(-1/32)
|
| - x64 = x32.rsqrt(); // x^(+1/64)
|
| -
|
| - // 29 = 32 - 2 - 1
|
| - return 255.0f * x2.invert() * x32 * x64.invert();
|
| -}
|
| -
|
| -static inline void store_2dot2(void* dst, const uint32_t* src,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - int kRShift = 0;
|
| - int kGShift = 8;
|
| - int kBShift = 16;
|
| - if (kYes_SwapRB == kSwapRB) {
|
| - kBShift = 0;
|
| - kRShift = 16;
|
| - }
|
| -
|
| - dr = linear_to_2dot2(dr);
|
| - dg = linear_to_2dot2(dg);
|
| - db = linear_to_2dot2(db);
|
| -
|
| - dr = sk_clamp_0_255(dr);
|
| - dg = sk_clamp_0_255(dg);
|
| - db = sk_clamp_0_255(db);
|
| -
|
| - Sk4i da = Sk4i::Load(src) & 0xFF000000;
|
| -
|
| - Sk4i rgba = (Sk4f_round(dr) << kRShift)
|
| - | (Sk4f_round(dg) << kGShift)
|
| - | (Sk4f_round(db) << kBShift)
|
| - | (da );
|
| - rgba.store(dst);
|
| -}
|
| -
|
| -static inline void store_2dot2_1(void* dst, const uint32_t* src,
|
| - Sk4f& rgba, const Sk4f&,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - rgba = sk_clamp_0_255(linear_to_2dot2(rgba));
|
| -
|
| - uint32_t tmp;
|
| - SkNx_cast<uint8_t>(Sk4f_round(rgba)).store(&tmp);
|
| - tmp = (*src & 0xFF000000) | (tmp & 0x00FFFFFF);
|
| - if (kYes_SwapRB == kSwapRB) {
|
| - tmp = SkSwizzle_RB(tmp);
|
| - }
|
| -
|
| - *(uint32_t*)dst = tmp;
|
| -}
|
| -
|
| -static inline void store_f16(void* dst, const uint32_t* src,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
|
| - const uint8_t* const[3], SwapRB) {
|
| - Sk4h_store4(dst, SkFloatToHalf_finite(dr),
|
| - SkFloatToHalf_finite(dg),
|
| - SkFloatToHalf_finite(db),
|
| - SkFloatToHalf_finite(da));
|
| -}
|
| -
|
| -static inline void store_f16_1(void* dst, const uint32_t* src,
|
| - Sk4f& rgba, const Sk4f& a,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - rgba = Sk4f(rgba[0], rgba[1], rgba[2], a[3]);
|
| - SkFloatToHalf_finite(rgba).store((uint64_t*) dst);
|
| -}
|
| -
|
| -static inline void store_f16_opaque(void* dst, const uint32_t* src,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f& da,
|
| - const uint8_t* const[3], SwapRB) {
|
| - Sk4h_store4(dst, SkFloatToHalf_finite(dr),
|
| - SkFloatToHalf_finite(dg),
|
| - SkFloatToHalf_finite(db),
|
| - SK_Half1);
|
| -}
|
| -
|
| -static inline void store_f16_1_opaque(void* dst, const uint32_t* src,
|
| - Sk4f& rgba, const Sk4f& a,
|
| - const uint8_t* const[3], SwapRB kSwapRB) {
|
| - uint64_t tmp;
|
| - SkFloatToHalf_finite(rgba).store(&tmp);
|
| - tmp |= static_cast<uint64_t>(SK_Half1) << 48;
|
| - *((uint64_t*) dst) = tmp;
|
| -}
|
| -
|
| -static inline void store_generic(void* dst, const uint32_t* src,
|
| - Sk4f& dr, Sk4f& dg, Sk4f& db, Sk4f&,
|
| - const uint8_t* const dstTables[3], SwapRB kSwapRB) {
|
| - int kRShift = 0;
|
| - int kGShift = 8;
|
| - int kBShift = 16;
|
| - if (kYes_SwapRB == kSwapRB) {
|
| - kBShift = 0;
|
| - kRShift = 16;
|
| - }
|
| -
|
| - dr = Sk4f::Min(Sk4f::Max(1023.0f * dr, 0.0f), 1023.0f);
|
| - dg = Sk4f::Min(Sk4f::Max(1023.0f * dg, 0.0f), 1023.0f);
|
| - db = Sk4f::Min(Sk4f::Max(1023.0f * db, 0.0f), 1023.0f);
|
| -
|
| - Sk4i ir = Sk4f_round(dr);
|
| - Sk4i ig = Sk4f_round(dg);
|
| - Sk4i ib = Sk4f_round(db);
|
| -
|
| - Sk4i da = Sk4i::Load(src) & 0xFF000000;
|
| -
|
| - uint32_t* dst32 = (uint32_t*) dst;
|
| - dst32[0] = dstTables[0][ir[0]] << kRShift
|
| - | dstTables[1][ig[0]] << kGShift
|
| - | dstTables[2][ib[0]] << kBShift
|
| - | da[0];
|
| - dst32[1] = dstTables[0][ir[1]] << kRShift
|
| - | dstTables[1][ig[1]] << kGShift
|
| - | dstTables[2][ib[1]] << kBShift
|
| - | da[1];
|
| - dst32[2] = dstTables[0][ir[2]] << kRShift
|
| - | dstTables[1][ig[2]] << kGShift
|
| - | dstTables[2][ib[2]] << kBShift
|
| - | da[2];
|
| - dst32[3] = dstTables[0][ir[3]] << kRShift
|
| - | dstTables[1][ig[3]] << kGShift
|
| - | dstTables[2][ib[3]] << kBShift
|
| - | da[3];
|
| -}
|
| -
|
| -static inline void store_generic_1(void* dst, const uint32_t* src,
|
| - Sk4f& rgba, const Sk4f&,
|
| - const uint8_t* const dstTables[3], SwapRB kSwapRB) {
|
| - rgba = Sk4f::Min(Sk4f::Max(1023.0f * rgba, 0.0f), 1023.0f);
|
| -
|
| - Sk4i indices = Sk4f_round(rgba);
|
| -
|
| - *((uint32_t*) dst) = dstTables[0][indices[0]] << 0
|
| - | dstTables[1][indices[1]] << 8
|
| - | dstTables[2][indices[2]] << 16
|
| - | (*src & 0xFF000000);
|
| -}
|
| -
|
| -template <SkColorSpace::GammaNamed kDstGamma, SkAlphaType kAlphaType, SwapRB kSwapRB>
|
| -static void color_xform_RGBA(void* dst, const uint32_t* src, int len,
|
| - const float* const srcTables[3], const float matrix[16],
|
| - const uint8_t* const dstTables[3]) {
|
| - decltype(store_srgb )* store;
|
| - decltype(store_srgb_1 )* store_1;
|
| - decltype(load_rgb_from_tables )* load;
|
| - decltype(load_rgb_from_tables_1)* load_1;
|
| - size_t sizeOfDstPixel;
|
| - switch (kDstGamma) {
|
| - case SkColorSpace::kSRGB_GammaNamed:
|
| - load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
|
| - load_rgb_from_tables;
|
| - load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
|
| - load_rgb_from_tables_1;
|
| - store = store_srgb;
|
| - store_1 = store_srgb_1;
|
| - sizeOfDstPixel = 4;
|
| - break;
|
| - case SkColorSpace::k2Dot2Curve_GammaNamed:
|
| - load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
|
| - load_rgb_from_tables;
|
| - load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
|
| - load_rgb_from_tables_1;
|
| - store = store_2dot2;
|
| - store_1 = store_2dot2_1;
|
| - sizeOfDstPixel = 4;
|
| - break;
|
| - case SkColorSpace::kLinear_GammaNamed:
|
| - load = load_rgba_from_tables;
|
| - load_1 = load_rgba_from_tables_1;
|
| - store = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque :
|
| - store_f16;
|
| - store_1 = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_1_opaque :
|
| - store_f16_1;
|
| - sizeOfDstPixel = 8;
|
| - break;
|
| - case SkColorSpace::kNonStandard_GammaNamed:
|
| - load = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
|
| - load_rgb_from_tables;
|
| - load_1 = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
|
| - load_rgb_from_tables_1;
|
| - store = store_generic;
|
| - store_1 = store_generic_1;
|
| - sizeOfDstPixel = 4;
|
| - break;
|
| - }
|
| -
|
| - Sk4f rXgXbX, rYgYbY, rZgZbZ, rTgTbT;
|
| - load_matrix(matrix, rXgXbX, rYgYbY, rZgZbZ, rTgTbT);
|
| -
|
| - if (len >= 4) {
|
| - // Naively this would be a loop of load-transform-store, but we found it faster to
|
| - // move the N+1th load ahead of the Nth store. We don't bother doing this for N<4.
|
| - Sk4f r, g, b, a;
|
| - load(src, r, g, b, a, srcTables);
|
| - src += 4;
|
| - len -= 4;
|
| -
|
| - Sk4f dr, dg, db, da;
|
| - while (len >= 4) {
|
| - transform_gamut(r, g, b, a, rXgXbX, rYgYbY, rZgZbZ, dr, dg, db, da);
|
| - translate_gamut(rTgTbT, dr, dg, db);
|
| -
|
| - if (kPremul_SkAlphaType == kAlphaType) {
|
| - premultiply(dr, dg, db, da);
|
| - }
|
| -
|
| - load(src, r, g, b, a, srcTables);
|
| -
|
| - store(dst, src - 4, dr, dg, db, da, dstTables, kSwapRB);
|
| - dst = SkTAddOffset<void>(dst, 4 * sizeOfDstPixel);
|
| - src += 4;
|
| - len -= 4;
|
| - }
|
| -
|
| - transform_gamut(r, g, b, a, rXgXbX, rYgYbY, rZgZbZ, dr, dg, db, da);
|
| - translate_gamut(rTgTbT, dr, dg, db);
|
| -
|
| - if (kPremul_SkAlphaType == kAlphaType) {
|
| - premultiply(dr, dg, db, da);
|
| - }
|
| -
|
| - store(dst, src - 4, dr, dg, db, da, dstTables, kSwapRB);
|
| - dst = SkTAddOffset<void>(dst, 4 * sizeOfDstPixel);
|
| - }
|
| -
|
| - while (len > 0) {
|
| - Sk4f r, g, b, a;
|
| - load_1(src, r, g, b, a, srcTables);
|
| -
|
| - Sk4f rgba;
|
| - transform_gamut_1(r, g, b, rXgXbX, rYgYbY, rZgZbZ, rgba);
|
| - translate_gamut_1(rTgTbT, rgba);
|
| -
|
| - store_1(dst, src, rgba, a, dstTables, kSwapRB);
|
| -
|
| - src += 1;
|
| - len -= 1;
|
| - dst = SkTAddOffset<void>(dst, sizeOfDstPixel);
|
| - }
|
| -}
|
| -
|
| -#endif // SkColorSpaceXformOpts_DEFINED
|
|
|