Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 314 insertions, 0 deletions

diff --git a/gfx/cairo/09-quartz-surface-additions.patch b/gfx/cairo/09-quartz-surface-additions.patch
new file mode 100644
index 0000000000..104d453f4f
--- /dev/null
+++ b/gfx/cairo/09-quartz-surface-additions.patch
@@ -0,0 +1,314 @@
+diff --git a/gfx/cairo/cairo/src/cairo-quartz-private.h b/gfx/cairo/cairo/src/cairo-quartz-private.h
+--- a/gfx/cairo/cairo/src/cairo-quartz-private.h
++++ b/gfx/cairo/cairo/src/cairo-quartz-private.h
+@@ -71,8 +71,11 @@ typedef struct cairo_quartz_surface {
+     cairo_surface_t *imageSurfaceEquiv;
+ 
+     cairo_surface_clipper_t clipper;
++
+     cairo_rectangle_int_t extents;
+     cairo_rectangle_int_t virtual_extents;
++
++    cairo_bool_t ownsData;
+ } cairo_quartz_surface_t;
+ 
+ typedef struct cairo_quartz_image_surface {
+diff --git a/gfx/cairo/cairo/src/cairo-quartz-surface.c b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+--- a/gfx/cairo/cairo/src/cairo-quartz-surface.c
++++ b/gfx/cairo/cairo/src/cairo-quartz-surface.c
+@@ -1520,6 +1520,103 @@ static cairo_int_status_t
+ 
+ 
+ /*
++ * get source/dest image implementation
++ */
++
++/* Read the image from the surface's front buffer */
++static cairo_int_status_t
++_cairo_quartz_get_image (cairo_quartz_surface_t *surface,
++			 cairo_image_surface_t **image_out)
++{
++    unsigned char *imageData;
++    cairo_image_surface_t *isurf;
++
++    if (IS_EMPTY(surface)) {
++	*image_out = (cairo_image_surface_t*) cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
++	return CAIRO_STATUS_SUCCESS;
++    }
++
++    if (surface->imageSurfaceEquiv) {
++	CGContextFlush(surface->cgContext);
++	*image_out = (cairo_image_surface_t*) cairo_surface_reference(surface->imageSurfaceEquiv);
++	return CAIRO_STATUS_SUCCESS;
++    }
++
++    if (_cairo_quartz_is_cgcontext_bitmap_context(surface->cgContext)) {
++	unsigned int stride;
++	unsigned int bitinfo;
++	unsigned int bpc, bpp;
++	CGColorSpaceRef colorspace;
++	unsigned int color_comps;
++
++	CGContextFlush(surface->cgContext);
++	imageData = (unsigned char *) CGBitmapContextGetData(surface->cgContext);
++
++#ifdef USE_10_3_WORKAROUNDS
++	bitinfo = CGBitmapContextGetAlphaInfo (surface->cgContext);
++#else
++	bitinfo = CGBitmapContextGetBitmapInfo (surface->cgContext);
++#endif
++	stride = CGBitmapContextGetBytesPerRow (surface->cgContext);
++	bpp = CGBitmapContextGetBitsPerPixel (surface->cgContext);
++	bpc = CGBitmapContextGetBitsPerComponent (surface->cgContext);
++
++	// let's hope they don't add YUV under us
++	colorspace = CGBitmapContextGetColorSpace (surface->cgContext);
++	color_comps = CGColorSpaceGetNumberOfComponents(colorspace);
++
++	// XXX TODO: We can handle all of these by converting to
++	// pixman masks, including non-native-endian masks
++	if (bpc != 8)
++	    return CAIRO_INT_STATUS_UNSUPPORTED;
++
++	if (bpp != 32 && bpp != 8)
++	    return CAIRO_INT_STATUS_UNSUPPORTED;
++
++	if (color_comps != 3 && color_comps != 1)
++	    return CAIRO_INT_STATUS_UNSUPPORTED;
++
++	if (bpp == 32 && color_comps == 3 &&
++	    (bitinfo & kCGBitmapAlphaInfoMask) == kCGImageAlphaPremultipliedFirst &&
++	    (bitinfo & kCGBitmapByteOrderMask) == kCGBitmapByteOrder32Host)
++	{
++	    isurf = (cairo_image_surface_t *)
++		cairo_image_surface_create_for_data (imageData,
++						     CAIRO_FORMAT_ARGB32,
++						     surface->extents.width,
++						     surface->extents.height,
++						     stride);
++	} else if (bpp == 32 && color_comps == 3 &&
++		   (bitinfo & kCGBitmapAlphaInfoMask) == kCGImageAlphaNoneSkipFirst &&
++		   (bitinfo & kCGBitmapByteOrderMask) == kCGBitmapByteOrder32Host)
++	{
++	    isurf = (cairo_image_surface_t *)
++		cairo_image_surface_create_for_data (imageData,
++						     CAIRO_FORMAT_RGB24,
++						     surface->extents.width,
++						     surface->extents.height,
++						     stride);
++	} else if (bpp == 8 && color_comps == 1)
++	{
++	    isurf = (cairo_image_surface_t *)
++		cairo_image_surface_create_for_data (imageData,
++						     CAIRO_FORMAT_A8,
++						     surface->extents.width,
++						     surface->extents.height,
++						     stride);
++	} else {
++	    return CAIRO_INT_STATUS_UNSUPPORTED;
++	}
++    } else {
++	return CAIRO_INT_STATUS_UNSUPPORTED;
++    }
++
++    *image_out = isurf;
++    return CAIRO_STATUS_SUCCESS;
++}
++
++
++/*
+  * Cairo surface backend implementations
+  */
+ 
+@@ -1542,11 +1639,14 @@ static cairo_status_t
+     surface->cgContext = NULL;
+ 
+     if (surface->imageSurfaceEquiv) {
++        if (surface->ownsData)
++            _cairo_image_surface_assume_ownership_of_data (surface->imageSurfaceEquiv);
+ 	cairo_surface_destroy (surface->imageSurfaceEquiv);
+ 	surface->imageSurfaceEquiv = NULL;
++    } else if (surface->imageData && surface->ownsData) {
++        free (surface->imageData);
+     }
+ 
+-    free (surface->imageData);
+     surface->imageData = NULL;
+ 
+     return CAIRO_STATUS_SUCCESS;
+@@ -2298,6 +2398,8 @@ cairo_quartz_surface_t *
+     surface->cgContext = cgContext;
+     surface->cgContextBaseCTM = CGContextGetCTM (cgContext);
+ 
++    surface->ownsData = TRUE;
++
+     return surface;
+ }
+ 
+@@ -2452,10 +2554,124 @@ cairo_quartz_surface_create (cairo_forma
+     surf->imageData = imageData;
+     surf->imageSurfaceEquiv = cairo_image_surface_create_for_data (imageData, format, width, height, stride);
+ 
++    // We created this data, so we can delete it.
++    surf->ownsData = TRUE;
++
+     return &surf->base;
+ }
+ 
+ /**
++ * cairo_quartz_surface_create_for_data
++ * @data: a pointer to a buffer supplied by the application in which
++ *     to write contents. This pointer must be suitably aligned for any
++ *     kind of variable, (for example, a pointer returned by malloc).
++ * @format: format of pixels in the surface to create
++ * @width: width of the surface, in pixels
++ * @height: height of the surface, in pixels
++ *
++ * Creates a Quartz surface backed by a CGBitmap.  The surface is
++ * created using the Device RGB (or Device Gray, for A8) color space.
++ * All Cairo operations, including those that require software
++ * rendering, will succeed on this surface.
++ *
++ * Return value: the newly created surface.
++ *
++ * Since: 1.12 [Mozilla addition]
++ **/
++cairo_surface_t *
++cairo_quartz_surface_create_for_data (unsigned char *data,
++				      cairo_format_t format,
++				      unsigned int width,
++				      unsigned int height,
++				      unsigned int stride)
++{
++    cairo_quartz_surface_t *surf;
++    CGContextRef cgc;
++    CGColorSpaceRef cgColorspace;
++    CGBitmapInfo bitinfo;
++    void *imageData = data;
++    int bitsPerComponent;
++    unsigned int i;
++
++    // verify width and height of surface
++    if (!_cairo_quartz_verify_surface_size(width, height))
++	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
++
++    if (width == 0 || height == 0) {
++	return (cairo_surface_t*) _cairo_quartz_surface_create_internal (NULL, _cairo_content_from_format (format),
++									 width, height);
++    }
++
++    if (format == CAIRO_FORMAT_ARGB32 ||
++	format == CAIRO_FORMAT_RGB24)
++    {
++	cgColorspace = CGColorSpaceCreateDeviceRGB();
++	bitinfo = kCGBitmapByteOrder32Host;
++	if (format == CAIRO_FORMAT_ARGB32)
++	    bitinfo |= kCGImageAlphaPremultipliedFirst;
++	else
++	    bitinfo |= kCGImageAlphaNoneSkipFirst;
++	bitsPerComponent = 8;
++    } else if (format == CAIRO_FORMAT_A8) {
++	cgColorspace = NULL;
++	bitinfo = kCGImageAlphaOnly;
++	bitsPerComponent = 8;
++    } else if (format == CAIRO_FORMAT_A1) {
++	/* I don't think we can usefully support this, as defined by
++	 * cairo_format_t -- these are 1-bit pixels stored in 32-bit
++	 * quantities.
++	 */
++	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
++    } else {
++	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT));
++    }
++
++    cgc = CGBitmapContextCreate (imageData,
++				 width,
++				 height,
++				 bitsPerComponent,
++				 stride,
++				 cgColorspace,
++				 bitinfo);
++    CGColorSpaceRelease (cgColorspace);
++
++    if (!cgc) {
++	free (imageData);
++	return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
++    }
++
++    /* flip the Y axis */
++    CGContextTranslateCTM (cgc, 0.0, height);
++    CGContextScaleCTM (cgc, 1.0, -1.0);
++
++    surf = _cairo_quartz_surface_create_internal (cgc, _cairo_content_from_format (format),
++						  width, height);
++    if (surf->base.status) {
++	CGContextRelease (cgc);
++	free (imageData);
++	// create_internal will have set an error
++	return (cairo_surface_t*) surf;
++    }
++
++    surf->imageData = imageData;
++
++    cairo_surface_t* tmpImageSurfaceEquiv =
++      cairo_image_surface_create_for_data (imageData, format,
++                                           width, height, stride);
++
++    if (cairo_surface_status (tmpImageSurfaceEquiv)) {
++        // Tried & failed to create an imageSurfaceEquiv!
++        cairo_surface_destroy (tmpImageSurfaceEquiv);
++        surf->imageSurfaceEquiv = NULL;
++    } else {
++        surf->imageSurfaceEquiv = tmpImageSurfaceEquiv;
++        surf->ownsData = FALSE;
++    }
++
++    return (cairo_surface_t *) surf;
++}
++
++/**
+  * cairo_quartz_surface_get_cg_context:
+  * @surface: the Cairo Quartz surface
+  *
+@@ -2497,6 +2713,18 @@ cairo_bool_t
+     return surface->backend == &cairo_quartz_surface_backend;
+ }
+ 
++cairo_surface_t *
++cairo_quartz_surface_get_image (cairo_surface_t *surface)
++{
++    cairo_quartz_surface_t *quartz = (cairo_quartz_surface_t *)surface;
++    cairo_image_surface_t *image;
++
++    if (_cairo_quartz_get_image(quartz, &image))
++        return NULL;
++
++    return (cairo_surface_t *)image;
++}
++
+ /* Debug stuff */
+ 
+ #ifdef QUARTZ_DEBUG
+diff --git a/gfx/cairo/cairo/src/cairo-quartz.h b/gfx/cairo/cairo/src/cairo-quartz.h
+--- a/gfx/cairo/cairo/src/cairo-quartz.h
++++ b/gfx/cairo/cairo/src/cairo-quartz.h
+@@ -54,9 +54,19 @@ cairo_quartz_surface_create_for_cg_conte
+                                             unsigned int width,
+                                             unsigned int height);
+ 
++cairo_surface_t *
++cairo_quartz_surface_create_for_data (unsigned char *data,
++                                      cairo_format_t format,
++                                      unsigned int width,
++                                      unsigned int height,
++                                      unsigned int stride);
++
+ cairo_public CGContextRef
+ cairo_quartz_surface_get_cg_context (cairo_surface_t *surface);
+ 
++cairo_public cairo_surface_t *
++cairo_quartz_surface_get_image (cairo_surface_t *surface);
++
+ #if CAIRO_HAS_QUARTZ_FONT
+ 
+ /*