third_party/qcms/google.patch

   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..9a9b197 100644
 175 --- a/third_party/qcms/src/qcmstypes.h
 176 +++ b/third_party/qcms/src/qcmstypes.h
 177 @@ -87,7 +87,12 @@ typedef unsigned __int64 uint64_t;
 178  #ifdef _WIN64
 179  typedef unsigned __int64 uintptr_t;
 180  #else
 181 +#pragma warning(push)
 182 +/* Disable benign redefinition of type warning 4142 */
 183 +#pragma warning(disable:4142)
 184  typedef unsigned long uintptr_t;
 185 +/* Restore warnings */
 186 +#pragma warning(pop)
 187  #endif
 188
 189  #elif defined (_AIX)
 190 diff --git a/third_party/qcms/src/transform-sse1.c b/third_party/qcms/src/transform-sse1.c
 191 index 2f34db5..aaee1bf 100644
 192 --- a/third_party/qcms/src/transform-sse1.c
 193 +++ b/third_party/qcms/src/transform-sse1.c
 194 @@ -34,7 +34,8 @@ static const ALIGN float clampMaxValueX4[4] =
 195  void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
 196                                            unsigned char *src,
 197                                            unsigned char *dest,
 198 -                                          size_t length)
 199 +                                          size_t length,
 200 +                                          qcms_format_type output_format)
 201  {
 202      unsigned int i;
 203      float (*mat)[4] = transform->matrix;
 204 @@ -70,6 +71,8 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
 205
 206      /* working variables */
 207      __m128 vec_r, vec_g, vec_b, result;
 208 +    const int r_out = output_format.r;
 209 +    const int b_out = output_format.b;
 210
 211      /* CYA */
 212      if (!length)
 213 @@ -116,9 +119,9 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
 214          src += 3;
 215
 216          /* use calc'd indices to output RGB values */
 217 -        dest[0] = otdata_r[output[0]];
 218 -        dest[1] = otdata_g[output[1]];
 219 -        dest[2] = otdata_b[output[2]];
 220 +        dest[r_out] = otdata_r[output[0]];
 221 +        dest[1]     = otdata_g[output[1]];
 222 +        dest[b_out] = otdata_b[output[2]];
 223          dest += 3;
 224      }
 225
 226 @@ -141,9 +144,9 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
 227      result = _mm_movehl_ps(result, result);
 228      *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
 229
 230 -    dest[0] = otdata_r[output[0]];
 231 -    dest[1] = otdata_g[output[1]];
 232 -    dest[2] = otdata_b[output[2]];
 233 +    dest[r_out] = otdata_r[output[0]];
 234 +    dest[1]     = otdata_g[output[1]];
 235 +    dest[b_out] = otdata_b[output[2]];
 236
 237      _mm_empty();
 238  }
 239 @@ -151,7 +154,8 @@ void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
 240  void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
 241                                             unsigned char *src,
 242                                             unsigned char *dest,
 243 -                                           size_t length)
 244 +                                           size_t length,
 245 +                                           qcms_format_type output_format)
 246  {
 247      unsigned int i;
 248      float (*mat)[4] = transform->matrix;
 249 @@ -187,6 +191,8 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
 250
 251      /* working variables */
 252      __m128 vec_r, vec_g, vec_b, result;
 253 +    const int r_out = output_format.r;
 254 +    const int b_out = output_format.b;
 255      unsigned char alpha;
 256
 257      /* CYA */
 258 @@ -239,9 +245,9 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
 259          src += 4;
 260
 261          /* use calc'd indices to output RGB values */
 262 -        dest[0] = otdata_r[output[0]];
 263 -        dest[1] = otdata_g[output[1]];
 264 -        dest[2] = otdata_b[output[2]];
 265 +        dest[r_out] = otdata_r[output[0]];
 266 +        dest[1]     = otdata_g[output[1]];
 267 +        dest[b_out] = otdata_b[output[2]];
 268          dest += 4;
 269      }
 270
 271 @@ -266,9 +272,9 @@ void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
 272      result = _mm_movehl_ps(result, result);
 273      *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
 274
 275 -    dest[0] = otdata_r[output[0]];
 276 -    dest[1] = otdata_g[output[1]];
 277 -    dest[2] = otdata_b[output[2]];
 278 +    dest[r_out] = otdata_r[output[0]];
 279 +    dest[1]     = otdata_g[output[1]];
 280 +    dest[b_out] = otdata_b[output[2]];
 281
 282      _mm_empty();
 283  }
 284 diff --git a/third_party/qcms/src/transform-sse2.c b/third_party/qcms/src/transform-sse2.c
 285 index 6a5faf9..fa7f2d1 100644
 286 --- a/third_party/qcms/src/transform-sse2.c
 287 +++ b/third_party/qcms/src/transform-sse2.c
 288 @@ -34,7 +34,8 @@ static const ALIGN float clampMaxValueX4[4] =
 289  void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
 290                                            unsigned char *src,
 291                                            unsigned char *dest,
 292 -                                          size_t length)
 293 +                                          size_t length,
 294 +                                          qcms_format_type output_format)
 295  {
 296      unsigned int i;
 297      float (*mat)[4] = transform->matrix;
 298 @@ -70,6 +71,8 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
 299
 300      /* working variables */
 301      __m128 vec_r, vec_g, vec_b, result;
 302 +    const int r_out = output_format.r;
 303 +    const int b_out = output_format.b;
 304
 305      /* CYA */
 306      if (!length)
 307 @@ -114,9 +117,9 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
 308          src += 3;
 309
 310          /* use calc'd indices to output RGB values */
 311 -        dest[0] = otdata_r[output[0]];
 312 -        dest[1] = otdata_g[output[1]];
 313 -        dest[2] = otdata_b[output[2]];
 314 +        dest[r_out] = otdata_r[output[0]];
 315 +        dest[1]     = otdata_g[output[1]];
 316 +        dest[b_out] = otdata_b[output[2]];
 317          dest += 3;
 318      }
 319
 320 @@ -137,15 +140,16 @@ void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
 321
 322      _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
 323
 324 -    dest[0] = otdata_r[output[0]];
 325 -    dest[1] = otdata_g[output[1]];
 326 -    dest[2] = otdata_b[output[2]];
 327 +    dest[r_out] = otdata_r[output[0]];
 328 +    dest[1]     = otdata_g[output[1]];
 329 +    dest[b_out] = otdata_b[output[2]];
 330  }
 331
 332  void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
 333                                             unsigned char *src,
 334                                             unsigned char *dest,
 335 -                                           size_t length)
 336 +                                           size_t length,
 337 +                                           qcms_format_type output_format)
 338  {
 339      unsigned int i;
 340      float (*mat)[4] = transform->matrix;
 341 @@ -181,6 +185,8 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
 342
 343      /* working variables */
 344      __m128 vec_r, vec_g, vec_b, result;
 345 +    const int r_out = output_format.r;
 346 +    const int b_out = output_format.b;
 347      unsigned char alpha;
 348
 349      /* CYA */
 350 @@ -231,9 +237,9 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
 351          src += 4;
 352
 353          /* use calc'd indices to output RGB values */
 354 -        dest[0] = otdata_r[output[0]];
 355 -        dest[1] = otdata_g[output[1]];
 356 -        dest[2] = otdata_b[output[2]];
 357 +        dest[r_out] = otdata_r[output[0]];
 358 +        dest[1]     = otdata_g[output[1]];
 359 +        dest[b_out] = otdata_b[output[2]];
 360          dest += 4;
 361      }
 362
 363 @@ -256,7 +262,7 @@ void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
 364
 365      _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
 366
 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  }
 374 diff --git a/third_party/qcms/src/transform.c b/third_party/qcms/src/transform.c
 375 index 9a6562b..7e0ba2c 100644
 376 --- a/third_party/qcms/src/transform.c
 377 +++ b/third_party/qcms/src/transform.c
 378 @@ -181,11 +181,20 @@ compute_chromatic_adaption(struct CIE_XYZ source_white_point,
 379  static struct matrix
 380  adaption_matrix(struct CIE_XYZ source_illumination, struct CIE_XYZ target_illumination)
 381  {
 382 +#if defined (_MSC_VER)
 383 +#pragma warning(push)
 384 +/* Disable double to float truncation warning 4305 */
 385 +#pragma warning(disable:4305)
 386 +#endif
 387         struct matrix lam_rigg = {{ // Bradford matrix
 388                                  {  0.8951,  0.2664, -0.1614 },
 389                                  { -0.7502,  1.7135,  0.0367 },
 390                                  {  0.0389, -0.0685,  1.0296 }
 391                                  }};
 392 +#if defined (_MSC_VER)
 393 +/* Restore warnings */
 394 +#pragma warning(pop)
 395 +#endif
 396         return compute_chromatic_adaption(source_illumination, target_illumination, lam_rigg);
 397  }
 398
 399 @@ -230,8 +239,11 @@ qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcm
 400  }
 401
 402  #if 0
 403 -static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 404 +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)
 405  {
 406 +       const int r_out = output_format.r;
 407 +       const int b_out = output_format.b;
 408 +
 409         int i;
 410         float (*mat)[4] = transform->matrix;
 411         for (i=0; i<length; i++) {
 412 @@ -251,15 +263,19 @@ static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned
 413                 float out_device_g = pow(out_linear_g, transform->out_gamma_g);
 414                 float out_device_b = pow(out_linear_b, transform->out_gamma_b);
 415
 416 -               *dest++ = clamp_u8(255*out_device_r);
 417 -               *dest++ = clamp_u8(255*out_device_g);
 418 -               *dest++ = clamp_u8(255*out_device_b);
 419 +               dest[r_out] = clamp_u8(out_device_r*255);
 420 +               dest[1]     = clamp_u8(out_device_g*255);
 421 +               dest[b_out] = clamp_u8(out_device_b*255);
 422 +               dest += 3;
 423         }
 424  }
 425  #endif
 426
 427 -static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 428 +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)
 429  {
 430 +       const int r_out = output_format.r;
 431 +       const int b_out = output_format.b;
 432 +
 433         unsigned int i;
 434         for (i = 0; i < length; i++) {
 435                 float out_device_r, out_device_g, out_device_b;
 436 @@ -267,13 +283,14 @@ static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned
 437
 438                 float linear = transform->input_gamma_table_gray[device];
 439
 440 -                out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 441 +               out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 442                 out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
 443                 out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 444
 445 -               *dest++ = clamp_u8(out_device_r*255);
 446 -               *dest++ = clamp_u8(out_device_g*255);
 447 -               *dest++ = clamp_u8(out_device_b*255);
 448 +               dest[r_out] = clamp_u8(out_device_r*255);
 449 +               dest[1]     = clamp_u8(out_device_g*255);
 450 +               dest[b_out] = clamp_u8(out_device_b*255);
 451 +               dest += 3;
 452         }
 453  }
 454
 455 @@ -283,8 +300,11 @@ static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned
 456         See: ftp://ftp.alvyray.com/Acrobat/17_Nonln.pdf
 457  */
 458
 459 -static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 460 +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)
 461  {
 462 +       const int r_out = output_format.r;
 463 +       const int b_out = output_format.b;
 464 +
 465         unsigned int i;
 466         for (i = 0; i < length; i++) {
 467                 float out_device_r, out_device_g, out_device_b;
 468 @@ -293,20 +313,24 @@ static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigne
 469
 470                 float linear = transform->input_gamma_table_gray[device];
 471
 472 -                out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 473 +               out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 474                 out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
 475                 out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 476
 477 -               *dest++ = clamp_u8(out_device_r*255);
 478 -               *dest++ = clamp_u8(out_device_g*255);
 479 -               *dest++ = clamp_u8(out_device_b*255);
 480 -               *dest++ = alpha;
 481 +               dest[r_out] = clamp_u8(out_device_r*255);
 482 +               dest[1]     = clamp_u8(out_device_g*255);
 483 +               dest[b_out] = clamp_u8(out_device_b*255);
 484 +               dest[3]     = alpha;
 485 +               dest += 4;
 486         }
 487  }
 488
 489
 490 -static void qcms_transform_data_gray_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 491 +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)
 492  {
 493 +       const int r_out = output_format.r;
 494 +       const int b_out = output_format.b;
 495 +
 496         unsigned int i;
 497         for (i = 0; i < length; i++) {
 498                 unsigned char device = *src++;
 499 @@ -317,14 +341,19 @@ static void qcms_transform_data_gray_out_precache(qcms_transform *transform, uns
 500                 /* we could round here... */
 501                 gray = linear * PRECACHE_OUTPUT_MAX;
 502
 503 -               *dest++ = transform->output_table_r->data[gray];
 504 -               *dest++ = transform->output_table_g->data[gray];
 505 -               *dest++ = transform->output_table_b->data[gray];
 506 +               dest[r_out] = transform->output_table_r->data[gray];
 507 +               dest[1]     = transform->output_table_g->data[gray];
 508 +               dest[b_out] = transform->output_table_b->data[gray];
 509 +               dest += 3;
 510         }
 511  }
 512
 513 -static void qcms_transform_data_graya_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 514 +
 515 +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)
 516  {
 517 +       const int r_out = output_format.r;
 518 +       const int b_out = output_format.b;
 519 +
 520         unsigned int i;
 521         for (i = 0; i < length; i++) {
 522                 unsigned char device = *src++;
 523 @@ -336,15 +365,19 @@ static void qcms_transform_data_graya_out_precache(qcms_transform *transform, un
 524                 /* we could round here... */
 525                 gray = linear * PRECACHE_OUTPUT_MAX;
 526
 527 -               *dest++ = transform->output_table_r->data[gray];
 528 -               *dest++ = transform->output_table_g->data[gray];
 529 -               *dest++ = transform->output_table_b->data[gray];
 530 -               *dest++ = alpha;
 531 +               dest[r_out] = transform->output_table_r->data[gray];
 532 +               dest[1]     = transform->output_table_g->data[gray];
 533 +               dest[b_out] = transform->output_table_b->data[gray];
 534 +               dest[3]     = alpha;
 535 +               dest += 4;
 536         }
 537  }
 538
 539 -static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 540 +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)
 541  {
 542 +       const int r_out = output_format.r;
 543 +       const int b_out = output_format.b;
 544 +
 545         unsigned int i;
 546         float (*mat)[4] = transform->matrix;
 547         for (i = 0; i < length; i++) {
 548 @@ -370,14 +403,18 @@ static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform,
 549                 g = out_linear_g * PRECACHE_OUTPUT_MAX;
 550                 b = out_linear_b * PRECACHE_OUTPUT_MAX;
 551
 552 -               *dest++ = transform->output_table_r->data[r];
 553 -               *dest++ = transform->output_table_g->data[g];
 554 -               *dest++ = transform->output_table_b->data[b];
 555 +               dest[r_out] = transform->output_table_r->data[r];
 556 +               dest[1]     = transform->output_table_g->data[g];
 557 +               dest[b_out] = transform->output_table_b->data[b];
 558 +               dest += 3;
 559         }
 560  }
 561
 562 -static void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 563 +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)
 564  {
 565 +       const int r_out = output_format.r;
 566 +       const int b_out = output_format.b;
 567 +
 568         unsigned int i;
 569         float (*mat)[4] = transform->matrix;
 570         for (i = 0; i < length; i++) {
 571 @@ -404,16 +441,21 @@ static void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform,
 572                 g = out_linear_g * PRECACHE_OUTPUT_MAX;
 573                 b = out_linear_b * PRECACHE_OUTPUT_MAX;
 574
 575 -               *dest++ = transform->output_table_r->data[r];
 576 -               *dest++ = transform->output_table_g->data[g];
 577 -               *dest++ = transform->output_table_b->data[b];
 578 -               *dest++ = alpha;
 579 +               dest[r_out] = transform->output_table_r->data[r];
 580 +               dest[1]     = transform->output_table_g->data[g];
 581 +               dest[b_out] = transform->output_table_b->data[b];
 582 +               dest[3]     = alpha;
 583 +               dest += 4;
 584         }
 585  }
 586
 587  // Not used
 588  /*
 589 -static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
 590 +static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 591 +{
 592 +       const int r_out = output_format.r;
 593 +       const int b_out = output_format.b;
 594 +
 595         unsigned int i;
 596         int xy_len = 1;
 597         int x_len = transform->grid_size;
 598 @@ -462,15 +504,20 @@ static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *s
 599                 float b_y2 = lerp(b_x3, b_x4, y_d);
 600                 float clut_b = lerp(b_y1, b_y2, z_d);
 601
 602 -               *dest++ = clamp_u8(clut_r*255.0f);
 603 -               *dest++ = clamp_u8(clut_g*255.0f);
 604 -               *dest++ = clamp_u8(clut_b*255.0f);
 605 -       }
 606 +               dest[r_out] = clamp_u8(clut_r*255.0f);
 607 +               dest[1]     = clamp_u8(clut_g*255.0f);
 608 +               dest[b_out] = clamp_u8(clut_b*255.0f);
 609 +               dest += 3;
 610 +       }
 611  }
 612  */
 613
 614  // Using lcms' tetra interpolation algorithm.
 615 -static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
 616 +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)
 617 +{
 618 +       const int r_out = output_format.r;
 619 +       const int b_out = output_format.b;
 620 +
 621         unsigned int i;
 622         int xy_len = 1;
 623         int x_len = transform->grid_size;
 624 @@ -577,15 +624,20 @@ static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsig
 625                 clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz;
 626                 clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz;
 627
 628 -               *dest++ = clamp_u8(clut_r*255.0f);
 629 -               *dest++ = clamp_u8(clut_g*255.0f);
 630 -               *dest++ = clamp_u8(clut_b*255.0f);
 631 -               *dest++ = in_a;
 632 -       }
 633 +               dest[r_out] = clamp_u8(clut_r*255.0f);
 634 +               dest[1]     = clamp_u8(clut_g*255.0f);
 635 +               dest[b_out] = clamp_u8(clut_b*255.0f);
 636 +               dest[3]     = in_a;
 637 +               dest += 4;
 638 +       }
 639  }
 640
 641  // Using lcms' tetra interpolation code.
 642 -static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
 643 +static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 644 +{
 645 +       const int r_out = output_format.r;
 646 +       const int b_out = output_format.b;
 647 +
 648         unsigned int i;
 649         int xy_len = 1;
 650         int x_len = transform->grid_size;
 651 @@ -691,14 +743,18 @@ static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned c
 652                 clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz;
 653                 clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz;
 654
 655 -               *dest++ = clamp_u8(clut_r*255.0f);
 656 -               *dest++ = clamp_u8(clut_g*255.0f);
 657 -               *dest++ = clamp_u8(clut_b*255.0f);
 658 -       }
 659 +               dest[r_out] = clamp_u8(clut_r*255.0f);
 660 +               dest[1]     = clamp_u8(clut_g*255.0f);
 661 +               dest[b_out] = clamp_u8(clut_b*255.0f);
 662 +               dest += 3;
 663 +       }
 664  }
 665
 666 -static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 667 +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)
 668  {
 669 +       const int r_out = output_format.r;
 670 +       const int b_out = output_format.b;
 671 +
 672         unsigned int i;
 673         float (*mat)[4] = transform->matrix;
 674         for (i = 0; i < length; i++) {
 675 @@ -726,14 +782,18 @@ static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned
 676                 out_device_b = lut_interp_linear(out_linear_b,
 677                                 transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 678
 679 -               *dest++ = clamp_u8(out_device_r*255);
 680 -               *dest++ = clamp_u8(out_device_g*255);
 681 -               *dest++ = clamp_u8(out_device_b*255);
 682 +               dest[r_out] = clamp_u8(out_device_r*255);
 683 +               dest[1]     = clamp_u8(out_device_g*255);
 684 +               dest[b_out] = clamp_u8(out_device_b*255);
 685 +               dest += 3;
 686         }
 687  }
 688
 689 -static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 690 +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)
 691  {
 692 +       const int r_out = output_format.r;
 693 +       const int b_out = output_format.b;
 694 +
 695         unsigned int i;
 696         float (*mat)[4] = transform->matrix;
 697         for (i = 0; i < length; i++) {
 698 @@ -762,16 +822,20 @@ static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned
 699                 out_device_b = lut_interp_linear(out_linear_b,
 700                                 transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 701
 702 -               *dest++ = clamp_u8(out_device_r*255);
 703 -               *dest++ = clamp_u8(out_device_g*255);
 704 -               *dest++ = clamp_u8(out_device_b*255);
 705 -               *dest++ = alpha;
 706 +               dest[r_out] = clamp_u8(out_device_r*255);
 707 +               dest[1]     = clamp_u8(out_device_g*255);
 708 +               dest[b_out] = clamp_u8(out_device_b*255);
 709 +               dest[3]     = alpha;
 710 +               dest += 4;
 711         }
 712  }
 713
 714  #if 0
 715 -static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
 716 +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)
 717  {
 718 +       const int r_out = output_format.r;
 719 +       const int b_out = output_format.b;
 720 +
 721         int i;
 722         float (*mat)[4] = transform->matrix;
 723         for (i = 0; i < length; i++) {
 724 @@ -787,16 +851,25 @@ static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsign
 725                 float out_linear_g = mat[0][1]*linear_r + mat[1][1]*linear_g + mat[2][1]*linear_b;
 726                 float out_linear_b = mat[0][2]*linear_r + mat[1][2]*linear_g + mat[2][2]*linear_b;
 727
 728 -               *dest++ = clamp_u8(out_linear_r*255);
 729 -               *dest++ = clamp_u8(out_linear_g*255);
 730 -               *dest++ = clamp_u8(out_linear_b*255);
 731 +               dest[r_out] = clamp_u8(out_linear_r*255);
 732 +               dest[1]     = clamp_u8(out_linear_g*255);
 733 +               dest[b_out] = clamp_u8(out_linear_b*255);
 734 +               dest += 3;
 735         }
 736  }
 737  #endif
 738
 739 +/*
 740 + * If users create and destroy objects on different threads, even if the same
 741 + * objects aren't used on different threads at the same time, we can still run
 742 + * in to trouble with refcounts if they aren't atomic.
 743 + *
 744 + * This can lead to us prematurely deleting the precache if threads get unlucky
 745 + * and write the wrong value to the ref count.
 746 + */
 747  static struct precache_output *precache_reference(struct precache_output *p)
 748  {
 749 -       p->ref_count++;
 750 +       qcms_atomic_increment(p->ref_count);
 751         return p;
 752  }
 753
 754 @@ -810,12 +883,12 @@ static struct precache_output *precache_create()
 755
 756  void precache_release(struct precache_output *p)
 757  {
 758 -       if (--p->ref_count == 0) {
 759 +       if (qcms_atomic_decrement(p->ref_count) == 0) {
 760                 free(p);
 761         }
 762  }
 763
 764 -#ifdef HAS_POSIX_MEMALIGN
 765 +#ifdef HAVE_POSIX_MEMALIGN
 766  static qcms_transform *transform_alloc(void)
 767  {
 768         qcms_transform *t;
 769 @@ -994,13 +1067,15 @@ void qcms_profile_precache_output_transform(qcms_profile *profile)
 770         if (profile->color_space != RGB_SIGNATURE)
 771                 return;
 772
 773 -       /* don't precache since we will use the B2A LUT */
 774 -       if (profile->B2A0)
 775 -               return;
 776 +       if (qcms_supports_iccv4) {
 777 +               /* don't precache since we will use the B2A LUT */
 778 +               if (profile->B2A0)
 779 +                       return;
 780
 781 -       /* don't precache since we will use the mBA LUT */
 782 -       if (profile->mBA)
 783 -               return;
 784 +               /* don't precache since we will use the mBA LUT */
 785 +               if (profile->mBA)
 786 +                       return;
 787 +       }
 788
 789         /* don't precache if we do not have the TRC curves */
 790         if (!profile->redTRC || !profile->greenTRC || !profile->blueTRC)
 791 @@ -1157,14 +1232,14 @@ qcms_transform* qcms_transform_create(
 792                         return NULL;
 793                 }
 794                 if (precache) {
 795 -#ifdef X86
 796 +#if defined(SSE2_ENABLE) && defined(X86)
 797                     if (sse_version_available() >= 2) {
 798                             if (in_type == QCMS_DATA_RGB_8)
 799                                     transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2;
 800                             else
 801                                     transform->transform_fn = qcms_transform_data_rgba_out_lut_sse2;
 802
 803 -#if !(defined(_MSC_VER) && defined(_M_AMD64))
 804 +#if defined(SSE2_ENABLE) && !(defined(_MSC_VER) && defined(_M_AMD64))
 805                      /* Microsoft Compiler for x64 doesn't support MMX.
 806                       * SSE code uses MMX so that we disable on x64 */
 807                     } else
 808 @@ -1256,13 +1331,34 @@ qcms_transform* qcms_transform_create(
 809         return transform;
 810  }
 811
 812 -#if defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__)
 813 +/* __force_align_arg_pointer__ is an x86-only attribute, and gcc/clang warns on unused
 814 + * attributes. Don't use this on ARM or AMD64. __has_attribute can detect the presence
 815 + * of the attribute but is currently only supported by clang */
 816 +#if defined(__has_attribute)
 817 +#define HAS_FORCE_ALIGN_ARG_POINTER __has_attribute(__force_align_arg_pointer__)
 818 +#elif defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__) && !defined(__arm__) && !defined(__mips__)
 819 +#define HAS_FORCE_ALIGN_ARG_POINTER 1
 820 +#else
 821 +#define HAS_FORCE_ALIGN_ARG_POINTER 0
 822 +#endif
 823 +
 824 +#if HAS_FORCE_ALIGN_ARG_POINTER
 825  /* we need this to avoid crashes when gcc assumes the stack is 128bit aligned */
 826  __attribute__((__force_align_arg_pointer__))
 827  #endif
 828  void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length)
 829  {
 830 -       transform->transform_fn(transform, src, dest, length);
 831 +       static const struct _qcms_format_type output_rgbx = { 0, 2 };
 832 +
 833 +       transform->transform_fn(transform, src, dest, length, output_rgbx);
 834 +}
 835 +
 836 +void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type)
 837 +{
 838 +       static const struct _qcms_format_type output_rgbx = { 0, 2 };
 839 +       static const struct _qcms_format_type output_bgrx = { 2, 0 };
 840 +
 841 +       transform->transform_fn(transform, src, dest, length, type == QCMS_OUTPUT_BGRX ? output_bgrx : output_rgbx);
 842  }
 843
 844  qcms_bool qcms_supports_iccv4;
 845 diff --git a/third_party/qcms/src/transform_util.c b/third_party/qcms/src/transform_util.c
 846 index e8447e5..f4338b2 100644
 847 --- a/third_party/qcms/src/transform_util.c
 848 +++ b/third_party/qcms/src/transform_util.c
 849 @@ -36,7 +36,7 @@
 850
 851  /* value must be a value between 0 and 1 */
 852  //XXX: is the above a good restriction to have?
 853 -float lut_interp_linear(double value, uint16_t *table, int length)
 854 +float lut_interp_linear(double value, uint16_t *table, size_t length)
 855  {
 856         int upper, lower;
 857         value = value * (length - 1); // scale to length of the array
 858 @@ -49,11 +49,11 @@ float lut_interp_linear(double value, uint16_t *table, int length)
 859  }
 860
 861  /* same as above but takes and returns a uint16_t value representing a range from 0..1 */
 862 -uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length)
 863 +uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length)
 864  {
 865         /* Start scaling input_value to the length of the array: 65535*(length-1).
 866          * We'll divide out the 65535 next */
 867 -       uint32_t value = (input_value * (length - 1));
 868 +       uintptr_t value = (input_value * (length - 1));
 869         uint32_t upper = (value + 65534) / 65535; /* equivalent to ceil(value/65535) */
 870         uint32_t lower = value / 65535;           /* equivalent to floor(value/65535) */
 871         /* interp is the distance from upper to value scaled to 0..65535 */
 872 @@ -67,11 +67,11 @@ uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length)
 873  /* same as above but takes an input_value from 0..PRECACHE_OUTPUT_MAX
 874   * and returns a uint8_t value representing a range from 0..1 */
 875  static
 876 -uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, int length)
 877 +uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, size_t length)
 878  {
 879         /* Start scaling input_value to the length of the array: PRECACHE_OUTPUT_MAX*(length-1).
 880          * We'll divide out the PRECACHE_OUTPUT_MAX next */
 881 -       uint32_t value = (input_value * (length - 1));
 882 +       uintptr_t value = (input_value * (length - 1));
 883
 884         /* equivalent to ceil(value/PRECACHE_OUTPUT_MAX) */
 885         uint32_t upper = (value + PRECACHE_OUTPUT_MAX-1) / PRECACHE_OUTPUT_MAX;
 886 @@ -91,7 +91,7 @@ uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table,
 887
 888  /* value must be a value between 0 and 1 */
 889  //XXX: is the above a good restriction to have?
 890 -float lut_interp_linear_float(float value, float *table, int length)
 891 +float lut_interp_linear_float(float value, float *table, size_t length)
 892  {
 893          int upper, lower;
 894          value = value * (length - 1);
 895 @@ -235,6 +235,21 @@ float u8Fixed8Number_to_float(uint16_t x)
 896         return x/256.;
 897  }
 898
 899 +/* The SSE2 code uses min & max which let NaNs pass through.
 900 +   We want to try to prevent that here by ensuring that
 901 +   gamma table is within expected values. */
 902 +void validate_gamma_table(float gamma_table[256])
 903 +{
 904 +       int i;
 905 +       for (i = 0; i < 256; i++) {
 906 +               // Note: we check that the gamma is not in range
 907 +               // instead of out of range so that we catch NaNs
 908 +               if (!(gamma_table[i] >= 0.f && gamma_table[i] <= 1.f)) {
 909 +                       gamma_table[i] = 0.f;
 910 +               }
 911 +       }
 912 +}
 913 +
 914  float *build_input_gamma_table(struct curveType *TRC)
 915  {
 916         float *gamma_table;
 917 @@ -254,7 +269,10 @@ float *build_input_gamma_table(struct curveType *TRC)
 918                         }
 919                 }
 920         }
 921 -        return gamma_table;
 922 +
 923 +       validate_gamma_table(gamma_table);
 924 +
 925 +       return gamma_table;
 926  }
 927
 928  struct matrix build_colorant_matrix(qcms_profile *p)
 929 @@ -390,7 +408,7 @@ uint16_fract_t lut_inverse_interp16(uint16_t Value, uint16_t LutTable[], int len
 930   which has an maximum error of about 9855 (pixel difference of ~38.346)
 931
 932   For now, we punt the decision of output size to the caller. */
 933 -static uint16_t *invert_lut(uint16_t *table, int length, int out_length)
 934 +static uint16_t *invert_lut(uint16_t *table, int length, size_t out_length)
 935  {
 936          int i;
 937          /* for now we invert the lut by creating a lut of size out_length
 938 diff --git a/third_party/qcms/src/transform_util.h b/third_party/qcms/src/transform_util.h
 939 index 8f358a8..de465f4 100644
 940 --- a/third_party/qcms/src/transform_util.h
 941 +++ b/third_party/qcms/src/transform_util.h
 942 @@ -31,9 +31,9 @@
 943  //XXX: could use a bettername
 944  typedef uint16_t uint16_fract_t;
 945
 946 -float lut_interp_linear(double value, uint16_t *table, int length);
 947 -float lut_interp_linear_float(float value, float *table, int length);
 948 -uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length);
 949 +float lut_interp_linear(double value, uint16_t *table, size_t length);
 950 +float lut_interp_linear_float(float value, float *table, size_t length);
 951 +uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length);
 952
 953
 954  static inline float lerp(float a, float b, float t)