/* vim: set ts=8 sw=8 noexpandtab: */ // qcms // Copyright (C) 2009 Mozilla Corporation // Copyright (C) 1998-2007 Marti Maria // // Permission is hereby granted, free of charge, to any person obtaining // a copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the Software // is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <stdlib.h> #include <math.h> #include <assert.h> #include <string.h> //memcpy #include "qcmsint.h" #include "chain.h" #include "halffloat.h" #include "matrix.h" #include "transform_util.h" #ifdef USE_LIBFUZZER #define ASSERT … #else #define ASSERT(x) … #endif /* for MSVC, GCC, Intel, and Sun compilers */ #if defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(_M_AMD64) || defined(__x86_64__) || defined(__x86_64) #define X86 #endif /* _M_IX86 || __i386__ || __i386 || _M_AMD64 || __x86_64__ || __x86_64 */ // Build a White point, primary chromas transfer matrix from RGB to CIE XYZ // This is just an approximation, I am not handling all the non-linear // aspects of the RGB to XYZ process, and assumming that the gamma correction // has transitive property in the tranformation chain. // // the alghoritm: // // - First I build the absolute conversion matrix using // primaries in XYZ. This matrix is next inverted // - Then I eval the source white point across this matrix // obtaining the coeficients of the transformation // - Then, I apply these coeficients to the original matrix static struct matrix build_RGB_to_XYZ_transfer_matrix(qcms_CIE_xyY white, qcms_CIE_xyYTRIPLE primrs) { … } struct CIE_XYZ { … }; /* CIE Illuminant D50 */ static const struct CIE_XYZ D50_XYZ = …; /* from lcms: xyY2XYZ() * corresponds to argyll: icmYxy2XYZ() */ static struct CIE_XYZ xyY2XYZ(qcms_CIE_xyY source) { … } /* from lcms: ComputeChromaticAdaption */ // Compute chromatic adaption matrix using chad as cone matrix static struct matrix compute_chromatic_adaption(struct CIE_XYZ source_white_point, struct CIE_XYZ dest_white_point, struct matrix chad) { … } /* from lcms: cmsAdaptionMatrix */ // Returns the final chrmatic adaptation from illuminant FromIll to Illuminant ToIll // Bradford is assumed static struct matrix adaption_matrix(struct CIE_XYZ source_illumination, struct CIE_XYZ target_illumination) { … } /* from lcms: cmsAdaptMatrixToD50 */ static struct matrix adapt_matrix_to_D50(struct matrix r, qcms_CIE_xyY source_white_point) { … } qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcms_CIE_xyYTRIPLE primaries) { … } #if 0 static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { const int r_out = output_format.r; const int b_out = output_format.b; int i; float (*mat)[4] = transform->matrix; for (i=0; i<length; i++) { unsigned char device_r = *src++; unsigned char device_g = *src++; unsigned char device_b = *src++; float linear_r = transform->input_gamma_table_r[device_r]; float linear_g = transform->input_gamma_table_g[device_g]; float linear_b = transform->input_gamma_table_b[device_b]; float out_linear_r = mat[0][0]*linear_r + mat[1][0]*linear_g + mat[2][0]*linear_b; float out_linear_g = mat[0][1]*linear_r + mat[1][1]*linear_g + mat[2][1]*linear_b; float out_linear_b = mat[0][2]*linear_r + mat[1][2]*linear_g + mat[2][2]*linear_b; float out_device_r = pow(out_linear_r, transform->out_gamma_r); float out_device_g = pow(out_linear_g, transform->out_gamma_g); float out_device_b = pow(out_linear_b, transform->out_gamma_b); dest[r_out] = clamp_u8(out_device_r*255); dest[1] = clamp_u8(out_device_g*255); dest[b_out] = clamp_u8(out_device_b*255); dest += 3; } } #endif static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } /* Alpha is not corrected. A rationale for this is found in Alvy Ray's "Should Alpha Be Nonlinear If RGB Is?" Tech Memo 17 (December 14, 1998). See: ftp://ftp.alvyray.com/Acrobat/17_Nonln.pdf */ static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } static void qcms_transform_data_gray_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } static void qcms_transform_data_graya_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } // Not used /* static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { const int r_out = output_format.r; const int b_out = output_format.b; unsigned int i; int xy_len = 1; int x_len = transform->grid_size; int len = x_len * x_len; float* r_table = transform->r_clut; float* g_table = transform->g_clut; float* b_table = transform->b_clut; for (i = 0; i < length; i++) { unsigned char in_r = *src++; unsigned char in_g = *src++; unsigned char in_b = *src++; float linear_r = in_r/255.0f, linear_g=in_g/255.0f, linear_b = in_b/255.0f; int x = floor(linear_r * (transform->grid_size-1)); int y = floor(linear_g * (transform->grid_size-1)); int z = floor(linear_b * (transform->grid_size-1)); int x_n = ceil(linear_r * (transform->grid_size-1)); int y_n = ceil(linear_g * (transform->grid_size-1)); int z_n = ceil(linear_b * (transform->grid_size-1)); float x_d = linear_r * (transform->grid_size-1) - x; float y_d = linear_g * (transform->grid_size-1) - y; float z_d = linear_b * (transform->grid_size-1) - z; float r_x1 = lerp(CLU(r_table,x,y,z), CLU(r_table,x_n,y,z), x_d); float r_x2 = lerp(CLU(r_table,x,y_n,z), CLU(r_table,x_n,y_n,z), x_d); float r_y1 = lerp(r_x1, r_x2, y_d); float r_x3 = lerp(CLU(r_table,x,y,z_n), CLU(r_table,x_n,y,z_n), x_d); float r_x4 = lerp(CLU(r_table,x,y_n,z_n), CLU(r_table,x_n,y_n,z_n), x_d); float r_y2 = lerp(r_x3, r_x4, y_d); float clut_r = lerp(r_y1, r_y2, z_d); float g_x1 = lerp(CLU(g_table,x,y,z), CLU(g_table,x_n,y,z), x_d); float g_x2 = lerp(CLU(g_table,x,y_n,z), CLU(g_table,x_n,y_n,z), x_d); float g_y1 = lerp(g_x1, g_x2, y_d); float g_x3 = lerp(CLU(g_table,x,y,z_n), CLU(g_table,x_n,y,z_n), x_d); float g_x4 = lerp(CLU(g_table,x,y_n,z_n), CLU(g_table,x_n,y_n,z_n), x_d); float g_y2 = lerp(g_x3, g_x4, y_d); float clut_g = lerp(g_y1, g_y2, z_d); float b_x1 = lerp(CLU(b_table,x,y,z), CLU(b_table,x_n,y,z), x_d); float b_x2 = lerp(CLU(b_table,x,y_n,z), CLU(b_table,x_n,y_n,z), x_d); float b_y1 = lerp(b_x1, b_x2, y_d); float b_x3 = lerp(CLU(b_table,x,y,z_n), CLU(b_table,x_n,y,z_n), x_d); float b_x4 = lerp(CLU(b_table,x,y_n,z_n), CLU(b_table,x_n,y_n,z_n), x_d); float b_y2 = lerp(b_x3, b_x4, y_d); float clut_b = lerp(b_y1, b_y2, z_d); dest[r_out] = clamp_u8(clut_r*255.0f); dest[1] = clamp_u8(clut_g*255.0f); dest[b_out] = clamp_u8(clut_b*255.0f); dest += 3; } } */ // Using lcms' tetra interpolation algorithm. void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } // Using lcms' tetra interpolation code. static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { … } #if 0 static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) { const int r_out = output_format.r; const int b_out = output_format.b; int i; float (*mat)[4] = transform->matrix; for (i = 0; i < length; i++) { unsigned char device_r = *src++; unsigned char device_g = *src++; unsigned char device_b = *src++; float linear_r = transform->input_gamma_table_r[device_r]; float linear_g = transform->input_gamma_table_g[device_g]; float linear_b = transform->input_gamma_table_b[device_b]; float out_linear_r = mat[0][0]*linear_r + mat[1][0]*linear_g + mat[2][0]*linear_b; float out_linear_g = mat[0][1]*linear_r + mat[1][1]*linear_g + mat[2][1]*linear_b; float out_linear_b = mat[0][2]*linear_r + mat[1][2]*linear_g + mat[2][2]*linear_b; dest[r_out] = clamp_u8(out_linear_r*255); dest[1] = clamp_u8(out_linear_g*255); dest[b_out] = clamp_u8(out_linear_b*255); dest += 3; } } #endif /* * If users create and destroy objects on different threads, even if the same * objects aren't used on different threads at the same time, we can still run * in to trouble with refcounts if they aren't atomic. * * This can lead to us prematurely deleting the precache if threads get unlucky * and write the wrong value to the ref count. */ static struct precache_output *precache_reference(struct precache_output *p) { … } static struct precache_output *precache_create() { … } void precache_release(struct precache_output *p) { … } #ifdef HAVE_POSIX_MEMALIGN static qcms_transform *transform_alloc(void) { qcms_transform *t; if (!posix_memalign(&t, 16, sizeof(*t))) { return t; } else { return NULL; } } static void transform_free(qcms_transform *t) { free(t); } #else static qcms_transform *transform_alloc(void) { … } static void transform_free(qcms_transform *t) { … } #endif void qcms_transform_release(qcms_transform *t) { … } #ifdef X86 // Determine if we can build with SSE2 (this was partly copied from jmorecfg.h in // mozilla/jpeg) // ------------------------------------------------------------------------- #if defined(_M_IX86) && defined(_MSC_VER) #define HAS_CPUID /* Get us a CPUID function. Avoid clobbering EBX because sometimes it's the PIC register - I'm not sure if that ever happens on windows, but cpuid isn't on the critical path so we just preserve the register to be safe and to be consistent with the non-windows version. */ static void cpuid(uint32_t fxn, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d) { uint32_t a_, b_, c_, d_; __asm { xchg ebx, esi mov eax, fxn cpuid mov a_, eax mov b_, ebx mov c_, ecx mov d_, edx xchg ebx, esi } *a = a_; *b = b_; *c = c_; *d = d_; } #elif (defined(__GNUC__) || defined(__SUNPRO_C)) && (defined(__i386__) || defined(__i386)) #define HAS_CPUID /* Get us a CPUID function. We can't use ebx because it's the PIC register on some platforms, so we use ESI instead and save ebx to avoid clobbering it. */ static void cpuid(uint32_t fxn, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d) { uint32_t a_, b_, c_, d_; __asm__ __volatile__ ("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi;" : "=a" (a_), "=S" (b_), "=c" (c_), "=d" (d_) : "a" (fxn)); *a = a_; *b = b_; *c = c_; *d = d_; } #endif // -------------------------Runtime SSEx Detection----------------------------- /* MMX is always supported per * Gecko v1.9.1 minimum CPU requirements */ #define SSE1_EDX_MASK … #define SSE2_EDX_MASK … #define SSE3_ECX_MASK … static int sse_version_available(void) { … } #endif static const struct matrix bradford_matrix = …; static const struct matrix bradford_matrix_inv = …; // See ICCv4 E.3 struct matrix compute_whitepoint_adaption(float X, float Y, float Z) { … } void qcms_profile_precache_output_transform(qcms_profile *profile) { … } /* Replace the current transformation with a LUT transformation using a given number of sample points */ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms_profile *in, qcms_profile *out, int samples, qcms_data_type in_type) { … } /* Create a transform LUT using the given number of sample points. The transform LUT data is stored in the output (cube) in bgra format in zyx sample order. */ qcms_bool qcms_transform_create_LUT_zyx_bgra(qcms_profile *in, qcms_profile *out, qcms_intent intent, int samples, unsigned char* cube) { … } void qcms_transform_build_clut_cache(qcms_transform* transform) { … } #define NO_MEM_TRANSFORM … qcms_transform* qcms_transform_create( qcms_profile *in, qcms_data_type in_type, qcms_profile *out, qcms_data_type out_type, qcms_intent intent) { … } /* __force_align_arg_pointer__ is an x86-only attribute, and gcc/clang warns on unused * attributes. Don't use this on ARM or AMD64. __has_attribute can detect the presence * of the attribute but is currently only supported by clang */ #if defined(__has_attribute) #define HAS_FORCE_ALIGN_ARG_POINTER … #elif defined(__GNUC__) && defined(__i386__) #define HAS_FORCE_ALIGN_ARG_POINTER … #else #define HAS_FORCE_ALIGN_ARG_POINTER … #endif #if HAS_FORCE_ALIGN_ARG_POINTER /* we need this to avoid crashes when gcc assumes the stack is 128bit aligned */ __attribute__((__force_align_arg_pointer__)) #endif void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length) { … } void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type) { … } #define ENABLE_ICC_V4_PROFILE_SUPPORT … qcms_bool qcms_supports_iccv4 = …; void qcms_enable_iccv4() { … } static inline qcms_bool transform_is_matrix(qcms_transform *t) { … } qcms_bool qcms_transform_is_matrix(qcms_transform *t) { … } float qcms_transform_get_matrix(qcms_transform *t, unsigned i, unsigned j) { … } static inline qcms_bool supported_trc_type(qcms_trc_type type) { … } const uint16_t half_float_one = …; size_t qcms_transform_get_input_trc_rgba(qcms_transform *t, qcms_profile *in, qcms_trc_type type, unsigned short *data) { … } const float inverse65535 = …; size_t qcms_transform_get_output_trc_rgba(qcms_transform *t, qcms_profile *out, qcms_trc_type type, unsigned short *data) { … }
Codebase Browser
chromium