WebSVN – Kolibri OS – Diff – /programs/develop/libraries/pixman/pixman-utils.c

 #include
 #include "pixman-private.h"
+pixman_bool_t
+_pixman_multiply_overflows_size (size_t a, size_t b)
+{
+    return a >= SIZE_MAX / b;
+}
-pixman_bool_t
-pixman_multiply_overflows_int (unsigned int a,
+pixman_bool_t
-                               unsigned int b)
+_pixman_multiply_overflows_int (unsigned int a, unsigned int b)
+{
     return a >= INT32_MAX / b;
 }
 pixman_bool_t
-pixman_addition_overflows_int (unsigned int a,
+pixman_bool_t
-                               unsigned int b)
+_pixman_addition_overflows_int (unsigned int a, unsigned int b)
+{
 	return NULL;
     else
 	return malloc (a * b * c);
+}
-/*
- * Helper routine to expand a color component from 0 < n <= 8 bits to 16
- * bits by replication.
- */
-static inline uint64_t
+static force_inline uint16_t
-expand16 (const uint8_t val, int nbits)
+float_to_unorm (float f, int n_bits)
-{
-    /* Start out with the high bit of val in the high bit of result. */
+{
-    uint16_t result = (uint16_t)val << (16 - nbits);
+    uint32_t u;
+    if (f > 1.0)
+	f = 1.0;
-    if (nbits == 0)
-	return 0;
+    if (f < 0.0)
-    /* Copy the bits in result, doubling the number of bits each time, until
+	f = 0.0;
-     * we fill all 16 bits.
-     */
-    while (nbits < 16)
+    u = f * (1 << n_bits);
     u -= (u >> n_bits);
+    return u;
+}
+static force_inline float
-	result |= result >> nbits;
+unorm_to_float (uint16_t u, int n_bits)
 	nbits *= 2;
     uint32_t m = ((1 << n_bits) - 1);
-    return result;
+    return (u & m) * (1.f / (float)m);
+}
-}
+/*
+ * This function expands images from a8r8g8b8 to argb_t.  To preserve
-/*
+ * precision, it needs to know from which source format the a8r8g8b8 pixels
+ * originally came.
  * This function expands images from ARGB8 format to ARGB16.  To preserve
- * precision, it needs to know the original source format.  For example, if the
+ * For example, if the source was PIXMAN_x1r5g5b5 and the red component
- * source was PIXMAN_x1r5g5b5 and the red component contained bits 12345, then
+ * contained bits 12345, then the 8-bit value is 12345123.  To correctly
- * the expanded value is 12345123.  To correctly expand this to 16 bits, it
+ * expand this to floating point, it should be 12345 / 31.0 and not
- * should be 1234512345123451 and not 1234512312345123.
+ * 12345123 / 255.0.
  */
 void
+pixman_expand_to_float (argb_t               *dst,
+			const uint32_t       *src,
+			pixman_format_code_t  format,
+			int                   width)
+{
+    static const float multipliers[16] = {
+.0f,
+.0f / ((1 <<  1) - 1),
+.0f / ((1 <<  2) - 1),
+.0f / ((1 <<  3) - 1),
+.0f / ((1 <<  4) - 1),
+.0f / ((1 <<  5) - 1),
+.0f / ((1 <<  6) - 1),
+.0f / ((1 <<  7) - 1),
+.0f / ((1 <<  8) - 1),
+.0f / ((1 <<  9) - 1),
+.0f / ((1 << 10) - 1),
+.0f / ((1 << 11) - 1),
+.0f / ((1 << 12) - 1),
+.0f / ((1 << 13) - 1),
+.0f / ((1 << 14) - 1),
+.0f / ((1 << 15) - 1),
+    };
+    int a_size, r_size, g_size, b_size;
+    int a_shift, r_shift, g_shift, b_shift;
+    float a_mul, r_mul, g_mul, b_mul;
+    uint32_t a_mask, r_mask, g_mask, b_mask;
-pixman_expand (uint64_t *           dst,
+    int i;
                const uint32_t *     src,
-               pixman_format_code_t format,
+    if (!PIXMAN_FORMAT_VIS (format))
-               int                  width)
+	format = PIXMAN_a8r8g8b8;
-{
     /*
      * Determine the sizes of each component and the masks and shifts
      * required to extract them from the source pixel.
+     */
-     */
+    a_size = PIXMAN_FORMAT_A (format);
-    const int a_size = PIXMAN_FORMAT_A (format),
+    r_size = PIXMAN_FORMAT_R (format);
-              r_size = PIXMAN_FORMAT_R (format),
+    g_size = PIXMAN_FORMAT_G (format);
-              g_size = PIXMAN_FORMAT_G (format),
+    b_size = PIXMAN_FORMAT_B (format);
-              b_size = PIXMAN_FORMAT_B (format);
+    a_shift = 32 - a_size;
-    const int a_shift = 32 - a_size,
+    r_shift = 24 - r_size;
-              r_shift = 24 - r_size,
+    g_shift = 16 - g_size;
-              g_shift = 16 - g_size,
+    b_shift =  8 - b_size;
+    a_mask = ((1 << a_size) - 1);
+    r_mask = ((1 << r_size) - 1);
+    g_mask = ((1 << g_size) - 1);
-              b_shift =  8 - b_size;
+    b_mask = ((1 << b_size) - 1);
     const uint8_t a_mask = ~(~0 << a_size),
-                  r_mask = ~(~0 << r_size),
+    a_mul = multipliers[a_size];
-                  g_mask = ~(~0 << g_size),
+    r_mul = multipliers[r_size];
-                  b_mask = ~(~0 << b_size);
+    g_mul = multipliers[g_size];
-    int i;
+    b_mul = multipliers[b_size];
-    /* Start at the end so that we can do the expansion in place
-     * when src == dst
-     */
-    for (i = width - 1; i >= 0; i--)
-    {
-	const uint32_t pixel = src[i];
-	const uint8_t a = (pixel >> a_shift) & a_mask,
-	              r = (pixel >> r_shift) & r_mask,
+    /* Start at the end so that we can do the expansion in place
+     * when src == dst
+     */
-	              g = (pixel >> g_shift) & g_mask,
+    for (i = width - 1; i >= 0; i--)
 	              b = (pixel >> b_shift) & b_mask;
-	const uint64_t a16 = a_size ? expand16 (a, a_size) : 0xffff,
+	const uint32_t pixel = src[i];
+	dst[i].a = a_mask? ((pixel >> a_shift) & a_mask) * a_mul : 1.0f;
-	               r16 = expand16 (r, r_size),
+	dst[i].r = ((pixel >> r_shift) & r_mask) * r_mul;
+	dst[i].g = ((pixel >> g_shift) & g_mask) * g_mul;
+	dst[i].b = ((pixel >> b_shift) & b_mask) * b_mul;
+    }
+}
-	               g16 = expand16 (g, g_size),
+uint16_t
-	               b16 = expand16 (b, b_size);
+pixman_float_to_unorm (float f, int n_bits)
+{
+    return float_to_unorm (f, n_bits);
 	dst[i] = a16 << 48 | r16 << 32 | g16 << 16 | b16;
-    }
-}
+float
 pixman_unorm_to_float (uint16_t u, int n_bits)
 /*
- * Contracting is easier than expanding.  We just need to truncate the
+    return unorm_to_float (u, n_bits);
- * components.
- */
-void
-pixman_contract (uint32_t *      dst,
+}
                  const uint64_t *src,
-                 int             width)
+void
+pixman_contract_from_float (uint32_t     *dst,
-{
+			    const argb_t *src,
-    int i;
+			    int           width)
+{
+    int i;
-    /* Start at the beginning so that we can do the contraction in
+    for (i = 0; i < width; ++i)
      * place when src == dst
+	uint8_t a, r, g, b;
+	a = float_to_unorm (src[i].a, 8);
+	r = float_to_unorm (src[i].r, 8);
+	g = float_to_unorm (src[i].g, 8);
-     */
+	b = float_to_unorm (src[i].b, 8);
     for (i = 0; i < width; i++)
 	dst[i] = (a << 24) | (r << 16) | (g << 8) | (b << 0);
 	free (boxes32);
     return retval;
+}
-}
+/* This function is exported for the sake of the test suite and not part
+ * of the ABI.
+ */
+PIXMAN_EXPORT pixman_implementation_t *
+_pixman_internal_only_get_implementation (void)
+{
     return get_implementation ();
 #ifdef DEBUG
 void
                  function, message);
 	n_messages++;
+    }
-}

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/pixman/pixman-utils.c – Rev 1891 → 3931