* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
+#ifdef HAVE_CONFIG_H
#include <config.h>
+#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
+#include <assert.h>
-#include "pixman.h"
#include "pixman-private.h"
+#include "pixman-combine32.h"
-enum
-{
- PIXMAN_BAD_VALUE,
- PIXMAN_BAD_ALLOC
-};
-
-static void
-init_source_image (source_image_t *image)
-{
- image->class = SOURCE_IMAGE_CLASS_UNKNOWN;
-}
-
-static pixman_bool_t
-init_gradient (gradient_t *gradient,
- const pixman_gradient_stop_t *stops,
- int n_stops)
+pixman_bool_t
+_pixman_init_gradient (gradient_t * gradient,
+ const pixman_gradient_stop_t *stops,
+ int n_stops)
{
return_val_if_fail (n_stops > 0, FALSE);
- init_source_image (&gradient->common);
-
- gradient->stops = malloc (n_stops * sizeof (pixman_gradient_stop_t));
+ gradient->stops = pixman_malloc_ab (n_stops, sizeof (pixman_gradient_stop_t));
if (!gradient->stops)
return FALSE;
memcpy (gradient->stops, stops, n_stops * sizeof (pixman_gradient_stop_t));
-
+
gradient->n_stops = n_stops;
gradient->stop_range = 0xffff;
- gradient->color_table = NULL;
- gradient->color_table_size = 0;
+ gradient->common.class = SOURCE_IMAGE_CLASS_UNKNOWN;
return TRUE;
}
-static uint32_t
-color_to_uint32 (const pixman_color_t *color)
+/*
+ * By default, just evaluate the image at 32bpp and expand. Individual image
+ * types can plug in a better scanline getter if they want to. For example
+ * we could produce smoother gradients by evaluating them at higher color
+ * depth, but that's a project for the future.
+ */
+void
+_pixman_image_get_scanline_generic_64 (pixman_image_t * image,
+ int x,
+ int y,
+ int width,
+ uint32_t * buffer,
+ const uint32_t * mask,
+ uint32_t mask_bits)
{
- return
- (color->alpha >> 8 << 24) |
- (color->red >> 8 << 16) |
- (color->green & 0xff00) |
- (color->blue >> 8);
+ uint32_t *mask8 = NULL;
+
+ /* Contract the mask image, if one exists, so that the 32-bit fetch
+ * function can use it.
+ */
+ if (mask)
+ {
+ mask8 = pixman_malloc_ab (width, sizeof(uint32_t));
+ if (!mask8)
+ return;
+
+ pixman_contract (mask8, (uint64_t *)mask, width);
+ }
+
+ /* Fetch the source image into the first half of buffer. */
+ _pixman_image_get_scanline_32 (image, x, y, width, (uint32_t*)buffer, mask8,
+ mask_bits);
+
+ /* Expand from 32bpp to 64bpp in place. */
+ pixman_expand ((uint64_t *)buffer, buffer, PIXMAN_a8r8g8b8, width);
+
+ free (mask8);
}
-static pixman_image_t *
-allocate_image (void)
+pixman_image_t *
+_pixman_image_allocate (void)
{
pixman_image_t *image = malloc (sizeof (pixman_image_t));
-
+
if (image)
{
image_common_t *common = &image->common;
-
- pixman_region_init (&common->clip_region);
+
+ pixman_region32_init (&common->clip_region);
+
+ common->have_clip_region = FALSE;
+ common->clip_sources = FALSE;
common->transform = NULL;
common->repeat = PIXMAN_REPEAT_NONE;
common->filter = PIXMAN_FILTER_NEAREST;
common->alpha_map = NULL;
common->component_alpha = FALSE;
common->ref_count = 1;
- common->read_func = NULL;
- common->write_func = NULL;
+ common->classify = NULL;
+ common->client_clip = FALSE;
+ common->destroy_func = NULL;
+ common->destroy_data = NULL;
+ common->need_workaround = FALSE;
+ common->dirty = TRUE;
}
return image;
}
+source_image_class_t
+_pixman_image_classify (pixman_image_t *image,
+ int x,
+ int y,
+ int width,
+ int height)
+{
+ if (image->common.classify)
+ return image->common.classify (image, x, y, width, height);
+ else
+ return SOURCE_IMAGE_CLASS_UNKNOWN;
+}
+
+void
+_pixman_image_get_scanline_32 (pixman_image_t *image,
+ int x,
+ int y,
+ int width,
+ uint32_t * buffer,
+ const uint32_t *mask,
+ uint32_t mask_bits)
+{
+ image->common.get_scanline_32 (image, x, y, width, buffer, mask, mask_bits);
+}
+
+/* Even thought the type of buffer is uint32_t *, the function actually expects
+ * a uint64_t *buffer.
+ */
+void
+_pixman_image_get_scanline_64 (pixman_image_t *image,
+ int x,
+ int y,
+ int width,
+ uint32_t * buffer,
+ const uint32_t *unused,
+ uint32_t unused2)
+{
+ image->common.get_scanline_64 (image, x, y, width, buffer, unused, unused2);
+}
+
+static void
+image_property_changed (pixman_image_t *image)
+{
+ image->common.dirty = TRUE;
+}
+
/* Ref Counting */
-pixman_image_t *
+PIXMAN_EXPORT pixman_image_t *
pixman_image_ref (pixman_image_t *image)
{
image->common.ref_count++;
return image;
}
-void
+/* returns TRUE when the image is freed */
+PIXMAN_EXPORT pixman_bool_t
pixman_image_unref (pixman_image_t *image)
{
image_common_t *common = (image_common_t *)image;
if (common->ref_count == 0)
{
- pixman_region_fini (&common->clip_region);
+ if (image->common.destroy_func)
+ image->common.destroy_func (image, image->common.destroy_data);
+
+ pixman_region32_fini (&common->clip_region);
if (common->transform)
free (common->transform);
if (common->alpha_map)
pixman_image_unref ((pixman_image_t *)common->alpha_map);
-#if 0
- if (image->type == BITS && image->bits.indexed)
- free (image->bits.indexed);
-#endif
-
-#if 0
- memset (image, 0xaa, sizeof (pixman_image_t));
-#endif
-
+ if (image->type == LINEAR ||
+ image->type == RADIAL ||
+ image->type == CONICAL)
+ {
+ if (image->gradient.stops)
+ free (image->gradient.stops);
+ }
+
+ if (image->type == BITS && image->bits.free_me)
+ free (image->bits.free_me);
+
free (image);
+
+ return TRUE;
}
+
+ return FALSE;
}
-/* Constructors */
-pixman_image_t *
-pixman_image_create_solid_fill (pixman_color_t *color)
+PIXMAN_EXPORT void
+pixman_image_set_destroy_function (pixman_image_t * image,
+ pixman_image_destroy_func_t func,
+ void * data)
{
- pixman_image_t *img = allocate_image();
- if (!img)
- return NULL;
-
- init_source_image (&img->solid.common);
-
- img->type = SOLID;
- img->solid.color = color_to_uint32 (color);
-
- return img;
+ image->common.destroy_func = func;
+ image->common.destroy_data = data;
}
-pixman_image_t *
-pixman_image_create_linear_gradient (pixman_point_fixed_t *p1,
- pixman_point_fixed_t *p2,
- const pixman_gradient_stop_t *stops,
- int n_stops)
+void
+_pixman_image_reset_clip_region (pixman_image_t *image)
{
- pixman_image_t *image;
- linear_gradient_t *linear;
-
- return_val_if_fail (n_stops >= 2, NULL);
-
- image = allocate_image();
-
- if (!image)
- return NULL;
-
- linear = &image->linear;
-
- if (!init_gradient (&linear->common, stops, n_stops))
- {
- free (image);
- return NULL;
- }
-
- linear->p1 = *p1;
- linear->p2 = *p2;
-
- image->type = LINEAR;
-
- return image;
+ image->common.have_clip_region = FALSE;
}
-
-pixman_image_t *
-pixman_image_create_radial_gradient (pixman_point_fixed_t *inner,
- pixman_point_fixed_t *outer,
- pixman_fixed_t inner_radius,
- pixman_fixed_t outer_radius,
- const pixman_gradient_stop_t *stops,
- int n_stops)
+void
+_pixman_image_validate (pixman_image_t *image)
{
- pixman_image_t *image;
- radial_gradient_t *radial;
-
- return_val_if_fail (n_stops >= 2, NULL);
-
- image = allocate_image();
-
- if (!image)
- return NULL;
-
- radial = &image->radial;
-
- if (!init_gradient (&radial->common, stops, n_stops))
+ if (image->common.dirty)
{
- free (image);
- return NULL;
+ image->common.property_changed (image);
+ image->common.dirty = FALSE;
}
-
- image->type = RADIAL;
-
- radial->c1.x = inner->x;
- radial->c1.y = inner->y;
- radial->c1.radius = inner_radius;
- radial->c2.x = outer->x;
- radial->c2.y = outer->y;
- radial->c2.radius = outer_radius;
- radial->cdx = pixman_fixed_to_double (radial->c2.x - radial->c1.x);
- radial->cdy = pixman_fixed_to_double (radial->c2.y - radial->c1.y);
- radial->dr = pixman_fixed_to_double (radial->c2.radius - radial->c1.radius);
- radial->A = (radial->cdx * radial->cdx
- + radial->cdy * radial->cdy
- - radial->dr * radial->dr);
-
- return image;
}
-pixman_image_t *
-pixman_image_create_conical_gradient (pixman_point_fixed_t *center,
- pixman_fixed_t angle,
- const pixman_gradient_stop_t *stops,
- int n_stops)
+PIXMAN_EXPORT pixman_bool_t
+pixman_image_set_clip_region32 (pixman_image_t * image,
+ pixman_region32_t *region)
{
- pixman_image_t *image = allocate_image();
- conical_gradient_t *conical;
-
- if (!image)
- return NULL;
+ image_common_t *common = (image_common_t *)image;
+ pixman_bool_t result;
- conical = &image->conical;
-
- if (!init_gradient (&conical->common, stops, n_stops))
+ if (region)
{
- free (image);
- return NULL;
+ if ((result = pixman_region32_copy (&common->clip_region, region)))
+ image->common.have_clip_region = TRUE;
}
+ else
+ {
+ _pixman_image_reset_clip_region (image);
- image->type = CONICAL;
- conical->center = *center;
- conical->angle = angle;
-
- return image;
-}
+ result = TRUE;
+ }
-pixman_image_t *
-pixman_image_create_bits (pixman_format_code_t format,
- int width,
- int height,
- uint32_t *bits,
- int rowstride)
-{
- pixman_image_t *image;
-
- return_val_if_fail ((rowstride & 0x3) == 0, NULL); /* must be a
- * multiple of 4
- */
-
- image = allocate_image();
-
- if (!image)
- return NULL;
-
- image->type = BITS;
- image->bits.format = format;
- image->bits.width = width;
- image->bits.height = height;
- image->bits.bits = bits;
- image->bits.rowstride = rowstride / 4; /* we store it in number
- * of uint32_t's
- */
- image->bits.indexed = NULL;
+ image_property_changed (image);
- return image;
+ return result;
}
-void
-pixman_image_set_clip_region (pixman_image_t *image,
- pixman_region16_t *region)
+PIXMAN_EXPORT pixman_bool_t
+pixman_image_set_clip_region (pixman_image_t * image,
+ pixman_region16_t *region)
{
image_common_t *common = (image_common_t *)image;
+ pixman_bool_t result;
if (region)
{
- pixman_region_copy (&common->clip_region, region);
+ if ((result = pixman_region32_copy_from_region16 (&common->clip_region, region)))
+ image->common.have_clip_region = TRUE;
}
else
{
- pixman_region_fini (&common->clip_region);
- pixman_region_init (&common->clip_region);
+ _pixman_image_reset_clip_region (image);
+
+ result = TRUE;
}
+
+ image_property_changed (image);
+
+ return result;
}
-void
-pixman_image_set_transform (pixman_image_t *image,
- const pixman_transform_t *transform)
+PIXMAN_EXPORT void
+pixman_image_set_has_client_clip (pixman_image_t *image,
+ pixman_bool_t client_clip)
+{
+ image->common.client_clip = client_clip;
+}
+
+PIXMAN_EXPORT pixman_bool_t
+pixman_image_set_transform (pixman_image_t * image,
+ const pixman_transform_t *transform)
{
+ static const pixman_transform_t id =
+ {
+ { { pixman_fixed_1, 0, 0 },
+ { 0, pixman_fixed_1, 0 },
+ { 0, 0, pixman_fixed_1 } }
+ };
+
image_common_t *common = (image_common_t *)image;
+ pixman_bool_t result;
if (common->transform == transform)
- return;
+ return TRUE;
- if (common->transform)
+ if (memcmp (&id, transform, sizeof (pixman_transform_t)) == 0)
+ {
free (common->transform);
+ common->transform = NULL;
+ result = TRUE;
- if (transform)
- {
+ goto out;
+ }
+
+ if (common->transform == NULL)
common->transform = malloc (sizeof (pixman_transform_t));
- if (!common->transform)
- return;
- *common->transform = *transform;
- }
- else
+ if (common->transform == NULL)
{
- common->transform = NULL;
+ result = FALSE;
+
+ goto out;
}
+
+ memcpy (common->transform, transform, sizeof(pixman_transform_t));
+
+ result = TRUE;
+
+out:
+ image_property_changed (image);
+
+ return result;
}
-void
-pixman_image_set_repeat (pixman_image_t *image,
- pixman_repeat_t repeat)
+PIXMAN_EXPORT void
+pixman_image_set_repeat (pixman_image_t *image,
+ pixman_repeat_t repeat)
{
image->common.repeat = repeat;
+
+ image_property_changed (image);
}
-void
-pixman_image_set_filter (pixman_image_t *image,
- pixman_filter_t filter,
- const pixman_fixed_t *params,
- int n_params)
+PIXMAN_EXPORT pixman_bool_t
+pixman_image_set_filter (pixman_image_t * image,
+ pixman_filter_t filter,
+ const pixman_fixed_t *params,
+ int n_params)
{
image_common_t *common = (image_common_t *)image;
-
- if (params != common->filter_params || filter != common->filter)
+ pixman_fixed_t *new_params;
+
+ if (params == common->filter_params && filter == common->filter)
+ return TRUE;
+
+ new_params = NULL;
+ if (params)
{
- common->filter = filter;
-
- if (common->filter_params)
- free (common->filter_params);
+ new_params = pixman_malloc_ab (n_params, sizeof (pixman_fixed_t));
+ if (!new_params)
+ return FALSE;
- if (params)
- {
- common->filter_params = malloc (n_params * sizeof (pixman_fixed_t));
- memcpy (common->filter_params, params, n_params * sizeof (pixman_fixed_t));
- }
- else
- {
- common->filter_params = NULL;
- n_params = 0;
- }
+ memcpy (new_params,
+ params, n_params * sizeof (pixman_fixed_t));
}
-
+
+ common->filter = filter;
+
+ if (common->filter_params)
+ free (common->filter_params);
+
+ common->filter_params = new_params;
common->n_filter_params = n_params;
+
+ image_property_changed (image);
+ return TRUE;
+}
+
+PIXMAN_EXPORT void
+pixman_image_set_source_clipping (pixman_image_t *image,
+ pixman_bool_t clip_sources)
+{
+ image->common.clip_sources = clip_sources;
+
+ image_property_changed (image);
}
/* Unlike all the other property setters, this function does not
* copy the content of indexed. Doing this copying is simply
* way, way too expensive.
*/
-void
-pixman_image_set_indexed (pixman_image_t *image,
- const pixman_indexed_t *indexed)
+PIXMAN_EXPORT void
+pixman_image_set_indexed (pixman_image_t * image,
+ const pixman_indexed_t *indexed)
{
bits_image_t *bits = (bits_image_t *)image;
bits->indexed = indexed;
+
+ image_property_changed (image);
}
-void
+PIXMAN_EXPORT void
pixman_image_set_alpha_map (pixman_image_t *image,
- pixman_image_t *alpha_map,
- int16_t x,
- int16_t y)
+ pixman_image_t *alpha_map,
+ int16_t x,
+ int16_t y)
{
image_common_t *common = (image_common_t *)image;
-
+
return_if_fail (!alpha_map || alpha_map->type == BITS);
if (common->alpha_map != (bits_image_t *)alpha_map)
common->alpha_map = NULL;
}
- common->alpha_origin.x = x;
- common->alpha_origin.y = y;
+ common->alpha_origin_x = x;
+ common->alpha_origin_y = y;
+
+ image_property_changed (image);
}
-void
-pixman_image_set_component_alpha (pixman_image_t *image,
- pixman_bool_t component_alpha)
+PIXMAN_EXPORT void
+pixman_image_set_component_alpha (pixman_image_t *image,
+ pixman_bool_t component_alpha)
{
image->common.component_alpha = component_alpha;
+
+ image_property_changed (image);
}
+PIXMAN_EXPORT void
+pixman_image_set_accessors (pixman_image_t * image,
+ pixman_read_memory_func_t read_func,
+ pixman_write_memory_func_t write_func)
+{
+ return_if_fail (image != NULL);
-#define SCANLINE_BUFFER_LENGTH 2048
+ if (image->type == BITS)
+ {
+ image->bits.read_func = read_func;
+ image->bits.write_func = write_func;
-void
-pixman_image_set_accessors (pixman_image_t *image,
- pixman_read_memory_func_t read_func,
- pixman_write_memory_func_t write_func)
+ image_property_changed (image);
+ }
+}
+
+PIXMAN_EXPORT uint32_t *
+pixman_image_get_data (pixman_image_t *image)
{
- return_if_fail (image != NULL);
+ if (image->type == BITS)
+ return image->bits.bits;
- image->common.read_func = read_func;
- image->common.write_func = write_func;
+ return NULL;
}
-void
-pixman_image_composite_rect (pixman_op_t op,
- pixman_image_t *src,
- pixman_image_t *mask,
- pixman_image_t *dest,
- int16_t src_x,
- int16_t src_y,
- int16_t mask_x,
- int16_t mask_y,
- int16_t dest_x,
- int16_t dest_y,
- uint16_t width,
- uint16_t height)
+PIXMAN_EXPORT int
+pixman_image_get_width (pixman_image_t *image)
{
- FbComposeData compose_data;
- uint32_t _scanline_buffer[SCANLINE_BUFFER_LENGTH * 3];
- uint32_t *scanline_buffer = _scanline_buffer;
-
- return_if_fail (src != NULL);
- return_if_fail (dest != NULL);
-
- if (width > SCANLINE_BUFFER_LENGTH)
+ if (image->type == BITS)
+ return image->bits.width;
+
+ return 0;
+}
+
+PIXMAN_EXPORT int
+pixman_image_get_height (pixman_image_t *image)
+{
+ if (image->type == BITS)
+ return image->bits.height;
+
+ return 0;
+}
+
+PIXMAN_EXPORT int
+pixman_image_get_stride (pixman_image_t *image)
+{
+ if (image->type == BITS)
+ return image->bits.rowstride * (int) sizeof (uint32_t);
+
+ return 0;
+}
+
+PIXMAN_EXPORT int
+pixman_image_get_depth (pixman_image_t *image)
+{
+ if (image->type == BITS)
+ return PIXMAN_FORMAT_DEPTH (image->bits.format);
+
+ return 0;
+}
+
+pixman_bool_t
+_pixman_image_is_solid (pixman_image_t *image)
+{
+ if (image->type == SOLID)
+ return TRUE;
+
+ if (image->type != BITS ||
+ image->bits.width != 1 ||
+ image->bits.height != 1)
{
- scanline_buffer = (uint32_t *)malloc (width * 3 * sizeof (uint32_t));
+ return FALSE;
+ }
- if (!scanline_buffer)
- return;
+ if (image->common.repeat == PIXMAN_REPEAT_NONE)
+ return FALSE;
+
+ return TRUE;
+}
+
+uint32_t
+_pixman_image_get_solid (pixman_image_t * image,
+ pixman_format_code_t format)
+{
+ uint32_t result;
+
+ _pixman_image_get_scanline_32 (image, 0, 0, 1, &result, NULL, 0);
+
+ /* If necessary, convert RGB <--> BGR. */
+ if (PIXMAN_FORMAT_TYPE (format) != PIXMAN_TYPE_ARGB)
+ {
+ result = (((result & 0xff000000) >> 0) |
+ ((result & 0x00ff0000) >> 16) |
+ ((result & 0x0000ff00) >> 0) |
+ ((result & 0x000000ff) << 16));
+ }
+
+ return result;
+}
+
+pixman_bool_t
+_pixman_image_is_opaque (pixman_image_t *image)
+{
+ int i;
+
+ if (image->common.alpha_map)
+ return FALSE;
+
+ switch (image->type)
+ {
+ case BITS:
+ if (image->common.repeat == PIXMAN_REPEAT_NONE)
+ return FALSE;
+
+ if (PIXMAN_FORMAT_A (image->bits.format))
+ return FALSE;
+ break;
+
+ case LINEAR:
+ case RADIAL:
+ if (image->common.repeat == PIXMAN_REPEAT_NONE)
+ return FALSE;
+
+ for (i = 0; i < image->gradient.n_stops; ++i)
+ {
+ if (image->gradient.stops[i].color.alpha != 0xffff)
+ return FALSE;
+ }
+ break;
+
+ case CONICAL:
+ /* Conical gradients always have a transparent border */
+ return FALSE;
+ break;
+
+ case SOLID:
+ if (ALPHA_8 (image->solid.color) != 0xff)
+ return FALSE;
+ break;
+
+ default:
+ return FALSE;
+ break;
}
-
- compose_data.op = op;
- compose_data.src = src;
- compose_data.mask = mask;
- compose_data.dest = dest;
- compose_data.xSrc = src_x;
- compose_data.ySrc = src_y;
- compose_data.xMask = mask_x;
- compose_data.yMask = mask_y;
- compose_data.xDest = dest_x;
- compose_data.yDest = dest_y;
- compose_data.width = width;
- compose_data.height = height;
-
- pixmanCompositeRect (&compose_data, scanline_buffer);
-
- if (scanline_buffer != _scanline_buffer)
- free (scanline_buffer);
+
+ /* Convolution filters can introduce translucency if the sum of the
+ * weights is lower than 1.
+ */
+ if (image->common.filter == PIXMAN_FILTER_CONVOLUTION)
+ return FALSE;
+
+ return TRUE;
}
+