Update google.patch

third_party/qcms/google.patch

 diff --git a/third_party/qcms/src/iccread.c b/third_party/qcms/src/iccread.c
-index 36b7011..aca19d3 100644
+index 36b7011..6cec34a 100644
 --- a/third_party/qcms/src/iccread.c
 +++ b/third_party/qcms/src/iccread.c
 @@ -266,7 +266,7 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile)
         if (profile->color_space != RGB_SIGNATURE)
                return false;
  
 -       if (profile->A2B0 || profile->B2A0)
 +       if (qcms_supports_iccv4 && (profile->A2B0 || profile->B2A0))
                 return false;
  
@@ skipping 22 matching lines @@
         for (i = 0; i < 3; ++i) {
             if (!(((sum[i] - tolerance[i]) <= target[i]) &&
 @@ -331,6 +340,7 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile)
  #define TAG_A2B0 0x41324230
  #define TAG_B2A0 0x42324130
  #define TAG_CHAD 0x63686164
 +#define TAG_desc 0x64657363
  
  static struct tag *find_tag(struct tag_index index, uint32_t tag_id)
  {
-@@ -344,6 +354,47 @@ static struct tag *find_tag(struct tag_index index, uint32_t tag_id)
+@@ -344,6 +354,152 @@ static struct tag *find_tag(struct tag_index index, uint32_t tag_id)
         return tag;
  }
  
 +#define DESC_TYPE 0x64657363 // 'desc'
 +#define MLUC_TYPE 0x6d6c7563 // 'mluc'
++#define MMOD_TYPE 0x6D6D6F64 // 'mmod'
 +
 +static bool read_tag_descType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
 +{
 +       struct tag *tag = find_tag(index, tag_id);
 +       if (tag) {
 +               const uint32_t limit = sizeof profile->description;
 +               uint32_t offset = tag->offset;
 +               uint32_t type = read_u32(src, offset);
 +               uint32_t length = read_u32(src, offset+8);
-+               uint32_t i, description;
++               uint32_t i, description_offset;
++               bool mluc = false;
 +               if (length && type == MLUC_TYPE) {
 +                       length = read_u32(src, offset+20);
 +                       if (!length || (length & 1) || (read_u32(src, offset+12) != 12))
 +                               goto invalid_desc_tag;
-+                       description = offset + read_u32(src, offset+24);
++                       description_offset = offset + read_u32(src, offset+24);
 +                       if (!src->valid)
 +                               goto invalid_desc_tag;
++                       mluc = true;
 +               } else if (length && type == DESC_TYPE) {
-+                       description = offset + 12;
++                       description_offset = offset + 12;
 +               } else {
 +                       goto invalid_desc_tag;
 +               }
 +               if (length >= limit)
 +                       length = limit - 1;
-+               for (i = 0; i < length; ++i)
-+                       profile->description[i] = read_u8(src, description+i);
++               for (i = 0; i < length; ++i) {
++                       uint8_t value = read_u8(src, description_offset + i);
++                       if (!src->valid)
++                               goto invalid_desc_tag;
++                       if (mluc && !value)
++                               value = '.';
++                       profile->description[i] = value;
++               }
 +               profile->description[length] = 0;
 +       } else {
 +               goto invalid_desc_tag;
 +       }
 +
 +       if (src->valid)
 +               return true;
 +
 +invalid_desc_tag:
 +       invalid_source(src, "invalid description");
 +       return false;
 +}
 +
++#if defined(__APPLE__)
++
++// Use the dscm tag to change profile description "Display" to its more specific en-localized monitor name, if any.
++
++#define TAG_dscm  0x6473636D // 'dscm'
++
++static bool read_tag_dscmType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
++{
++       if (strcmp(profile->description, "Display") != 0)
++               return true;
++
++       struct tag *tag = find_tag(index, tag_id);
++       if (tag) {
++               uint32_t offset = tag->offset;
++               uint32_t type = read_u32(src, offset);
++               uint32_t records = read_u32(src, offset+8);
++
++               if (!src->valid || !records || type != MLUC_TYPE)
++                       goto invalid_dscm_tag;
++               if (read_u32(src, offset+12) != 12) // MLUC record size: bytes
++                       goto invalid_dscm_tag;
++
++               for (uint32_t i = 0; i < records; ++i) {
++                       const uint32_t limit = sizeof profile->description;
++                       const uint16_t isoen = 0x656E; // ISO-3166-1 language 'en'
++
++                       uint16_t language = read_u16(src, offset + 16 + (i * 12) + 0);
++                       uint32_t length = read_u32(src, offset + 16 + (i * 12) + 4);
++                       uint32_t description_offset = read_u32(src, offset + 16 + (i * 12) + 8);
++
++                       if (!src->valid || !length || (length & 1))
++                               goto invalid_dscm_tag;
++                       if (language != isoen)
++                               continue;
++
++                       // Use a prefix to identify the display description source
++                       strcpy(profile->description, "dscm:");
++                       length += 5;
++
++                       if (length >= limit)
++                               length = limit - 1;
++                       for (uint32_t j = 5; j < length; ++j) {
++                               uint8_t value = read_u8(src, offset + description_offset + j - 5);
++                               if (!src->valid)
++                                       goto invalid_dscm_tag;
++                               profile->description[j] = value ? value : '.';
++                       }
++                       profile->description[length] = 0;
++                       break;
++               }
++       }
++
++       if (src->valid)
++               return true;
++
++invalid_dscm_tag:
++       invalid_source(src, "invalid dscm tag");
++       return false;
++}
++
++// Use the mmod tag to change profile description "Display" to its specific mmod maker model data, if any.
++
++#define TAG_mmod  0x6D6D6F64 // 'mmod'
++
++static bool read_tag_mmodType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
++{
++       if (strcmp(profile->description, "Display") != 0)
++               return true;
++
++       struct tag *tag = find_tag(index, tag_id);
++       if (tag) {
++               const uint8_t length = 4 * 4; // Four 4-byte fields: 'mmod', 0, maker, model.
++
++               uint32_t offset = tag->offset;
++               if (tag->size < 40 || read_u32(src, offset) != MMOD_TYPE)
++                       goto invalid_mmod_tag;
++
++               for (uint8_t i = 0; i < length; ++i) {
++                       uint8_t value = read_u8(src, offset + i);
++                       if (!src->valid)
++                               goto invalid_mmod_tag;
++                       profile->description[i] = value ? value : '.';
++               }
++               profile->description[length] = 0;
++       }
++
++       if (src->valid)
++               return true;
++
++invalid_mmod_tag:
++       invalid_source(src, "invalid mmod tag");
++       return false;
++}
++
++#endif // __APPLE__
++
  #define XYZ_TYPE               0x58595a20 // 'XYZ '
  #define CURVE_TYPE             0x63757276 // 'curv'
  #define PARAMETRIC_CURVE_TYPE  0x70617261 // 'para'
-@@ -402,7 +453,7 @@ static struct XYZNumber read_tag_XYZType(struct mem_source *src, struct tag_inde
+@@ -402,7 +558,7 @@ static struct XYZNumber read_tag_XYZType(struct mem_source *src, struct tag_inde
  // present that are not part of the tag_index.
  static struct curveType *read_curveType(struct mem_source *src, uint32_t offset, uint32_t *len)
  {
 -       static const size_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7};
 +       static const uint32_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7};
         struct curveType *curve = NULL;
         uint32_t type = read_u32(src, offset);
         uint32_t count;
-@@ -484,19 +535,23 @@ static void read_nested_curveType(struct mem_source *src, struct curveType *(*cu
+@@ -484,19 +640,23 @@ static void read_nested_curveType(struct mem_source *src, struct curveType *(*cu
         uint32_t channel_offset = 0;
         int i;
         for (i = 0; i < num_channels; i++) {
 -               uint32_t tag_len;
 +               uint32_t tag_len = ~0;
  
                 (*curveArray)[i] = read_curveType(src, curve_offset + channel_offset, &tag_len);
                 if (!(*curveArray)[i]) {
                         invalid_source(src, "invalid nested curveType curve");
                 }
  
 +               if (tag_len == ~0) {
 +                       invalid_source(src, "invalid nested curveType tag length");
 +                       return;
 +               }
 +
                 channel_offset += tag_len;
                 // 4 byte aligned
                 if ((tag_len % 4) != 0)
                         channel_offset += 4 - (tag_len % 4);
         }
 -
  }
  
  static void mAB_release(struct lutmABType *lut)
-@@ -657,7 +712,7 @@ static struct lutType *read_tag_lutType(struct mem_source *src, struct tag_index
+@@ -657,7 +817,7 @@ static struct lutType *read_tag_lutType(struct mem_source *src, struct tag_index
         uint16_t num_input_table_entries;
         uint16_t num_output_table_entries;
         uint8_t in_chan, grid_points, out_chan;
 -       uint32_t clut_offset, output_offset;
 +       size_t clut_offset, output_offset;
         uint32_t clut_size;
         size_t entry_size;
         struct lutType *lut;
-@@ -979,6 +1034,9 @@ qcms_profile* qcms_profile_sRGB(void)
+@@ -979,6 +1139,9 @@ qcms_profile* qcms_profile_sRGB(void)
                 return NO_MEM_PROFILE;
  
         profile = qcms_profile_create_rgb_with_table(D65, Rec709Primaries, table, 1024);
 +       if (profile)
 +               strcpy(profile->description, "sRGB IEC61966-2.1");
 +
         free(table);
         return profile;
  }
-@@ -997,6 +1055,9 @@ qcms_profile* qcms_profile_from_memory(const void *mem, size_t size)
+@@ -997,6 +1160,9 @@ qcms_profile* qcms_profile_from_memory(const void *mem, size_t size)
         source.size = size;
         source.valid = true;
  
 +       if (size < 4)
 +               return INVALID_PROFILE;
 +
         length = read_u32(src, 0);
         if (length <= size) {
                 // shrink the area that we can read if appropriate
-@@ -1028,6 +1089,9 @@ qcms_profile* qcms_profile_from_memory(const void *mem, size_t size)
+@@ -1028,6 +1194,15 @@ qcms_profile* qcms_profile_from_memory(const void *mem, size_t size)
         if (!src->valid || !index.tags)
                 goto invalid_tag_table;
  
 +       if (!read_tag_descType(profile, src, index, TAG_desc))
 +               goto invalid_tag_table;
++#if defined(__APPLE__)
++       if (!read_tag_dscmType(profile, src, index, TAG_dscm))
++               goto invalid_tag_table;
++       if (!read_tag_mmodType(profile, src, index, TAG_mmod))
++               goto invalid_tag_table;
++#endif // __APPLE__
 +
         if (find_tag(index, TAG_CHAD)) {
                 profile->chromaticAdaption = read_tag_s15Fixed16ArrayType(src, index, TAG_CHAD);
         } else {
-@@ -1098,6 +1162,16 @@ invalid_profile:
+@@ -1098,6 +1273,16 @@ invalid_profile:
         return INVALID_PROFILE;
  }
  
 +qcms_bool qcms_profile_match(qcms_profile *p1, qcms_profile *p2)
 +{
 +    return memcmp(p1->description, p2->description, sizeof p1->description) == 0;
 +}
 +
 +const char* qcms_profile_get_description(qcms_profile *profile)
 +{
 +    return profile->description;
 +}
 +
  qcms_intent qcms_profile_get_rendering_intent(qcms_profile *profile)
  {
         return profile->rendering_intent;
 diff --git a/third_party/qcms/src/qcms.h b/third_party/qcms/src/qcms.h
-index 7d83623..c69a772 100644
+index 7d83623..e9c0b09 100644
 --- a/third_party/qcms/src/qcms.h
 +++ b/third_party/qcms/src/qcms.h
 @@ -40,6 +40,12 @@ sale, use or other dealings in this Software without written
  authorization from SunSoft Inc. 
  ******************************************************************/
  
 +/*
 + * QCMS, in general, is not threadsafe. However, it should be safe to create
 + * profile and transformation objects on different threads, so long as you
 + * don't use the same objects on different threads at the same time.
@@ skipping 18 matching lines @@
 @@ -136,6 +148,9 @@ qcms_bool qcms_profile_is_bogus(qcms_profile *profile);
  qcms_intent qcms_profile_get_rendering_intent(qcms_profile *profile);
  icColorSpaceSignature qcms_profile_get_color_space(qcms_profile *profile);
  
 +qcms_bool qcms_profile_match(qcms_profile *p1, qcms_profile *p2);
 +const char* qcms_profile_get_description(qcms_profile *profile);
 +
  void qcms_profile_precache_output_transform(qcms_profile *profile);
  
  qcms_transform* qcms_transform_create(
-@@ -146,6 +161,7 @@ qcms_transform* qcms_transform_create(
- void qcms_transform_release(qcms_transform *);
+@@ -143,9 +158,14 @@ qcms_transform* qcms_transform_create(
+                qcms_profile* out, qcms_data_type out_type,
+                qcms_intent intent);
+ 
+-void qcms_transform_release(qcms_transform *);
++qcms_bool qcms_transform_create_LUT_zyx_bgra(
++               qcms_profile *in, qcms_profile* out, qcms_intent intent,
++               int samples, unsigned char* lut);
  
  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);
++
++void qcms_transform_release(qcms_transform *);
  
  void qcms_enable_iccv4();
  
 diff --git a/third_party/qcms/src/qcmsint.h b/third_party/qcms/src/qcmsint.h
 index 53a3420..4116ed5 100644
 --- a/third_party/qcms/src/qcmsint.h
 +++ b/third_party/qcms/src/qcmsint.h
 @@ -45,6 +45,11 @@ struct precache_output
  #define ALIGN __attribute__(( aligned (16) ))
  #endif
@@ skipping 319 matching lines @@
      _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
  
 -    dest[0] = otdata_r[output[0]];
 -    dest[1] = otdata_g[output[1]];
 -    dest[2] = otdata_b[output[2]];
 +    dest[r_out] = otdata_r[output[0]];
 +    dest[1]     = otdata_g[output[1]];
 +    dest[b_out] = otdata_b[output[2]];
  }
 diff --git a/third_party/qcms/src/transform.c b/third_party/qcms/src/transform.c
-index 9a6562b..08db142 100644
+index 9a6562b..f669a6b 100644
 --- a/third_party/qcms/src/transform.c
 +++ b/third_party/qcms/src/transform.c
 @@ -181,11 +181,20 @@ compute_chromatic_adaption(struct CIE_XYZ source_white_point,
  static struct matrix
  adaption_matrix(struct CIE_XYZ source_illumination, struct CIE_XYZ target_illumination)
  {
 +#if defined (_MSC_VER)
 +#pragma warning(push)
 +/* Disable double to float truncation warning 4305 */
 +#pragma warning(disable:4305)
@@ skipping 395 matching lines @@
 -       /* don't precache since we will use the mBA LUT */
 -       if (profile->mBA)
 -               return;
 +               /* don't precache since we will use the mBA LUT */
 +               if (profile->mBA)
 +                       return;
 +       }
  
         /* don't precache if we do not have the TRC curves */
         if (!profile->redTRC || !profile->greenTRC || !profile->blueTRC)
-@@ -1078,7 +1153,8 @@ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms
-        //XXX: qcms_modular_transform_data may return either the src or dest buffer. If so it must not be free-ed
+@@ -1043,28 +1118,31 @@ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms
+        float* src = NULL;
+        float* dest = NULL;
+        float* lut = NULL;
++       float inverse;
+ 
+        src = malloc(lutSize*sizeof(float));
+        dest = malloc(lutSize*sizeof(float));
+ 
+        if (src && dest) {
+-               /* Prepare a list of points we want to sample */
++               /* Prepare a list of points we want to sample: x, y, z order */
+                l = 0;
++               inverse = 1 / (float)(samples-1);
+                for (x = 0; x < samples; x++) {
+                        for (y = 0; y < samples; y++) {
+                                for (z = 0; z < samples; z++) {
+-                                       src[l++] = x / (float)(samples-1);
+-                                       src[l++] = y / (float)(samples-1);
+-                                       src[l++] = z / (float)(samples-1);
++                                       src[l++] = x * inverse; // r
++                                       src[l++] = y * inverse; // g
++                                       src[l++] = z * inverse; // b
+                                }
+                        }
+                }
+ 
+                lut = qcms_chain_transform(in, out, src, dest, lutSize);
++
+                if (lut) {
+-                       transform->r_clut = &lut[0];
+-                       transform->g_clut = &lut[1];
+-                       transform->b_clut = &lut[2];
++                       transform->r_clut = &lut[0]; // r
++                       transform->g_clut = &lut[1]; // g
++                       transform->b_clut = &lut[2]; // b
+                        transform->grid_size = samples;
+                        if (in_type == QCMS_DATA_RGBA_8) {
+                                transform->transform_fn = qcms_transform_data_tetra_clut_rgba;
+@@ -1074,11 +1152,12 @@ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms
+                }
+        }
+ 
+-
+-       //XXX: qcms_modular_transform_data may return either the src or dest buffer. If so it must not be free-ed
++       // XXX: qcms_modular_transform_data may return the lut in either the src or the
++       // dest buffer. If so, it must not be free-ed.
         if (src && lut != src) {
                 free(src);
 -       } else if (dest && lut != src) {
 +       }
 +       if (dest && lut != dest) {
                 free(dest);
         }
  
-@@ -1157,14 +1233,14 @@ qcms_transform* qcms_transform_create(
+@@ -1088,6 +1167,71 @@ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms
+        return transform;
+ }
+ 
++/* 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)
++{
++       uint16_t z,y,x;
++       uint32_t l,index;
++       uint32_t lutSize = 3 * samples * samples * samples;
++
++       float* src = NULL;
++       float* dest = NULL;
++       float* lut = NULL;
++       float inverse;
++
++       src = malloc(lutSize*sizeof(float));
++       dest = malloc(lutSize*sizeof(float));
++
++       if (src && dest) {
++               /* Prepare a list of points we want to sample: z, y, x order */
++               l = 0;
++               inverse = 1 / (float)(samples-1);
++               for (z = 0; z < samples; z++) {
++                       for (y = 0; y < samples; y++) {
++                               for (x = 0; x < samples; x++) {
++                                       src[l++] = x * inverse; // r
++                                       src[l++] = y * inverse; // g
++                                       src[l++] = z * inverse; // b
++                               }
++                       }
++               }
++
++               lut = qcms_chain_transform(in, out, src, dest, lutSize);
++
++               if (lut) {
++                       index = l = 0;
++                       for (z = 0; z < samples; z++) {
++                               for (y = 0; y < samples; y++) {
++                                       for (x = 0; x < samples; x++) {
++                                               cube[index++] = (int)floorf(lut[l + 2] * 255.0f + 0.5f); // b
++                                               cube[index++] = (int)floorf(lut[l + 1] * 255.0f + 0.5f); // g
++                                               cube[index++] = (int)floorf(lut[l + 0] * 255.0f + 0.5f); // r
++                                               cube[index++] = 255;                                     // a
++                                               l += 3;
++                                       }
++                               }
++                       }
++               }
++       }
++
++       // XXX: qcms_modular_transform_data may return the lut data in either the src or
++       // dest buffer so free src, dest, and lut with care.
++
++       if (src && lut != src)
++               free(src);
++       if (dest && lut != dest)
++               free(dest);
++
++       if (lut) {
++               free(lut);
++               return true;
++       }
++
++       return false;
++}
++
+ #define NO_MEM_TRANSFORM NULL
+ 
+ qcms_transform* qcms_transform_create(
+@@ -1157,14 +1301,14 @@ qcms_transform* qcms_transform_create(
                         return NULL;
                 }
                 if (precache) {
 -#ifdef X86
 +#if defined(SSE2_ENABLE) && defined(X86)
                     if (sse_version_available() >= 2) {
                             if (in_type == QCMS_DATA_RGB_8)
                                     transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2;
                             else
                                     transform->transform_fn = qcms_transform_data_rgba_out_lut_sse2;
  
 -#if !(defined(_MSC_VER) && defined(_M_AMD64))
 +#if defined(SSE2_ENABLE) && !(defined(_MSC_VER) && defined(_M_AMD64))
                      /* Microsoft Compiler for x64 doesn't support MMX.
                       * SSE code uses MMX so that we disable on x64 */
                     } else
-@@ -1256,13 +1332,34 @@ qcms_transform* qcms_transform_create(
+@@ -1256,13 +1400,34 @@ qcms_transform* qcms_transform_create(
         return transform;
  }
  
 -#if defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__)
 +/* __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 __has_attribute(__force_align_arg_pointer__)
 +#elif defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__) && !defined(__arm__) && !defined(__mips__)
@@ skipping 126 matching lines @@
  
 -float lut_interp_linear(double value, uint16_t *table, int length);
 -float lut_interp_linear_float(float value, float *table, int length);
 -uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length);
 +float lut_interp_linear(double value, uint16_t *table, size_t length);
 +float lut_interp_linear_float(float value, float *table, size_t length);
 +uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length);
  
  
  static inline float lerp(float a, float b, float t)