pixman/pixman-utils.c - third_party/pixman - Git at Google

 /*
  * Copyright © 2000 SuSE, Inc.
  * Copyright © 1999 Keith Packard
  *
  * Permission to use, copy, modify, distribute, and sell this software and its
  * documentation for any purpose is hereby granted without fee, provided that
  * the above copyright notice appear in all copies and that both that
  * copyright notice and this permission notice appear in supporting
  * documentation, and that the name of SuSE not be used in advertising or
  * publicity pertaining to distribution of the software without specific,
  * written prior permission.  SuSE makes no representations about the
  * suitability of this software for any purpose.  It is provided "as is"
  * without express or implied warranty.
  *
  * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  *
  * Author:  Keith Packard, SuSE, Inc.
  */

 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 #include <stdio.h>
 #include <stdlib.h>

 #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, unsigned int b)
 {
     return a >= INT32_MAX / b;
 }

 pixman_bool_t
 _pixman_addition_overflows_int (unsigned int a, unsigned int b)
 {
     return a > INT32_MAX - b;
 }

 void *
 pixman_malloc_ab_plus_c (unsigned int a, unsigned int b, unsigned int c)
 {
     if (!b || a >= INT32_MAX / b || (a * b) > INT32_MAX - c)
 	return NULL;

     return malloc (a * b + c);
 }

 void *
 pixman_malloc_ab (unsigned int a,
                   unsigned int b)
 {
     if (a >= INT32_MAX / b)
 	return NULL;

     return malloc (a * b);
 }

 void *
 pixman_malloc_abc (unsigned int a,
                    unsigned int b,
                    unsigned int c)
 {
     if (a >= INT32_MAX / b)
 	return NULL;
     else if (a * b >= INT32_MAX / c)
 	return NULL;
     else
 	return malloc (a * b * c);
 }

 static force_inline uint16_t
 float_to_unorm (float f, int n_bits)
 {
     uint32_t u;

     if (f > 1.0)
 	f = 1.0;
     if (f < 0.0)
 	f = 0.0;

     u = f * (1 << n_bits);
     u -= (u >> n_bits);

     return u;
 }

 static force_inline float
 unorm_to_float (uint16_t u, int n_bits)
 {
     uint32_t m = ((1 << n_bits) - 1);

     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.
  *
  * For example, if the source was PIXMAN_x1r5g5b5 and the red component
  * contained bits 12345, then the 8-bit value is 12345123.  To correctly
  * expand this to floating point, it should be 12345 / 31.0 and not
  * 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] = {
 	0.0f,
 	1.0f / ((1 <<  1) - 1),
 	1.0f / ((1 <<  2) - 1),
 	1.0f / ((1 <<  3) - 1),
 	1.0f / ((1 <<  4) - 1),
 	1.0f / ((1 <<  5) - 1),
 	1.0f / ((1 <<  6) - 1),
 	1.0f / ((1 <<  7) - 1),
 	1.0f / ((1 <<  8) - 1),
 	1.0f / ((1 <<  9) - 1),
 	1.0f / ((1 << 10) - 1),
 	1.0f / ((1 << 11) - 1),
 	1.0f / ((1 << 12) - 1),
 	1.0f / ((1 << 13) - 1),
 	1.0f / ((1 << 14) - 1),
 	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;
     int i;

     if (!PIXMAN_FORMAT_VIS (format))
 	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);
     r_size = PIXMAN_FORMAT_R (format);
     g_size = PIXMAN_FORMAT_G (format);
     b_size = PIXMAN_FORMAT_B (format);

     a_shift = 32 - a_size;
     r_shift = 24 - r_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_mask = ((1 << b_size) - 1);

     a_mul = multipliers[a_size];
     r_mul = multipliers[r_size];
     g_mul = multipliers[g_size];
     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];

 	dst[i].a = a_mask? ((pixel >> a_shift) & a_mask) * a_mul : 1.0f;
 	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;
     }
 }

 uint16_t
 pixman_float_to_unorm (float f, int n_bits)
 {
     return float_to_unorm (f, n_bits);
 }

 float
 pixman_unorm_to_float (uint16_t u, int n_bits)
 {
     return unorm_to_float (u, n_bits);
 }

 void
 pixman_contract_from_float (uint32_t     *dst,
 			    const argb_t *src,
 			    int           width)
 {
     int i;

     for (i = 0; i < width; ++i)
     {
 	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);

 	dst[i] = (a << 24) | (r << 16) | (g << 8) | (b << 0);
     }
 }

 uint32_t *
 _pixman_iter_get_scanline_noop (pixman_iter_t *iter, const uint32_t *mask)
 {
     return iter->buffer;
 }

 void
 _pixman_iter_init_bits_stride (pixman_iter_t *iter, const pixman_iter_info_t *info)
 {
     pixman_image_t *image = iter->image;
     uint8_t *b = (uint8_t *)image->bits.bits;
     int s = image->bits.rowstride * 4;

     iter->bits = b + s * iter->y + iter->x * PIXMAN_FORMAT_BPP (info->format) / 8;
     iter->stride = s;
 }

 #define N_TMP_BOXES (16)

 pixman_bool_t
 pixman_region16_copy_from_region32 (pixman_region16_t *dst,
                                     pixman_region32_t *src)
 {
     int n_boxes, i;
     pixman_box32_t *boxes32;
     pixman_box16_t *boxes16;
     pixman_bool_t retval;

     boxes32 = pixman_region32_rectangles (src, &n_boxes);

     boxes16 = pixman_malloc_ab (n_boxes, sizeof (pixman_box16_t));

     if (!boxes16)
 	return FALSE;

     for (i = 0; i < n_boxes; ++i)
     {
 	boxes16[i].x1 = boxes32[i].x1;
 	boxes16[i].y1 = boxes32[i].y1;
 	boxes16[i].x2 = boxes32[i].x2;
 	boxes16[i].y2 = boxes32[i].y2;
     }

     pixman_region_fini (dst);
     retval = pixman_region_init_rects (dst, boxes16, n_boxes);
     free (boxes16);
     return retval;
 }

 pixman_bool_t
 pixman_region32_copy_from_region16 (pixman_region32_t *dst,
                                     pixman_region16_t *src)
 {
     int n_boxes, i;
     pixman_box16_t *boxes16;
     pixman_box32_t *boxes32;
     pixman_box32_t tmp_boxes[N_TMP_BOXES];
     pixman_bool_t retval;

     boxes16 = pixman_region_rectangles (src, &n_boxes);

     if (n_boxes > N_TMP_BOXES)
 	boxes32 = pixman_malloc_ab (n_boxes, sizeof (pixman_box32_t));
     else
 	boxes32 = tmp_boxes;

     if (!boxes32)
 	return FALSE;

     for (i = 0; i < n_boxes; ++i)
     {
 	boxes32[i].x1 = boxes16[i].x1;
 	boxes32[i].y1 = boxes16[i].y1;
 	boxes32[i].x2 = boxes16[i].x2;
 	boxes32[i].y2 = boxes16[i].y2;
     }

     pixman_region32_fini (dst);
     retval = pixman_region32_init_rects (dst, boxes32, n_boxes);

     if (boxes32 != tmp_boxes)
 	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 ();
 }

 void
 _pixman_log_error (const char *function, const char *message)
 {
     static int n_messages = 0;

     if (n_messages < 10)
     {
 	fprintf (stderr,
 		 "*** BUG ***\n"
 		 "In %s: %s\n"
 		 "Set a breakpoint on '_pixman_log_error' to debug\n\n",
                  function, message);

 	n_messages++;
     }
 }
	/*
	* Copyright © 2000 SuSE, Inc.
	* Copyright © 1999 Keith Packard
	*
	* Permission to use, copy, modify, distribute, and sell this software and its
	* documentation for any purpose is hereby granted without fee, provided that
	* the above copyright notice appear in all copies and that both that
	* copyright notice and this permission notice appear in supporting
	* documentation, and that the name of SuSE not be used in advertising or
	* publicity pertaining to distribution of the software without specific,
	* written prior permission. SuSE makes no representations about the
	* suitability of this software for any purpose. It is provided "as is"
	* without express or implied warranty.
	*
	* SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
	* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
	* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
	* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	*
	* Author: Keith Packard, SuSE, Inc.
	*/

	#ifdef HAVE_CONFIG_H
	#include <config.h>
	#endif
	#include <stdio.h>
	#include <stdlib.h>

	#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, unsigned int b)
	{
	return a >= INT32_MAX / b;
	}

	pixman_bool_t
	_pixman_addition_overflows_int (unsigned int a, unsigned int b)
	{
	return a > INT32_MAX - b;
	}

	void *
	pixman_malloc_ab_plus_c (unsigned int a, unsigned int b, unsigned int c)
	{
	if (!b \|\| a >= INT32_MAX / b \|\| (a * b) > INT32_MAX - c)
	return NULL;

	return malloc (a * b + c);
	}

	void *
	pixman_malloc_ab (unsigned int a,
	unsigned int b)
	{
	if (a >= INT32_MAX / b)
	return NULL;

	return malloc (a * b);
	}

	void *
	pixman_malloc_abc (unsigned int a,
	unsigned int b,
	unsigned int c)
	{
	if (a >= INT32_MAX / b)
	return NULL;
	else if (a * b >= INT32_MAX / c)
	return NULL;
	else
	return malloc (a * b * c);
	}

	static force_inline uint16_t
	float_to_unorm (float f, int n_bits)
	{
	uint32_t u;

	if (f > 1.0)
	f = 1.0;
	if (f < 0.0)
	f = 0.0;

	u = f * (1 << n_bits);
	u -= (u >> n_bits);

	return u;
	}

	static force_inline float
	unorm_to_float (uint16_t u, int n_bits)
	{
	uint32_t m = ((1 << n_bits) - 1);

	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.
	*
	* For example, if the source was PIXMAN_x1r5g5b5 and the red component
	* contained bits 12345, then the 8-bit value is 12345123. To correctly
	* expand this to floating point, it should be 12345 / 31.0 and not
	* 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] = {
	0.0f,
	1.0f / ((1 << 1) - 1),
	1.0f / ((1 << 2) - 1),
	1.0f / ((1 << 3) - 1),
	1.0f / ((1 << 4) - 1),
	1.0f / ((1 << 5) - 1),
	1.0f / ((1 << 6) - 1),
	1.0f / ((1 << 7) - 1),
	1.0f / ((1 << 8) - 1),
	1.0f / ((1 << 9) - 1),
	1.0f / ((1 << 10) - 1),
	1.0f / ((1 << 11) - 1),
	1.0f / ((1 << 12) - 1),
	1.0f / ((1 << 13) - 1),
	1.0f / ((1 << 14) - 1),
	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;
	int i;

	if (!PIXMAN_FORMAT_VIS (format))
	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);
	r_size = PIXMAN_FORMAT_R (format);
	g_size = PIXMAN_FORMAT_G (format);
	b_size = PIXMAN_FORMAT_B (format);

	a_shift = 32 - a_size;
	r_shift = 24 - r_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_mask = ((1 << b_size) - 1);

	a_mul = multipliers[a_size];
	r_mul = multipliers[r_size];
	g_mul = multipliers[g_size];
	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];

	dst[i].a = a_mask? ((pixel >> a_shift) & a_mask) * a_mul : 1.0f;
	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;
	}
	}

	uint16_t
	pixman_float_to_unorm (float f, int n_bits)
	{
	return float_to_unorm (f, n_bits);
	}

	float
	pixman_unorm_to_float (uint16_t u, int n_bits)
	{
	return unorm_to_float (u, n_bits);
	}

	void
	pixman_contract_from_float (uint32_t *dst,
	const argb_t *src,
	int width)
	{
	int i;

	for (i = 0; i < width; ++i)
	{
	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);

	dst[i] = (a << 24) \| (r << 16) \| (g << 8) \| (b << 0);
	}
	}

	uint32_t *
	_pixman_iter_get_scanline_noop (pixman_iter_t iter, const uint32_t mask)
	{
	return iter->buffer;
	}

	void
	_pixman_iter_init_bits_stride (pixman_iter_t iter, const pixman_iter_info_t info)
	{
	pixman_image_t *image = iter->image;
	uint8_t b = (uint8_t )image->bits.bits;
	int s = image->bits.rowstride * 4;

	iter->bits = b + s * iter->y + iter->x * PIXMAN_FORMAT_BPP (info->format) / 8;
	iter->stride = s;
	}

	#define N_TMP_BOXES (16)

	pixman_bool_t
	pixman_region16_copy_from_region32 (pixman_region16_t *dst,
	pixman_region32_t *src)
	{
	int n_boxes, i;
	pixman_box32_t *boxes32;
	pixman_box16_t *boxes16;
	pixman_bool_t retval;

	boxes32 = pixman_region32_rectangles (src, &n_boxes);

	boxes16 = pixman_malloc_ab (n_boxes, sizeof (pixman_box16_t));

	if (!boxes16)
	return FALSE;

	for (i = 0; i < n_boxes; ++i)
	{
	boxes16[i].x1 = boxes32[i].x1;
	boxes16[i].y1 = boxes32[i].y1;
	boxes16[i].x2 = boxes32[i].x2;
	boxes16[i].y2 = boxes32[i].y2;
	}

	pixman_region_fini (dst);
	retval = pixman_region_init_rects (dst, boxes16, n_boxes);
	free (boxes16);
	return retval;
	}

	pixman_bool_t
	pixman_region32_copy_from_region16 (pixman_region32_t *dst,
	pixman_region16_t *src)
	{
	int n_boxes, i;
	pixman_box16_t *boxes16;
	pixman_box32_t *boxes32;
	pixman_box32_t tmp_boxes[N_TMP_BOXES];
	pixman_bool_t retval;

	boxes16 = pixman_region_rectangles (src, &n_boxes);

	if (n_boxes > N_TMP_BOXES)
	boxes32 = pixman_malloc_ab (n_boxes, sizeof (pixman_box32_t));
	else
	boxes32 = tmp_boxes;

	if (!boxes32)
	return FALSE;

	for (i = 0; i < n_boxes; ++i)
	{
	boxes32[i].x1 = boxes16[i].x1;
	boxes32[i].y1 = boxes16[i].y1;
	boxes32[i].x2 = boxes16[i].x2;
	boxes32[i].y2 = boxes16[i].y2;
	}

	pixman_region32_fini (dst);
	retval = pixman_region32_init_rects (dst, boxes32, n_boxes);

	if (boxes32 != tmp_boxes)
	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 ();
	}

	void
	_pixman_log_error (const char function, const char message)
	{
	static int n_messages = 0;

	if (n_messages < 10)
	{
	fprintf (stderr,
	"* BUG *\n"
	"In %s: %s\n"
	"Set a breakpoint on '_pixman_log_error' to debug\n\n",
	function, message);

	n_messages++;
	}
	}