/* * Copyright 2018 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #include "src/skcms_public.h" // NO_G3_REWRITE #include "src/skcms_internals.h" // NO_G3_REWRITE #include "src/skcms_Transform.h" // NO_G3_REWRITE #include <assert.h> #include <float.h> #include <limits.h> #include <stdlib.h> #include <string.h> #if defined(__ARM_NEON) #include <arm_neon.h> #elif defined(__SSE__) #include <immintrin.h> #if defined(__clang__) // That #include <immintrin.h> is usually enough, but Clang's headers // "helpfully" skip including the whole kitchen sink when _MSC_VER is // defined, because lots of programs on Windows would include that and // it'd be a lot slower. But we want all those headers included so we // can use their features after runtime checks later. #include <smmintrin.h> #include <avxintrin.h> #include <avx2intrin.h> #include <avx512fintrin.h> #include <avx512dqintrin.h> #endif #endif usingnamespaceskcms_private; static bool sAllowRuntimeCPUDetection = …; void skcms_DisableRuntimeCPUDetection() { … } static float log2f_(float x) { … } static float logf_(float x) { … } static float exp2f_(float x) { … } // Not static, as it's used by some test tools. float powf_(float x, float y) { … } static float expf_(float x) { … } static float fmaxf_(float x, float y) { … } static float fminf_(float x, float y) { … } static bool isfinitef_(float x) { … } static float minus_1_ulp(float x) { … } // Most transfer functions we work with are sRGBish. // For exotic HDR transfer functions, we encode them using a tf.g that makes no sense, // and repurpose the other fields to hold the parameters of the HDR functions. struct TF_PQish { … }; struct TF_HLGish { … }; // We didn't originally support a scale factor K for HLG, and instead just stored 0 in // the unused `f` field of skcms_TransferFunction for HLGish and HLGInvish transfer functions. // By storing f=K-1, those old unusued f=0 values now mean K=1, a noop scale factor. static float TFKind_marker(skcms_TFType kind) { … } static skcms_TFType classify(const skcms_TransferFunction& tf, TF_PQish* pq = nullptr , TF_HLGish* hlg = nullptr) { … } skcms_TFType skcms_TransferFunction_getType(const skcms_TransferFunction* tf) { … } bool skcms_TransferFunction_isSRGBish(const skcms_TransferFunction* tf) { … } bool skcms_TransferFunction_isPQish(const skcms_TransferFunction* tf) { … } bool skcms_TransferFunction_isHLGish(const skcms_TransferFunction* tf) { … } bool skcms_TransferFunction_makePQish(skcms_TransferFunction* tf, float A, float B, float C, float D, float E, float F) { … } bool skcms_TransferFunction_makeScaledHLGish(skcms_TransferFunction* tf, float K, float R, float G, float a, float b, float c) { … } float skcms_TransferFunction_eval(const skcms_TransferFunction* tf, float x) { … } static float eval_curve(const skcms_Curve* curve, float x) { … } float skcms_MaxRoundtripError(const skcms_Curve* curve, const skcms_TransferFunction* inv_tf) { … } bool skcms_AreApproximateInverses(const skcms_Curve* curve, const skcms_TransferFunction* inv_tf) { … } // Additional ICC signature values that are only used internally enum { … }; static uint16_t read_big_u16(const uint8_t* ptr) { … } static uint32_t read_big_u32(const uint8_t* ptr) { … } static int32_t read_big_i32(const uint8_t* ptr) { … } static float read_big_fixed(const uint8_t* ptr) { … } // Maps to an in-memory profile so that fields line up to the locations specified // in ICC.1:2010, section 7.2 header_Layout; tag_Layout; static const tag_Layout* get_tag_table(const skcms_ICCProfile* profile) { … } // s15Fixed16ArrayType is technically variable sized, holding N values. However, the only valid // use of the type is for the CHAD tag that stores exactly nine values. sf32_Layout; bool skcms_GetCHAD(const skcms_ICCProfile* profile, skcms_Matrix3x3* m) { … } // XYZType is technically variable sized, holding N XYZ triples. However, the only valid uses of // the type are for tags/data that store exactly one triple. XYZ_Layout; static bool read_tag_xyz(const skcms_ICCTag* tag, float* x, float* y, float* z) { … } bool skcms_GetWTPT(const skcms_ICCProfile* profile, float xyz[3]) { … } static int data_color_space_channel_count(uint32_t data_color_space) { … } int skcms_GetInputChannelCount(const skcms_ICCProfile* profile) { … } static bool read_to_XYZD50(const skcms_ICCTag* rXYZ, const skcms_ICCTag* gXYZ, const skcms_ICCTag* bXYZ, skcms_Matrix3x3* toXYZ) { … } para_Layout; static bool read_curve_para(const uint8_t* buf, uint32_t size, skcms_Curve* curve, uint32_t* curve_size) { … } curv_Layout; static bool read_curve_curv(const uint8_t* buf, uint32_t size, skcms_Curve* curve, uint32_t* curve_size) { … } // Parses both curveType and parametricCurveType data. Ensures that at most 'size' bytes are read. // If curve_size is not nullptr, writes the number of bytes used by the curve in (*curve_size). static bool read_curve(const uint8_t* buf, uint32_t size, skcms_Curve* curve, uint32_t* curve_size) { … } // mft1 and mft2 share a large chunk of data mft_CommonLayout; mft1_Layout; mft2_Layout; static bool read_mft_common(const mft_CommonLayout* mftTag, skcms_A2B* a2b) { … } // All as the A2B version above, except where noted. static bool read_mft_common(const mft_CommonLayout* mftTag, skcms_B2A* b2a) { … } template <typename A2B_or_B2A> static bool init_tables(const uint8_t* table_base, uint64_t max_tables_len, uint32_t byte_width, uint32_t input_table_entries, uint32_t output_table_entries, A2B_or_B2A* out) { … } template <typename A2B_or_B2A> static bool read_tag_mft1(const skcms_ICCTag* tag, A2B_or_B2A* out) { … } template <typename A2B_or_B2A> static bool read_tag_mft2(const skcms_ICCTag* tag, A2B_or_B2A* out) { … } static bool read_curves(const uint8_t* buf, uint32_t size, uint32_t curve_offset, uint32_t num_curves, skcms_Curve* curves) { … } // mAB and mBA tags use the same encoding, including color lookup tables. mAB_or_mBA_Layout; CLUT_Layout; static bool read_tag_mab(const skcms_ICCTag* tag, skcms_A2B* a2b, bool pcs_is_xyz) { … } // Exactly the same as read_tag_mab(), except where there are comments. // TODO: refactor the two to eliminate common code? static bool read_tag_mba(const skcms_ICCTag* tag, skcms_B2A* b2a, bool pcs_is_xyz) { … } // If you pass f, we'll fit a possibly-non-zero value for *f. // If you pass nullptr, we'll assume you want *f to be treated as zero. static int fit_linear(const skcms_Curve* curve, int N, float tol, float* c, float* d, float* f = nullptr) { … } // If this skcms_Curve holds an identity table, rewrite it as an identity skcms_TransferFunction. static void canonicalize_identity(skcms_Curve* curve) { … } static bool read_a2b(const skcms_ICCTag* tag, skcms_A2B* a2b, bool pcs_is_xyz) { … } static bool read_b2a(const skcms_ICCTag* tag, skcms_B2A* b2a, bool pcs_is_xyz) { … } CICP_Layout; static bool read_cicp(const skcms_ICCTag* tag, skcms_CICP* cicp) { … } void skcms_GetTagByIndex(const skcms_ICCProfile* profile, uint32_t idx, skcms_ICCTag* tag) { … } bool skcms_GetTagBySignature(const skcms_ICCProfile* profile, uint32_t sig, skcms_ICCTag* tag) { … } static bool usable_as_src(const skcms_ICCProfile* profile) { … } bool skcms_ParseWithA2BPriority(const void* buf, size_t len, const int priority[], const int priorities, skcms_ICCProfile* profile) { … } const skcms_ICCProfile* skcms_sRGB_profile() { … } const skcms_ICCProfile* skcms_XYZD50_profile() { … } const skcms_TransferFunction* skcms_sRGB_TransferFunction() { … } const skcms_TransferFunction* skcms_sRGB_Inverse_TransferFunction() { … } const skcms_TransferFunction* skcms_Identity_TransferFunction() { … } const uint8_t skcms_252_random_bytes[] = …; bool skcms_ApproximatelyEqualProfiles(const skcms_ICCProfile* A, const skcms_ICCProfile* B) { … } bool skcms_TRCs_AreApproximateInverse(const skcms_ICCProfile* profile, const skcms_TransferFunction* inv_tf) { … } static bool is_zero_to_one(float x) { … } skcms_Vector3; static skcms_Vector3 mv_mul(const skcms_Matrix3x3* m, const skcms_Vector3* v) { … } bool skcms_AdaptToXYZD50(float wx, float wy, skcms_Matrix3x3* toXYZD50) { … } bool skcms_PrimariesToXYZD50(float rx, float ry, float gx, float gy, float bx, float by, float wx, float wy, skcms_Matrix3x3* toXYZD50) { … } bool skcms_Matrix3x3_invert(const skcms_Matrix3x3* src, skcms_Matrix3x3* dst) { … } skcms_Matrix3x3 skcms_Matrix3x3_concat(const skcms_Matrix3x3* A, const skcms_Matrix3x3* B) { … } #if defined(__clang__) [[clang::no_sanitize("float-divide-by-zero")]] // Checked for by classify() on the way out. #endif bool skcms_TransferFunction_invert(const skcms_TransferFunction* src, skcms_TransferFunction* dst) { … } // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // From here below we're approximating an skcms_Curve with an skcms_TransferFunction{g,a,b,c,d,e,f}: // // tf(x) = cx + f x < d // tf(x) = (ax + b)^g + e x ≥ d // // When fitting, we add the additional constraint that both pieces meet at d: // // cd + f = (ad + b)^g + e // // Solving for e and folding it through gives an alternate formulation of the non-linear piece: // // tf(x) = cx + f x < d // tf(x) = (ax + b)^g - (ad + b)^g + cd + f x ≥ d // // Our overall strategy is then: // For a couple tolerances, // - fit_linear(): fit c,d,f iteratively to as many points as our tolerance allows // - invert c,d,f // - fit_nonlinear(): fit g,a,b using Gauss-Newton given those inverted c,d,f // (and by constraint, inverted e) to the inverse of the table. // Return the parameters with least maximum error. // // To run Gauss-Newton to find g,a,b, we'll also need the gradient of the residuals // of round-trip f_inv(x), the inverse of the non-linear piece of f(x). // // let y = Table(x) // r(x) = x - f_inv(y) // // ∂r/∂g = ln(ay + b)*(ay + b)^g // - ln(ad + b)*(ad + b)^g // ∂r/∂a = yg(ay + b)^(g-1) // - dg(ad + b)^(g-1) // ∂r/∂b = g(ay + b)^(g-1) // - g(ad + b)^(g-1) // Return the residual of roundtripping skcms_Curve(x) through f_inv(y) with parameters P, // and fill out the gradient of the residual into dfdP. static float rg_nonlinear(float x, const skcms_Curve* curve, const skcms_TransferFunction* tf, float dfdP[3]) { … } static bool gauss_newton_step(const skcms_Curve* curve, skcms_TransferFunction* tf, float x0, float dx, int N) { … } static float max_roundtrip_error_checked(const skcms_Curve* curve, const skcms_TransferFunction* tf_inv) { … } // Fit the points in [L,N) to the non-linear piece of tf, or return false if we can't. static bool fit_nonlinear(const skcms_Curve* curve, int L, int N, skcms_TransferFunction* tf) { … } bool skcms_ApproximateCurve(const skcms_Curve* curve, skcms_TransferFunction* approx, float* max_error) { … } enum class CpuType { … }; static CpuType cpu_type() { … } static bool tf_is_gamma(const skcms_TransferFunction& tf) { … } struct OpAndArg { … }; static OpAndArg select_curve_op(const skcms_Curve* curve, int channel) { … } static int select_curve_ops(const skcms_Curve* curves, int numChannels, OpAndArg* ops) { … } static size_t bytes_per_pixel(skcms_PixelFormat fmt) { … } static bool prep_for_destination(const skcms_ICCProfile* profile, skcms_Matrix3x3* fromXYZD50, skcms_TransferFunction* invR, skcms_TransferFunction* invG, skcms_TransferFunction* invB) { … } bool skcms_Transform(const void* src, skcms_PixelFormat srcFmt, skcms_AlphaFormat srcAlpha, const skcms_ICCProfile* srcProfile, void* dst, skcms_PixelFormat dstFmt, skcms_AlphaFormat dstAlpha, const skcms_ICCProfile* dstProfile, size_t nz) { … } static void assert_usable_as_destination(const skcms_ICCProfile* profile) { … } bool skcms_MakeUsableAsDestination(skcms_ICCProfile* profile) { … } bool skcms_MakeUsableAsDestinationWithSingleCurve(skcms_ICCProfile* profile) { … }
Codebase Browser
chromium