1 diff --git a/third_party/qcms/src/iccread.c b/third_party/qcms/src/iccread.c 2 index 36b7011..9ee6b94 100644 3 --- a/third_party/qcms/src/iccread.c 4 +++ b/third_party/qcms/src/iccread.c 5 @@ -266,7 +266,7 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile) 6 if (profile->color_space != RGB_SIGNATURE) 7 return false; 8 9 - if (profile->A2B0 || profile->B2A0) 10 + if (qcms_supports_iccv4 && (profile->A2B0 || profile->B2A0)) 11 return false; 12 13 rX = s15Fixed16Number_to_float(profile->redColorant.X); 14 @@ -297,6 +297,11 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile) 15 sum[1] = rY + gY + bY; 16 sum[2] = rZ + gZ + bZ; 17 18 +#if defined (_MSC_VER) 19 +#pragma warning(push) 20 +/* Disable double to float truncation warning 4305 */ 21 +#pragma warning(disable:4305) 22 +#endif 23 // Build our target vector (see mozilla bug 460629) 24 target[0] = 0.96420; 25 target[1] = 1.00000; 26 @@ -310,6 +315,10 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile) 27 tolerance[1] = 0.02; 28 tolerance[2] = 0.04; 29 30 +#if defined (_MSC_VER) 31 +/* Restore warnings */ 32 +#pragma warning(pop) 33 +#endif 34 // Compare with our tolerance 35 for (i = 0; i < 3; ++i) { 36 if (!(((sum[i] - tolerance[i]) <= target[i]) && 37 @@ -402,7 +411,7 @@ static struct XYZNumber read_tag_XYZType(struct mem_source *src, struct tag_inde 38 // present that are not part of the tag_index. 39 static struct curveType *read_curveType(struct mem_source *src, uint32_t offset, uint32_t *len) 40 { 41 - static const size_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7}; 42 + static const uint32_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7}; 43 struct curveType *curve = NULL; 44 uint32_t type = read_u32(src, offset); 45 uint32_t count; 46 @@ -657,7 +666,7 @@ static struct lutType *read_tag_lutType(struct mem_source *src, struct tag_index 47 uint16_t num_input_table_entries; 48 uint16_t num_output_table_entries; 49 uint8_t in_chan, grid_points, out_chan; 50 - uint32_t clut_offset, output_offset; 51 + size_t clut_offset, output_offset; 52 uint32_t clut_size; 53 size_t entry_size; 54 struct lutType *lut; 55 @@ -997,6 +1006,9 @@ qcms_profile* qcms_profile_from_memory(const void *mem, size_t size) 56 source.size = size; 57 source.valid = true; 58 59 + if (size < 4) 60 + return INVALID_PROFILE; 61 + 62 length = read_u32(src, 0); 63 if (length <= size) { 64 // shrink the area that we can read if appropriate 65 diff --git a/third_party/qcms/src/qcms.h b/third_party/qcms/src/qcms.h 66 index 7d83623..11fe222 100644 67 --- a/third_party/qcms/src/qcms.h 68 +++ b/third_party/qcms/src/qcms.h 69 @@ -40,6 +40,12 @@ sale, use or other dealings in this Software without written 70 authorization from SunSoft Inc. 71 ******************************************************************/ 72 73 +/* 74 + * QCMS, in general, is not threadsafe. However, it should be safe to create 75 + * profile and transformation objects on different threads, so long as you 76 + * don't use the same objects on different threads at the same time. 77 + */ 78 + 79 /* 80 * Color Space Signatures 81 * Note that only icSigXYZData and icSigLabData are valid 82 @@ -102,6 +108,12 @@ typedef enum { 83 QCMS_DATA_GRAYA_8 84 } qcms_data_type; 85 86 +/* Format of the output data for qcms_transform_data_type() */ 87 +typedef enum { 88 + QCMS_OUTPUT_RGBX, 89 + QCMS_OUTPUT_BGRX 90 +} qcms_output_type; 91 + 92 /* the names for the following two types are sort of ugly */ 93 typedef struct 94 { 95 @@ -146,6 +158,7 @@ qcms_transform* qcms_transform_create( 96 void qcms_transform_release(qcms_transform *); 97 98 void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length); 99 +void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type); 100 101 void qcms_enable_iccv4(); 102 103 diff --git a/third_party/qcms/src/qcmsint.h b/third_party/qcms/src/qcmsint.h 104 index 53a3420..fb53e96 100644 105 --- a/third_party/qcms/src/qcmsint.h 106 +++ b/third_party/qcms/src/qcmsint.h 107 @@ -45,6 +45,11 @@ struct precache_output 108 #define ALIGN __attribute__(( aligned (16) )) 109 #endif 110 111 +typedef struct _qcms_format_type { 112 + int r; 113 + int b; 114 +} qcms_format_type; 115 + 116 struct _qcms_transform { 117 float ALIGN matrix[3][4]; 118 float *input_gamma_table_r; 119 @@ -88,7 +93,7 @@ struct _qcms_transform { 120 struct precache_output *output_table_g; 121 struct precache_output *output_table_b; 122 123 - void (*transform_fn)(struct _qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length); 124 + void (*transform_fn)(struct _qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, struct _qcms_format_type output_format); 125 }; 126 127 struct matrix { 128 @@ -280,18 +285,40 @@ qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcm 129 void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform, 130 unsigned char *src, 131 unsigned char *dest, 132 - size_t length); 133 + size_t length, 134 + qcms_format_type output_format); 135 void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform, 136 unsigned char *src, 137 unsigned char *dest, 138 - size_t length); 139 + size_t length, 140 + qcms_format_type output_format); 141 void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 142 unsigned char *src, 143 unsigned char *dest, 144 - size_t length); 145 + size_t length, 146 + qcms_format_type output_format); 147 void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform, 148 unsigned char *src, 149 unsigned char *dest, 150 - size_t length); 151 + size_t length, 152 + qcms_format_type output_format); 153 154 extern qcms_bool qcms_supports_iccv4; 155 + 156 + 157 +#ifdef _MSC_VER 158 + 159 +long __cdecl _InterlockedIncrement(long volatile *); 160 +long __cdecl _InterlockedDecrement(long volatile *); 161 +#pragma intrinsic(_InterlockedIncrement) 162 +#pragma intrinsic(_InterlockedDecrement) 163 + 164 +#define qcms_atomic_increment(x) _InterlockedIncrement((long volatile *)&x) 165 +#define qcms_atomic_decrement(x) _InterlockedDecrement((long volatile*)&x) 166 + 167 +#else 168 + 169 +#define qcms_atomic_increment(x) __sync_add_and_fetch(&x, 1) 170 +#define qcms_atomic_decrement(x) __sync_sub_and_fetch(&x, 1) 171 + 172 +#endif 173 diff --git a/third_party/qcms/src/qcmstypes.h b/third_party/qcms/src/qcmstypes.h 174 index 56d8de3..d58f691 100644 175 --- a/third_party/qcms/src/qcmstypes.h 176 +++ b/third_party/qcms/src/qcmstypes.h 177 @@ -22,37 +22,6 @@ 178 #ifndef QCMS_TYPES_H 179 #define QCMS_TYPES_H 180 181 -#ifdef MOZ_QCMS 182 - 183 -#include "prtypes.h" 184 - 185 -/* prtypes.h defines IS_LITTLE_ENDIAN and IS_BIG ENDIAN */ 186 - 187 -#if defined (__SVR4) && defined (__sun) 188 -/* int_types.h gets included somehow, so avoid redefining the types differently */ 189 -#include <sys/int_types.h> 190 -#elif defined (_AIX) 191 -#include <sys/types.h> 192 -#elif !defined(ANDROID) && !defined(__OpenBSD__) 193 -typedef PRInt8 int8_t; 194 -typedef PRUint8 uint8_t; 195 -typedef PRInt16 int16_t; 196 -typedef PRUint16 uint16_t; 197 -typedef PRInt32 int32_t; 198 -typedef PRUint32 uint32_t; 199 -typedef PRInt64 int64_t; 200 -typedef PRUint64 uint64_t; 201 - 202 -#ifdef __OS2__ 203 -/* OS/2's stdlib typdefs uintptr_t. So we'll just include that so we don't collide */ 204 -#include <stdlib.h> 205 -#elif !defined(__intptr_t_defined) && !defined(_UINTPTR_T_DEFINED) 206 -typedef PRUptrdiff uintptr_t; 207 -#endif 208 -#endif 209 - 210 -#else // MOZ_QCMS 211 - 212 #if BYTE_ORDER == LITTLE_ENDIAN 213 #define IS_LITTLE_ENDIAN 214 #elif BYTE_ORDER == BIG_ENDIAN 215 @@ -75,7 +44,7 @@ typedef PRUptrdiff uintptr_t; 216 217 #if defined (_SVR4) || defined (SVR4) || defined (__OpenBSD__) || defined (_sgi) || defined (__sun) || defined (sun) || defined (__digital__) 218 # include <inttypes.h> 219 -#elif defined (_MSC_VER) 220 +#elif defined (_MSC_VER) && _MSC_VER < 1600 221 typedef __int8 int8_t; 222 typedef unsigned __int8 uint8_t; 223 typedef __int16 int16_t; 224 @@ -87,7 +56,12 @@ typedef unsigned __int64 uint64_t; 225 #ifdef _WIN64 226 typedef unsigned __int64 uintptr_t; 227 #else 228 +#pragma warning(push) 229 +/* Disable benign redefinition of type warning 4142 */ 230 +#pragma warning(disable:4142) 231 typedef unsigned long uintptr_t; 232 +/* Restore warnings */ 233 +#pragma warning(pop) 234 #endif 235 236 #elif defined (_AIX) 237 @@ -96,8 +70,6 @@ typedef unsigned long uintptr_t; 238 # include <stdint.h> 239 #endif 240 241 -#endif 242 - 243 typedef qcms_bool bool; 244 #define true 1 245 #define false 0 246 diff --git a/third_party/qcms/src/transform-sse1.c b/third_party/qcms/src/transform-sse1.c 247 index 2f34db5..aaee1bf 100644 248 --- a/third_party/qcms/src/transform-sse1.c 249 +++ b/third_party/qcms/src/transform-sse1.c 250 @@ -34,7 +34,8 @@ static const ALIGN float clampMaxValueX4[4] = 251 void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 252 unsigned char *src, 253 unsigned char *dest, 254 - size_t length) 255 + size_t length, 256 + qcms_format_type output_format) 257 { 258 unsigned int i; 259 float (*mat)[4] = transform->matrix; 260 @@ -70,6 +71,8 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 261 262 /* working variables */ 263 __m128 vec_r, vec_g, vec_b, result; 264 + const int r_out = output_format.r; 265 + const int b_out = output_format.b; 266 267 /* CYA */ 268 if (!length) 269 @@ -116,9 +119,9 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 270 src += 3; 271 272 /* use calc'd indices to output RGB values */ 273 - dest[0] = otdata_r[output[0]]; 274 - dest[1] = otdata_g[output[1]]; 275 - dest[2] = otdata_b[output[2]]; 276 + dest[r_out] = otdata_r[output[0]]; 277 + dest[1] = otdata_g[output[1]]; 278 + dest[b_out] = otdata_b[output[2]]; 279 dest += 3; 280 } 281 282 @@ -141,9 +144,9 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 283 result = _mm_movehl_ps(result, result); 284 *((__m64 *)&output[2]) = _mm_cvtps_pi32(result); 285 286 - dest[0] = otdata_r[output[0]]; 287 - dest[1] = otdata_g[output[1]]; 288 - dest[2] = otdata_b[output[2]]; 289 + dest[r_out] = otdata_r[output[0]]; 290 + dest[1] = otdata_g[output[1]]; 291 + dest[b_out] = otdata_b[output[2]]; 292 293 _mm_empty(); 294 } 295 @@ -151,7 +154,8 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform, 296 void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform, 297 unsigned char *src, 298 unsigned char *dest, 299 - size_t length) 300 + size_t length, 301 + qcms_format_type output_format) 302 { 303 unsigned int i; 304 float (*mat)[4] = transform->matrix; 305 @@ -187,6 +191,8 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform, 306 307 /* working variables */ 308 __m128 vec_r, vec_g, vec_b, result; 309 + const int r_out = output_format.r; 310 + const int b_out = output_format.b; 311 unsigned char alpha; 312 313 /* CYA */ 314 @@ -239,9 +245,9 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform, 315 src += 4; 316 317 /* use calc'd indices to output RGB values */ 318 - dest[0] = otdata_r[output[0]]; 319 - dest[1] = otdata_g[output[1]]; 320 - dest[2] = otdata_b[output[2]]; 321 + dest[r_out] = otdata_r[output[0]]; 322 + dest[1] = otdata_g[output[1]]; 323 + dest[b_out] = otdata_b[output[2]]; 324 dest += 4; 325 } 326 327 @@ -266,9 +272,9 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform, 328 result = _mm_movehl_ps(result, result); 329 *((__m64 *)&output[2]) = _mm_cvtps_pi32(result); 330 331 - dest[0] = otdata_r[output[0]]; 332 - dest[1] = otdata_g[output[1]]; 333 - dest[2] = otdata_b[output[2]]; 334 + dest[r_out] = otdata_r[output[0]]; 335 + dest[1] = otdata_g[output[1]]; 336 + dest[b_out] = otdata_b[output[2]]; 337 338 _mm_empty(); 339 } 340 diff --git a/third_party/qcms/src/transform-sse2.c b/third_party/qcms/src/transform-sse2.c 341 index 6a5faf9..fa7f2d1 100644 342 --- a/third_party/qcms/src/transform-sse2.c 343 +++ b/third_party/qcms/src/transform-sse2.c 344 @@ -34,7 +34,8 @@ static const ALIGN float clampMaxValueX4[4] = 345 void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform, 346 unsigned char *src, 347 unsigned char *dest, 348 - size_t length) 349 + size_t length, 350 + qcms_format_type output_format) 351 { 352 unsigned int i; 353 float (*mat)[4] = transform->matrix; 354 @@ -70,6 +71,8 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform, 355 356 /* working variables */ 357 __m128 vec_r, vec_g, vec_b, result; 358 + const int r_out = output_format.r; 359 + const int b_out = output_format.b; 360 361 /* CYA */ 362 if (!length) 363 @@ -114,9 +117,9 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform, 364 src += 3; 365 366 /* use calc'd indices to output RGB values */ 367 - dest[0] = otdata_r[output[0]]; 368 - dest[1] = otdata_g[output[1]]; 369 - dest[2] = otdata_b[output[2]]; 370 + dest[r_out] = otdata_r[output[0]]; 371 + dest[1] = otdata_g[output[1]]; 372 + dest[b_out] = otdata_b[output[2]]; 373 dest += 3; 374 } 375 376 @@ -137,15 +140,16 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform, 377 378 _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result)); 379 380 - dest[0] = otdata_r[output[0]]; 381 - dest[1] = otdata_g[output[1]]; 382 - dest[2] = otdata_b[output[2]]; 383 + dest[r_out] = otdata_r[output[0]]; 384 + dest[1] = otdata_g[output[1]]; 385 + dest[b_out] = otdata_b[output[2]]; 386 } 387 388 void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform, 389 unsigned char *src, 390 unsigned char *dest, 391 - size_t length) 392 + size_t length, 393 + qcms_format_type output_format) 394 { 395 unsigned int i; 396 float (*mat)[4] = transform->matrix; 397 @@ -181,6 +185,8 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform, 398 399 /* working variables */ 400 __m128 vec_r, vec_g, vec_b, result; 401 + const int r_out = output_format.r; 402 + const int b_out = output_format.b; 403 unsigned char alpha; 404 405 /* CYA */ 406 @@ -231,9 +237,9 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform, 407 src += 4; 408 409 /* use calc'd indices to output RGB values */ 410 - dest[0] = otdata_r[output[0]]; 411 - dest[1] = otdata_g[output[1]]; 412 - dest[2] = otdata_b[output[2]]; 413 + dest[r_out] = otdata_r[output[0]]; 414 + dest[1] = otdata_g[output[1]]; 415 + dest[b_out] = otdata_b[output[2]]; 416 dest += 4; 417 } 418 419 @@ -256,7 +262,7 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform, 420 421 _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result)); 422 423 - dest[0] = otdata_r[output[0]]; 424 - dest[1] = otdata_g[output[1]]; 425 - dest[2] = otdata_b[output[2]]; 426 + dest[r_out] = otdata_r[output[0]]; 427 + dest[1] = otdata_g[output[1]]; 428 + dest[b_out] = otdata_b[output[2]]; 429 } 430 diff --git a/third_party/qcms/src/transform.c b/third_party/qcms/src/transform.c 431 index 9a6562b..7e0ba2c 100644 432 --- a/third_party/qcms/src/transform.c 433 +++ b/third_party/qcms/src/transform.c 434 @@ -181,11 +181,20 @@ compute_chromatic_adaption(struct CIE_XYZ source_white_point, 435 static struct matrix 436 adaption_matrix(struct CIE_XYZ source_illumination, struct CIE_XYZ target_illumination) 437 { 438 +#if defined (_MSC_VER) 439 +#pragma warning(push) 440 +/* Disable double to float truncation warning 4305 */ 441 +#pragma warning(disable:4305) 442 +#endif 443 struct matrix lam_rigg = {{ // Bradford matrix 444 { 0.8951, 0.2664, -0.1614 }, 445 { -0.7502, 1.7135, 0.0367 }, 446 { 0.0389, -0.0685, 1.0296 } 447 }}; 448 +#if defined (_MSC_VER) 449 +/* Restore warnings */ 450 +#pragma warning(pop) 451 +#endif 452 return compute_chromatic_adaption(source_illumination, target_illumination, lam_rigg); 453 } 454 455 @@ -230,8 +239,11 @@ qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcm 456 } 457 458 #if 0 459 -static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 460 +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) 461 { 462 + const int r_out = output_format.r; 463 + const int b_out = output_format.b; 464 + 465 int i; 466 float (*mat)[4] = transform->matrix; 467 for (i=0; i<length; i++) { 468 @@ -251,15 +263,19 @@ static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned 469 float out_device_g = pow(out_linear_g, transform->out_gamma_g); 470 float out_device_b = pow(out_linear_b, transform->out_gamma_b); 471 472 - *dest++ = clamp_u8(255*out_device_r); 473 - *dest++ = clamp_u8(255*out_device_g); 474 - *dest++ = clamp_u8(255*out_device_b); 475 + dest[r_out] = clamp_u8(out_device_r*255); 476 + dest[1] = clamp_u8(out_device_g*255); 477 + dest[b_out] = clamp_u8(out_device_b*255); 478 + dest += 3; 479 } 480 } 481 #endif 482 483 -static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 484 +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) 485 { 486 + const int r_out = output_format.r; 487 + const int b_out = output_format.b; 488 + 489 unsigned int i; 490 for (i = 0; i < length; i++) { 491 float out_device_r, out_device_g, out_device_b; 492 @@ -267,13 +283,14 @@ static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned 493 494 float linear = transform->input_gamma_table_gray[device]; 495 496 - out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length); 497 + out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length); 498 out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length); 499 out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length); 500 501 - *dest++ = clamp_u8(out_device_r*255); 502 - *dest++ = clamp_u8(out_device_g*255); 503 - *dest++ = clamp_u8(out_device_b*255); 504 + dest[r_out] = clamp_u8(out_device_r*255); 505 + dest[1] = clamp_u8(out_device_g*255); 506 + dest[b_out] = clamp_u8(out_device_b*255); 507 + dest += 3; 508 } 509 } 510 511 @@ -283,8 +300,11 @@ static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned 512 See: ftp://ftp.alvyray.com/Acrobat/17_Nonln.pdf 513 */ 514 515 -static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 516 +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) 517 { 518 + const int r_out = output_format.r; 519 + const int b_out = output_format.b; 520 + 521 unsigned int i; 522 for (i = 0; i < length; i++) { 523 float out_device_r, out_device_g, out_device_b; 524 @@ -293,20 +313,24 @@ static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigne 525 526 float linear = transform->input_gamma_table_gray[device]; 527 528 - out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length); 529 + out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length); 530 out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length); 531 out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length); 532 533 - *dest++ = clamp_u8(out_device_r*255); 534 - *dest++ = clamp_u8(out_device_g*255); 535 - *dest++ = clamp_u8(out_device_b*255); 536 - *dest++ = alpha; 537 + dest[r_out] = clamp_u8(out_device_r*255); 538 + dest[1] = clamp_u8(out_device_g*255); 539 + dest[b_out] = clamp_u8(out_device_b*255); 540 + dest[3] = alpha; 541 + dest += 4; 542 } 543 } 544 545 546 -static void qcms_transform_data_gray_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 547 +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) 548 { 549 + const int r_out = output_format.r; 550 + const int b_out = output_format.b; 551 + 552 unsigned int i; 553 for (i = 0; i < length; i++) { 554 unsigned char device = *src++; 555 @@ -317,14 +341,19 @@ static void qcms_transform_data_gray_out_precache(qcms_transform *transform, uns 556 /* we could round here... */ 557 gray = linear * PRECACHE_OUTPUT_MAX; 558 559 - *dest++ = transform->output_table_r->data[gray]; 560 - *dest++ = transform->output_table_g->data[gray]; 561 - *dest++ = transform->output_table_b->data[gray]; 562 + dest[r_out] = transform->output_table_r->data[gray]; 563 + dest[1] = transform->output_table_g->data[gray]; 564 + dest[b_out] = transform->output_table_b->data[gray]; 565 + dest += 3; 566 } 567 } 568 569 -static void qcms_transform_data_graya_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 570 + 571 +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) 572 { 573 + const int r_out = output_format.r; 574 + const int b_out = output_format.b; 575 + 576 unsigned int i; 577 for (i = 0; i < length; i++) { 578 unsigned char device = *src++; 579 @@ -336,15 +365,19 @@ static void qcms_transform_data_graya_out_precache(qcms_transform *transform, un 580 /* we could round here... */ 581 gray = linear * PRECACHE_OUTPUT_MAX; 582 583 - *dest++ = transform->output_table_r->data[gray]; 584 - *dest++ = transform->output_table_g->data[gray]; 585 - *dest++ = transform->output_table_b->data[gray]; 586 - *dest++ = alpha; 587 + dest[r_out] = transform->output_table_r->data[gray]; 588 + dest[1] = transform->output_table_g->data[gray]; 589 + dest[b_out] = transform->output_table_b->data[gray]; 590 + dest[3] = alpha; 591 + dest += 4; 592 } 593 } 594 595 -static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 596 +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) 597 { 598 + const int r_out = output_format.r; 599 + const int b_out = output_format.b; 600 + 601 unsigned int i; 602 float (*mat)[4] = transform->matrix; 603 for (i = 0; i < length; i++) { 604 @@ -370,14 +403,18 @@ static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, 605 g = out_linear_g * PRECACHE_OUTPUT_MAX; 606 b = out_linear_b * PRECACHE_OUTPUT_MAX; 607 608 - *dest++ = transform->output_table_r->data[r]; 609 - *dest++ = transform->output_table_g->data[g]; 610 - *dest++ = transform->output_table_b->data[b]; 611 + dest[r_out] = transform->output_table_r->data[r]; 612 + dest[1] = transform->output_table_g->data[g]; 613 + dest[b_out] = transform->output_table_b->data[b]; 614 + dest += 3; 615 } 616 } 617 618 -static void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 619 +static 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) 620 { 621 + const int r_out = output_format.r; 622 + const int b_out = output_format.b; 623 + 624 unsigned int i; 625 float (*mat)[4] = transform->matrix; 626 for (i = 0; i < length; i++) { 627 @@ -404,16 +441,21 @@ static void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, 628 g = out_linear_g * PRECACHE_OUTPUT_MAX; 629 b = out_linear_b * PRECACHE_OUTPUT_MAX; 630 631 - *dest++ = transform->output_table_r->data[r]; 632 - *dest++ = transform->output_table_g->data[g]; 633 - *dest++ = transform->output_table_b->data[b]; 634 - *dest++ = alpha; 635 + dest[r_out] = transform->output_table_r->data[r]; 636 + dest[1] = transform->output_table_g->data[g]; 637 + dest[b_out] = transform->output_table_b->data[b]; 638 + dest[3] = alpha; 639 + dest += 4; 640 } 641 } 642 643 // Not used 644 /* 645 -static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) { 646 +static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) 647 +{ 648 + const int r_out = output_format.r; 649 + const int b_out = output_format.b; 650 + 651 unsigned int i; 652 int xy_len = 1; 653 int x_len = transform->grid_size; 654 @@ -462,15 +504,20 @@ static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *s 655 float b_y2 = lerp(b_x3, b_x4, y_d); 656 float clut_b = lerp(b_y1, b_y2, z_d); 657 658 - *dest++ = clamp_u8(clut_r*255.0f); 659 - *dest++ = clamp_u8(clut_g*255.0f); 660 - *dest++ = clamp_u8(clut_b*255.0f); 661 - } 662 + dest[r_out] = clamp_u8(clut_r*255.0f); 663 + dest[1] = clamp_u8(clut_g*255.0f); 664 + dest[b_out] = clamp_u8(clut_b*255.0f); 665 + dest += 3; 666 + } 667 } 668 */ 669 670 // Using lcms' tetra interpolation algorithm. 671 -static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) { 672 +static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) 673 +{ 674 + const int r_out = output_format.r; 675 + const int b_out = output_format.b; 676 + 677 unsigned int i; 678 int xy_len = 1; 679 int x_len = transform->grid_size; 680 @@ -577,15 +624,20 @@ static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsig 681 clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz; 682 clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz; 683 684 - *dest++ = clamp_u8(clut_r*255.0f); 685 - *dest++ = clamp_u8(clut_g*255.0f); 686 - *dest++ = clamp_u8(clut_b*255.0f); 687 - *dest++ = in_a; 688 - } 689 + dest[r_out] = clamp_u8(clut_r*255.0f); 690 + dest[1] = clamp_u8(clut_g*255.0f); 691 + dest[b_out] = clamp_u8(clut_b*255.0f); 692 + dest[3] = in_a; 693 + dest += 4; 694 + } 695 } 696 697 // Using lcms' tetra interpolation code. 698 -static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) { 699 +static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format) 700 +{ 701 + const int r_out = output_format.r; 702 + const int b_out = output_format.b; 703 + 704 unsigned int i; 705 int xy_len = 1; 706 int x_len = transform->grid_size; 707 @@ -691,14 +743,18 @@ static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned c 708 clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz; 709 clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz; 710 711 - *dest++ = clamp_u8(clut_r*255.0f); 712 - *dest++ = clamp_u8(clut_g*255.0f); 713 - *dest++ = clamp_u8(clut_b*255.0f); 714 - } 715 + dest[r_out] = clamp_u8(clut_r*255.0f); 716 + dest[1] = clamp_u8(clut_g*255.0f); 717 + dest[b_out] = clamp_u8(clut_b*255.0f); 718 + dest += 3; 719 + } 720 } 721 722 -static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 723 +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) 724 { 725 + const int r_out = output_format.r; 726 + const int b_out = output_format.b; 727 + 728 unsigned int i; 729 float (*mat)[4] = transform->matrix; 730 for (i = 0; i < length; i++) { 731 @@ -726,14 +782,18 @@ static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned 732 out_device_b = lut_interp_linear(out_linear_b, 733 transform->output_gamma_lut_b, transform->output_gamma_lut_b_length); 734 735 - *dest++ = clamp_u8(out_device_r*255); 736 - *dest++ = clamp_u8(out_device_g*255); 737 - *dest++ = clamp_u8(out_device_b*255); 738 + dest[r_out] = clamp_u8(out_device_r*255); 739 + dest[1] = clamp_u8(out_device_g*255); 740 + dest[b_out] = clamp_u8(out_device_b*255); 741 + dest += 3; 742 } 743 } 744 745 -static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 746 +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) 747 { 748 + const int r_out = output_format.r; 749 + const int b_out = output_format.b; 750 + 751 unsigned int i; 752 float (*mat)[4] = transform->matrix; 753 for (i = 0; i < length; i++) { 754 @@ -762,16 +822,20 @@ static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned 755 out_device_b = lut_interp_linear(out_linear_b, 756 transform->output_gamma_lut_b, transform->output_gamma_lut_b_length); 757 758 - *dest++ = clamp_u8(out_device_r*255); 759 - *dest++ = clamp_u8(out_device_g*255); 760 - *dest++ = clamp_u8(out_device_b*255); 761 - *dest++ = alpha; 762 + dest[r_out] = clamp_u8(out_device_r*255); 763 + dest[1] = clamp_u8(out_device_g*255); 764 + dest[b_out] = clamp_u8(out_device_b*255); 765 + dest[3] = alpha; 766 + dest += 4; 767 } 768 } 769 770 #if 0 771 -static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) 772 +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) 773 { 774 + const int r_out = output_format.r; 775 + const int b_out = output_format.b; 776 + 777 int i; 778 float (*mat)[4] = transform->matrix; 779 for (i = 0; i < length; i++) { 780 @@ -787,16 +851,25 @@ static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsign 781 float out_linear_g = mat[0][1]*linear_r + mat[1][1]*linear_g + mat[2][1]*linear_b; 782 float out_linear_b = mat[0][2]*linear_r + mat[1][2]*linear_g + mat[2][2]*linear_b; 783 784 - *dest++ = clamp_u8(out_linear_r*255); 785 - *dest++ = clamp_u8(out_linear_g*255); 786 - *dest++ = clamp_u8(out_linear_b*255); 787 + dest[r_out] = clamp_u8(out_linear_r*255); 788 + dest[1] = clamp_u8(out_linear_g*255); 789 + dest[b_out] = clamp_u8(out_linear_b*255); 790 + dest += 3; 791 } 792 } 793 #endif 794 795 +/* 796 + * If users create and destroy objects on different threads, even if the same 797 + * objects aren't used on different threads at the same time, we can still run 798 + * in to trouble with refcounts if they aren't atomic. 799 + * 800 + * This can lead to us prematurely deleting the precache if threads get unlucky 801 + * and write the wrong value to the ref count. 802 + */ 803 static struct precache_output *precache_reference(struct precache_output *p) 804 { 805 - p->ref_count++; 806 + qcms_atomic_increment(p->ref_count); 807 return p; 808 } 809 810 @@ -810,12 +883,12 @@ static struct precache_output *precache_create() 811 812 void precache_release(struct precache_output *p) 813 { 814 - if (--p->ref_count == 0) { 815 + if (qcms_atomic_decrement(p->ref_count) == 0) { 816 free(p); 817 } 818 } 819 820 -#ifdef HAS_POSIX_MEMALIGN 821 +#ifdef HAVE_POSIX_MEMALIGN 822 static qcms_transform *transform_alloc(void) 823 { 824 qcms_transform *t; 825 @@ -994,13 +1067,15 @@ void qcms_profile_precache_output_transform(qcms_profile *profile) 826 if (profile->color_space != RGB_SIGNATURE) 827 return; 828 829 - /* don't precache since we will use the B2A LUT */ 830 - if (profile->B2A0) 831 - return; 832 + if (qcms_supports_iccv4) { 833 + /* don't precache since we will use the B2A LUT */ 834 + if (profile->B2A0) 835 + return; 836 837 - /* don't precache since we will use the mBA LUT */ 838 - if (profile->mBA) 839 - return; 840 + /* don't precache since we will use the mBA LUT */ 841 + if (profile->mBA) 842 + return; 843 + } 844 845 /* don't precache if we do not have the TRC curves */ 846 if (!profile->redTRC || !profile->greenTRC || !profile->blueTRC) 847 @@ -1157,14 +1232,14 @@ qcms_transform* qcms_transform_create( 848 return NULL; 849 } 850 if (precache) { 851 -#ifdef X86 852 +#if defined(SSE2_ENABLE) && defined(X86) 853 if (sse_version_available() >= 2) { 854 if (in_type == QCMS_DATA_RGB_8) 855 transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2; 856 else 857 transform->transform_fn = qcms_transform_data_rgba_out_lut_sse2; 858 859 -#if !(defined(_MSC_VER) && defined(_M_AMD64)) 860 +#if defined(SSE2_ENABLE) && !(defined(_MSC_VER) && defined(_M_AMD64)) 861 /* Microsoft Compiler for x64 doesn't support MMX. 862 * SSE code uses MMX so that we disable on x64 */ 863 } else 864 @@ -1256,13 +1331,34 @@ qcms_transform* qcms_transform_create( 865 return transform; 866 } 867 868 -#if defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__) 869 +/* __force_align_arg_pointer__ is an x86-only attribute, and gcc/clang warns on unused 870 + * attributes. Don't use this on ARM or AMD64. __has_attribute can detect the presence 871 + * of the attribute but is currently only supported by clang */ 872 +#if defined(__has_attribute) 873 +#define HAS_FORCE_ALIGN_ARG_POINTER __has_attribute(__force_align_arg_pointer__) 874 +#elif defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__) && !defined(__arm__) && !defined(__mips__) 875 +#define HAS_FORCE_ALIGN_ARG_POINTER 1 876 +#else 877 +#define HAS_FORCE_ALIGN_ARG_POINTER 0 878 +#endif 879 + 880 +#if HAS_FORCE_ALIGN_ARG_POINTER 881 /* we need this to avoid crashes when gcc assumes the stack is 128bit aligned */ 882 __attribute__((__force_align_arg_pointer__)) 883 #endif 884 void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length) 885 { 886 - transform->transform_fn(transform, src, dest, length); 887 + static const struct _qcms_format_type output_rgbx = { 0, 2 }; 888 + 889 + transform->transform_fn(transform, src, dest, length, output_rgbx); 890 +} 891 + 892 +void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type) 893 +{ 894 + static const struct _qcms_format_type output_rgbx = { 0, 2 }; 895 + static const struct _qcms_format_type output_bgrx = { 2, 0 }; 896 + 897 + transform->transform_fn(transform, src, dest, length, type == QCMS_OUTPUT_BGRX ? output_bgrx : output_rgbx); 898 } 899 900 qcms_bool qcms_supports_iccv4; 901 diff --git a/third_party/qcms/src/transform_util.c b/third_party/qcms/src/transform_util.c 902 index e8447e5..f4338b2 100644 903 --- a/third_party/qcms/src/transform_util.c 904 +++ b/third_party/qcms/src/transform_util.c 905 @@ -36,7 +36,7 @@ 906 907 /* value must be a value between 0 and 1 */ 908 //XXX: is the above a good restriction to have? 909 -float lut_interp_linear(double value, uint16_t *table, int length) 910 +float lut_interp_linear(double value, uint16_t *table, size_t length) 911 { 912 int upper, lower; 913 value = value * (length - 1); // scale to length of the array 914 @@ -49,11 +49,11 @@ float lut_interp_linear(double value, uint16_t *table, int length) 915 } 916 917 /* same as above but takes and returns a uint16_t value representing a range from 0..1 */ 918 -uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length) 919 +uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length) 920 { 921 /* Start scaling input_value to the length of the array: 65535*(length-1). 922 * We'll divide out the 65535 next */ 923 - uint32_t value = (input_value * (length - 1)); 924 + uintptr_t value = (input_value * (length - 1)); 925 uint32_t upper = (value + 65534) / 65535; /* equivalent to ceil(value/65535) */ 926 uint32_t lower = value / 65535; /* equivalent to floor(value/65535) */ 927 /* interp is the distance from upper to value scaled to 0..65535 */ 928 @@ -67,11 +67,11 @@ uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length) 929 /* same as above but takes an input_value from 0..PRECACHE_OUTPUT_MAX 930 * and returns a uint8_t value representing a range from 0..1 */ 931 static 932 -uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, int length) 933 +uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, size_t length) 934 { 935 /* Start scaling input_value to the length of the array: PRECACHE_OUTPUT_MAX*(length-1). 936 * We'll divide out the PRECACHE_OUTPUT_MAX next */ 937 - uint32_t value = (input_value * (length - 1)); 938 + uintptr_t value = (input_value * (length - 1)); 939 940 /* equivalent to ceil(value/PRECACHE_OUTPUT_MAX) */ 941 uint32_t upper = (value + PRECACHE_OUTPUT_MAX-1) / PRECACHE_OUTPUT_MAX; 942 @@ -91,7 +91,7 @@ uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, 943 944 /* value must be a value between 0 and 1 */ 945 //XXX: is the above a good restriction to have? 946 -float lut_interp_linear_float(float value, float *table, int length) 947 +float lut_interp_linear_float(float value, float *table, size_t length) 948 { 949 int upper, lower; 950 value = value * (length - 1); 951 @@ -235,6 +235,21 @@ float u8Fixed8Number_to_float(uint16_t x) 952 return x/256.; 953 } 954 955 +/* The SSE2 code uses min & max which let NaNs pass through. 956 + We want to try to prevent that here by ensuring that 957 + gamma table is within expected values. */ 958 +void validate_gamma_table(float gamma_table[256]) 959 +{ 960 + int i; 961 + for (i = 0; i < 256; i++) { 962 + // Note: we check that the gamma is not in range 963 + // instead of out of range so that we catch NaNs 964 + if (!(gamma_table[i] >= 0.f && gamma_table[i] <= 1.f)) { 965 + gamma_table[i] = 0.f; 966 + } 967 + } 968 +} 969 + 970 float *build_input_gamma_table(struct curveType *TRC) 971 { 972 float *gamma_table; 973 @@ -254,7 +269,10 @@ float *build_input_gamma_table(struct curveType *TRC) 974 } 975 } 976 } 977 - return gamma_table; 978 + 979 + validate_gamma_table(gamma_table); 980 + 981 + return gamma_table; 982 } 983 984 struct matrix build_colorant_matrix(qcms_profile *p) 985 @@ -390,7 +408,7 @@ uint16_fract_t lut_inverse_interp16(uint16_t Value, uint16_t LutTable[], int len 986 which has an maximum error of about 9855 (pixel difference of ~38.346) 987 988 For now, we punt the decision of output size to the caller. */ 989 -static uint16_t *invert_lut(uint16_t *table, int length, int out_length) 990 +static uint16_t *invert_lut(uint16_t *table, int length, size_t out_length) 991 { 992 int i; 993 /* for now we invert the lut by creating a lut of size out_length 994 diff --git a/third_party/qcms/src/transform_util.h b/third_party/qcms/src/transform_util.h 995 index 8f358a8..de465f4 100644 996 --- a/third_party/qcms/src/transform_util.h 997 +++ b/third_party/qcms/src/transform_util.h 998 @@ -31,9 +31,9 @@ 999 //XXX: could use a bettername 1000 typedef uint16_t uint16_fract_t; 1001 1002 -float lut_interp_linear(double value, uint16_t *table, int length); 1003 -float lut_interp_linear_float(float value, float *table, int length); 1004 -uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length); 1005 +float lut_interp_linear(double value, uint16_t *table, size_t length); 1006 +float lut_interp_linear_float(float value, float *table, size_t length); 1007 +uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length); 1008 1009 1010 static inline float lerp(float a, float b, float t) 1011
