Make qcms compile on Win64

third_party/qcms/src/transform_util.c

 //  qcms
 //  Copyright (C) 2009 Mozilla Foundation
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the "Software"),
 // to deal in the Software without restriction, including without limitation
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // and/or sell copies of the Software, and to permit persons to whom the Software
 // is furnished to do so, subject to the following conditions:
 //
@@ skipping 18 matching lines @@
 #include "matrix.h"
 
 #if !defined(INFINITY)
 #define INFINITY HUGE_VAL
 #endif
 
 #define PARAMETRIC_CURVE_TYPE 0x70617261 //'para'
 
 /* value must be a value between 0 and 1 */
 //XXX: is the above a good restriction to have?
-float lut_interp_linear(double value, uint16_t *table, int length)
+float lut_interp_linear(double value, uint16_t *table, size_t length)
 {
         int upper, lower;
         value = value * (length - 1); // scale to length of the array
         upper = ceil(value);
         lower = floor(value);
         //XXX: can we be more performant here?
         value = table[upper]*(1. - (upper - value)) + table[lower]*(upper - value);
         /* scale the value */
         return value * (1./65535.);
 }
 
 /* same as above but takes and returns a uint16_t value representing a range from 0..1 */
-uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length)
+uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length)
 {
         /* Start scaling input_value to the length of the array: 65535*(length-1).
          * We'll divide out the 65535 next */
-        uint32_t value = (input_value * (length - 1));
+        uintptr_t value = (input_value * (length - 1));
         uint32_t upper = (value + 65534) / 65535; /* equivalent to ceil(value/65535) */
         uint32_t lower = value / 65535;           /* equivalent to floor(value/65535) */
         /* interp is the distance from upper to value scaled to 0..65535 */
         uint32_t interp = value % 65535;
 
         value = (table[upper]*(interp) + table[lower]*(65535 - interp))/65535; // 0..65535*65535
 
         return value;
 }
 
 /* same as above but takes an input_value from 0..PRECACHE_OUTPUT_MAX
  * and returns a uint8_t value representing a range from 0..1 */
 static
-uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, int length)
+uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, size_t length)
 {
         /* Start scaling input_value to the length of the array: PRECACHE_OUTPUT_MAX*(length-1).
          * We'll divide out the PRECACHE_OUTPUT_MAX next */
-        uint32_t value = (input_value * (length - 1));
+        uintptr_t value = (input_value * (length - 1));
 
         /* equivalent to ceil(value/PRECACHE_OUTPUT_MAX) */
         uint32_t upper = (value + PRECACHE_OUTPUT_MAX-1) / PRECACHE_OUTPUT_MAX;
         /* equivalent to floor(value/PRECACHE_OUTPUT_MAX) */
         uint32_t lower = value / PRECACHE_OUTPUT_MAX;
         /* interp is the distance from upper to value scaled to 0..PRECACHE_OUTPUT_MAX */
         uint32_t interp = value % PRECACHE_OUTPUT_MAX;
 
         /* the table values range from 0..65535 */
         value = (table[upper]*(interp) + table[lower]*(PRECACHE_OUTPUT_MAX - interp)); // 0..(65535*PRECACHE_OUTPUT_MAX)
 
         /* round and scale */
         value += (PRECACHE_OUTPUT_MAX*65535/255)/2;
         value /= (PRECACHE_OUTPUT_MAX*65535/255); // scale to 0..255
         return value;
 }
 
 /* value must be a value between 0 and 1 */
 //XXX: is the above a good restriction to have?
-float lut_interp_linear_float(float value, float *table, int length)
+float lut_interp_linear_float(float value, float *table, size_t length)
 {
         int upper, lower;
         value = value * (length - 1);
         upper = ceil(value);
         lower = floor(value);
         //XXX: can we be more performant here?
         value = table[upper]*(1. - (upper - value)) + table[lower]*(upper - value);
         /* scale the value */
         return value;
 }
@@ skipping 296 matching lines @@
  especially true of lookup tables that have a small number of entries.
 
  For example:
  Using a table like:
     {0, 3104, 14263, 34802, 65535}
  invert_lut will produce an inverse of:
     {3, 34459, 47529, 56801, 65535}
  which has an maximum error of about 9855 (pixel difference of ~38.346)
 
  For now, we punt the decision of output size to the caller. */
-static uint16_t *invert_lut(uint16_t *table, int length, int out_length)
+static uint16_t *invert_lut(uint16_t *table, int length, size_t out_length)
 {
         int i;
         /* for now we invert the lut by creating a lut of size out_length
          * and attempting to lookup a value for each entry using lut_inverse_interp16 */
         uint16_t *output = malloc(sizeof(uint16_t)*out_length);
         if (!output)
                 return NULL;
 
         for (i = 0; i < out_length; i++) {
                 double x = ((double) i * 65535.) / (double) (out_length - 1);
@@ skipping 146 matching lines @@
                         //     measurement or data, however it is what lcms uses.
                         *output_gamma_lut_length = trc->count;
                         if (*output_gamma_lut_length < 256)
                                 *output_gamma_lut_length = 256;
 
                         *output_gamma_lut = invert_lut(trc->data, trc->count, *output_gamma_lut_length);
                 }
         }
 
 }