void
ink_cairo_surface_blit(cairo_surface_t *src, cairo_surface_t *dest)
{
if (cairo_surface_get_type(src) == CAIRO_SURFACE_TYPE_IMAGE &&
cairo_surface_get_type(dest) == CAIRO_SURFACE_TYPE_IMAGE &&
cairo_image_surface_get_format(src) == cairo_image_surface_get_format(dest) &&
cairo_image_surface_get_height(src) == cairo_image_surface_get_height(dest) &&
cairo_image_surface_get_width(src) == cairo_image_surface_get_width(dest) &&
cairo_image_surface_get_stride(src) == cairo_image_surface_get_stride(dest))
{
// use memory copy instead of using a Cairo context
cairo_surface_flush(src);
int stride = cairo_image_surface_get_stride(src);
int h = cairo_image_surface_get_height(src);
memcpy(cairo_image_surface_get_data(dest), cairo_image_surface_get_data(src), stride * h);
cairo_surface_mark_dirty(dest);
} else {
// generic implementation
cairo_t *ct = cairo_create(dest);
cairo_set_source_surface(ct, src, 0, 0);
cairo_set_operator(ct, CAIRO_OPERATOR_SOURCE);
cairo_paint(ct);
cairo_destroy(ct);
}
}
cairo_surface_t *
cairo_boilerplate_get_image_surface_from_png (const char *filename,
int width,
int height,
cairo_bool_t flatten)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create_from_png (filename);
if (cairo_surface_status (surface))
return surface;
if (flatten) {
cairo_t *cr;
cairo_surface_t *flattened;
flattened = cairo_image_surface_create (cairo_image_surface_get_format (surface),
width,
height);
cr = cairo_create (flattened);
cairo_surface_destroy (flattened);
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_set_source_surface (cr, surface,
width - cairo_image_surface_get_width (surface),
height - cairo_image_surface_get_height (surface));
cairo_paint (cr);
cairo_surface_destroy (surface);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
} else if (cairo_image_surface_get_width (surface) != width ||
cairo_image_surface_get_height (surface) != height)
{
cairo_t *cr;
cairo_surface_t *sub;
sub = cairo_image_surface_create (cairo_image_surface_get_format (surface),
width,
height);
cr = cairo_create (sub);
cairo_surface_destroy (sub);
cairo_set_source_surface (cr, surface,
width - cairo_image_surface_get_width (surface),
height - cairo_image_surface_get_height (surface));
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_surface_destroy (surface);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
}
return surface;
}
std::shared_ptr<Texture> createTextureFromSurface(cairo_surface_t* surface) {
// Convert cairo format to GL format.
GLint gl_internal_format;
GLint gl_format;
const cairo_format_t format = cairo_image_surface_get_format(surface);
if(format == CAIRO_FORMAT_ARGB32) {
gl_internal_format = GL_RGBA;
gl_format = GL_BGRA;
} else if(format == CAIRO_FORMAT_RGB24) {
gl_internal_format = GL_RGB;
gl_format = GL_BGR;
} else {
throw "Unsupported surface type";
}
// Create texture
const int width = cairo_image_surface_get_width(surface);
const int height = cairo_image_surface_get_height(surface);
auto texture = Texture::create(width, height);
texture->useIn();
glTexImage2D(GL_TEXTURE_2D, 0, gl_internal_format, width, height, 0, gl_format, GL_UNSIGNED_BYTE, cairo_image_surface_get_data(surface));
return texture;
}
Picture *Picture::from_png(const char *filename) {
cairo_surface_t *pngs = cairo_image_surface_create_from_png(filename);
if (cairo_surface_status(pngs) != CAIRO_STATUS_SUCCESS) {
cairo_surface_destroy(pngs);
throw std::runtime_error("Failed to load PNG to Cairo surface");
}
cairo_format_t nf = cairo_image_surface_get_format(pngs);
if (nf != CAIRO_FORMAT_ARGB32 && nf != CAIRO_FORMAT_RGB24) {
cairo_surface_destroy(pngs);
throw std::runtime_error("PNG uses unsupported pixel format");
}
Picture *ret = Picture::alloc(
cairo_image_surface_get_width(pngs),
cairo_image_surface_get_height(pngs),
4*cairo_image_surface_get_width(pngs),
BGRA8
);
int xcopy = 4*ret->w;
int stride = cairo_image_surface_get_stride(pngs);
uint8_t *data = (uint8_t *)cairo_image_surface_get_data(pngs);
/* copy data */
for (int ycopy = 0; ycopy < ret->h; ++ycopy) {
memcpy(ret->scanline(ycopy), data + stride * ycopy, xcopy);
}
cairo_surface_destroy(pngs);
return ret;
}
/*
* _gtk_cairo_blur_surface:
* @surface: a cairo image surface.
* @radius: the blur radius.
*
* Blurs the cairo image surface at the given radius.
*/
void
_gtk_cairo_blur_surface (cairo_surface_t* surface,
double radius_d)
{
cairo_format_t format;
int radius = radius_d;
g_return_if_fail (surface != NULL);
g_return_if_fail (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE);
format = cairo_image_surface_get_format (surface);
g_return_if_fail (format == CAIRO_FORMAT_A8);
if (radius == 0)
return;
/* Before we mess with the surface, execute any pending drawing. */
cairo_surface_flush (surface);
_boxblur (cairo_image_surface_get_data (surface),
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_height (surface),
radius);
/* Inform cairo we altered the surface contents. */
cairo_surface_mark_dirty (surface);
}
cairo_surface_t *
_cairo_image_surface_create_compatible (cairo_surface_t *surface)
{
return cairo_image_surface_create (cairo_image_surface_get_format (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface));
}
static GdkPixbuf *
cairo_surface_to_pixbuf (cairo_surface_t *surface)
{
gint stride, width, height, x, y;
guchar *data, *output, *output_pixel;
/* This doesn't deal with alpha --- it simply converts the 4-byte Cairo ARGB
* format to the 3-byte GdkPixbuf packed RGB format. */
g_assert (cairo_image_surface_get_format (surface) == CAIRO_FORMAT_RGB24);
stride = cairo_image_surface_get_stride (surface);
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
data = cairo_image_surface_get_data (surface);
output = g_malloc (stride * height);
output_pixel = output;
for (y = 0; y < height; y++) {
guint32 *row = (guint32*) (data + y * stride);
for (x = 0; x < width; x++) {
output_pixel[0] = (row[x] & 0x00ff0000) >> 16;
output_pixel[1] = (row[x] & 0x0000ff00) >> 8;
output_pixel[2] = (row[x] & 0x000000ff);
output_pixel += 3;
}
}
return gdk_pixbuf_new_from_data (output, GDK_COLORSPACE_RGB, FALSE, 8,
width, height, width * 3,
(GdkPixbufDestroyNotify) g_free, NULL);
}
/*
* _gsk_cairo_blur_surface:
* @surface: a cairo image surface.
* @radius: the blur radius.
*
* Blurs the cairo image surface at the given radius.
*/
void
gsk_cairo_blur_surface (cairo_surface_t* surface,
double radius_d,
GskBlurFlags flags)
{
int radius = radius_d;
g_return_if_fail (surface != NULL);
g_return_if_fail (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE);
g_return_if_fail (cairo_image_surface_get_format (surface) == CAIRO_FORMAT_A8);
/* The code doesn't actually do any blurring for radius 1, as it
* ends up with box filter size 1 */
if (radius <= 1)
return;
if ((flags & (GSK_BLUR_X|GSK_BLUR_Y)) == 0)
return;
/* Before we mess with the surface, execute any pending drawing. */
cairo_surface_flush (surface);
_boxblur (cairo_image_surface_get_data (surface),
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_height (surface),
radius, flags);
/* Inform cairo we altered the surface contents. */
cairo_surface_mark_dirty (surface);
}
void CairoImage::putPixel(int x, int y, const Color& color)
{
if (!mCairoSurface)
{
throw GCN_EXCEPTION("Trying to write a pixel on a non loaded image.");
}
int stride=cairo_image_surface_get_stride(mCairoSurface);
unsigned char *imagePixels=cairo_image_surface_get_data(mCairoSurface);
if (!imagePixels)
{
throw GCN_EXCEPTION("Surface data are not available (surface is not of type Image or has been finished)");
}
// deal differently with each surface format
switch(cairo_image_surface_get_format(mCairoSurface))
{
case CAIRO_FORMAT_ARGB32:
*((unsigned long*)(&imagePixels[x*4 + y*stride]))=PrecomputeAlpha(color);
break;
case CAIRO_FORMAT_RGB24:
*((unsigned long*)(&imagePixels[x*4 + y*stride]))=GetRGB(color);
break;
case CAIRO_FORMAT_A8:
imagePixels[x + y*stride]=(unsigned char)color.a;
break;
default :
//do nothing
break;
}
}
static int
surface_get_format (lua_State *L) {
cairo_surface_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_SURFACE);
if (cairo_surface_get_type(*obj) != CAIRO_SURFACE_TYPE_IMAGE)
return luaL_error(L, "method 'get_format' only works on image surfaces");
return format_to_lua(L, cairo_image_surface_get_format(*obj));
}
static gpointer
negative_exec (GthAsyncTask *task,
gpointer user_data)
{
NegativeData *negative_data = user_data;
cairo_format_t format;
int width;
int height;
int source_stride;
int destination_stride;
unsigned char *p_source_line;
unsigned char *p_destination_line;
unsigned char *p_source;
unsigned char *p_destination;
gboolean cancelled;
double progress;
gboolean terminated;
int x, y;
unsigned char red, green, blue, alpha;
format = cairo_image_surface_get_format (negative_data->source);
width = cairo_image_surface_get_width (negative_data->source);
height = cairo_image_surface_get_height (negative_data->source);
source_stride = cairo_image_surface_get_stride (negative_data->source);
negative_data->destination = cairo_image_surface_create (format, width, height);
destination_stride = cairo_image_surface_get_stride (negative_data->destination);
p_source_line = _cairo_image_surface_flush_and_get_data (negative_data->source);
p_destination_line = _cairo_image_surface_flush_and_get_data (negative_data->destination);
for (y = 0; y < height; y++) {
gth_async_task_get_data (task, NULL, &cancelled, NULL);
if (cancelled)
return NULL;
progress = (double) y / height;
gth_async_task_set_data (task, NULL, NULL, &progress);
p_source = p_source_line;
p_destination = p_destination_line;
for (x = 0; x < width; x++) {
CAIRO_GET_RGBA (p_source, red, green, blue, alpha);
CAIRO_SET_RGBA (p_destination,
255 - red,
255 - green,
255 - blue,
alpha);
p_source += 4;
p_destination += 4;
}
p_source_line += source_stride;
p_destination_line += destination_stride;
}
cairo_surface_mark_dirty (negative_data->destination);
terminated = TRUE;
gth_async_task_set_data (task, &terminated, NULL, NULL);
return NULL;
}
Color CairoImage::getPixel(int x, int y)
{
if (!mCairoSurface)
{
throw GCN_EXCEPTION("Trying to get a pixel from a non loaded image.");
}
int stride=cairo_image_surface_get_stride(mCairoSurface);
int yindex=y*stride;
unsigned char *imagePixels=cairo_image_surface_get_data(mCairoSurface);
if (!imagePixels)
{
throw GCN_EXCEPTION("Surface data are not available (surface is not of type cairo_image_surface or has been finished)");
}
// deal differently with each surface format
switch(cairo_image_surface_get_format(mCairoSurface))
{
case CAIRO_FORMAT_ARGB32:
return GetColorFromARGB(*((unsigned long*)(&imagePixels[x*4 + yindex])));
break;
case CAIRO_FORMAT_RGB24:
return GetColorFromRGB(*((unsigned long*)(&imagePixels[x*4 + yindex])));
break;
case CAIRO_FORMAT_A8:
return Color(0,0,0,imagePixels[x + yindex]);
break;
default :
return Color(0,0,0);
//do nothing
break;
}
}
PassRefPtr<Evas_Object> evasObjectFromCairoImageSurface(Evas* canvas, cairo_surface_t* surface)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(surface, 0);
cairo_status_t status = cairo_surface_status(surface);
if (status != CAIRO_STATUS_SUCCESS) {
EINA_LOG_ERR("cairo surface is invalid: %s", cairo_status_to_string(status));
return 0;
}
cairo_surface_type_t type = cairo_surface_get_type(surface);
if (type != CAIRO_SURFACE_TYPE_IMAGE) {
EINA_LOG_ERR("unknown surface type %d, required %d (CAIRO_SURFACE_TYPE_IMAGE).",
type, CAIRO_SURFACE_TYPE_IMAGE);
return 0;
}
cairo_format_t format = cairo_image_surface_get_format(surface);
if (format != CAIRO_FORMAT_ARGB32 && format != CAIRO_FORMAT_RGB24) {
EINA_LOG_ERR("unknown surface format %d, expected %d or %d.",
format, CAIRO_FORMAT_ARGB32, CAIRO_FORMAT_RGB24);
return 0;
}
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
int stride = cairo_image_surface_get_stride(surface);
if (width <= 0 || height <= 0 || stride <= 0) {
EINA_LOG_ERR("invalid image size %dx%d, stride=%d", width, height, stride);
return 0;
}
void* data = cairo_image_surface_get_data(surface);
if (!data) {
EINA_LOG_ERR("could not get source data.");
return 0;
}
RefPtr<Evas_Object> image = adoptRef(evas_object_image_filled_add(canvas));
if (!image) {
EINA_LOG_ERR("could not add image to canvas.");
return 0;
}
evas_object_image_colorspace_set(image.get(), EVAS_COLORSPACE_ARGB8888);
evas_object_image_size_set(image.get(), width, height);
evas_object_image_alpha_set(image.get(), format == CAIRO_FORMAT_ARGB32);
if (evas_object_image_stride_get(image.get()) != stride) {
EINA_LOG_ERR("evas' stride %d diverges from cairo's %d.",
evas_object_image_stride_get(image.get()), stride);
return 0;
}
evas_object_image_data_copy_set(image.get(), data);
return image.release();
}
static cairo_bool_t
image_surface_equals (cairo_surface_t *A, cairo_surface_t *B)
{
if (cairo_image_surface_get_format (A) !=
cairo_image_surface_get_format (B))
return 0;
if (cairo_image_surface_get_width (A) !=
cairo_image_surface_get_width (B))
return 0;
if (cairo_image_surface_get_height (A) !=
cairo_image_surface_get_height (B))
return 0;
return 1;
}
static void bg(GtkStyleContext* sc, wxColour& color, int state = GTK_STATE_FLAG_NORMAL)
{
GdkRGBA* rgba;
cairo_pattern_t* pattern = NULL;
gtk_style_context_set_state(sc, GtkStateFlags(state));
gtk_style_context_get(sc, GtkStateFlags(state),
"background-color", &rgba, "background-image", &pattern, NULL);
color = wxColour(*rgba);
gdk_rgba_free(rgba);
// "background-image" takes precedence over "background-color".
// If there is an image, try to get a color out of it.
if (pattern)
{
if (cairo_pattern_get_type(pattern) == CAIRO_PATTERN_TYPE_SURFACE)
{
cairo_surface_t* surf;
cairo_pattern_get_surface(pattern, &surf);
if (cairo_surface_get_type(surf) == CAIRO_SURFACE_TYPE_IMAGE)
{
const guchar* data = cairo_image_surface_get_data(surf);
const int stride = cairo_image_surface_get_stride(surf);
// choose a pixel in the middle vertically,
// images often have a vertical gradient
const int i = stride * (cairo_image_surface_get_height(surf) / 2);
const unsigned* p = reinterpret_cast<const unsigned*>(data + i);
const unsigned pixel = *p;
guchar r, g, b, a = 0xff;
switch (cairo_image_surface_get_format(surf))
{
case CAIRO_FORMAT_ARGB32:
a = guchar(pixel >> 24);
// fallthrough
case CAIRO_FORMAT_RGB24:
r = guchar(pixel >> 16);
g = guchar(pixel >> 8);
b = guchar(pixel);
break;
default:
a = 0;
break;
}
if (a != 0)
{
if (a != 0xff)
{
// un-premultiply
r = guchar((r * 0xff) / a);
g = guchar((g * 0xff) / a);
b = guchar((b * 0xff) / a);
}
color.Set(r, g, b, a);
}
}
}
cairo_pattern_destroy(pattern);
}
cairo_surface_t *
_cairo_image_surface_transform (cairo_surface_t *source,
GthTransform transform)
{
cairo_surface_t *destination = NULL;
cairo_format_t format;
int width;
int height;
int source_stride;
int destination_width;
int destination_height;
int line_start;
int line_step;
int pixel_step;
unsigned char *p_source_line;
unsigned char *p_destination_line;
unsigned char *p_source;
unsigned char *p_destination;
int x;
if (source == NULL)
return NULL;
format = cairo_image_surface_get_format (source);
width = cairo_image_surface_get_width (source);
height = cairo_image_surface_get_height (source);
source_stride = cairo_image_surface_get_stride (source);
_cairo_image_surface_transform_get_steps (format,
width,
height,
transform,
&destination_width,
&destination_height,
&line_start,
&line_step,
&pixel_step);
destination = cairo_image_surface_create (format, destination_width, destination_height);
p_source_line = _cairo_image_surface_flush_and_get_data (source);
p_destination_line = _cairo_image_surface_flush_and_get_data (destination) + line_start;
while (height-- > 0) {
p_source = p_source_line;
p_destination = p_destination_line;
for (x = 0; x < width; x++) {
memcpy (p_destination, p_source, 4);
p_source += 4;
p_destination += pixel_step;
}
p_source_line += source_stride;
p_destination_line += line_step;
}
cairo_surface_mark_dirty (destination);
return destination;
}
static void
print_surface (const cairo_test_context_t *ctx, cairo_surface_t *surface)
{
cairo_test_log (ctx,
"%s (%dx%d)\n",
format_to_string (cairo_image_surface_get_format (surface)),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface));
}
static void
st_texture_cache_reset_texture (StTextureCachePropertyBind *bind,
const char *propname)
{
cairo_surface_t *surface;
CoglTexture *texdata;
ClutterBackend *backend = clutter_get_default_backend ();
CoglContext *ctx = clutter_backend_get_cogl_context (backend);
g_object_get (bind->source, propname, &surface, NULL);
if (surface != NULL &&
cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE &&
(cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ||
cairo_image_surface_get_format (surface) == CAIRO_FORMAT_RGB24))
{
CoglError *error = NULL;
texdata = COGL_TEXTURE (cogl_texture_2d_new_from_data (ctx,
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ?
COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888,
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_data (surface),
&error));
if (texdata)
{
clutter_texture_set_cogl_texture (bind->texture, texdata);
cogl_object_unref (texdata);
}
else if (error)
{
g_warning ("Failed to allocate texture: %s", error->message);
cogl_error_free (error);
}
clutter_actor_set_opacity (CLUTTER_ACTOR (bind->texture), 255);
}
else
clutter_actor_set_opacity (CLUTTER_ACTOR (bind->texture), 0);
}
static void pango_loadimage_ps(GVJ_t * job, usershape_t *us, boxf b, boolean filled)
{
cairo_surface_t *surface; /* source surface */
cairo_format_t format;
FILE *out = job->output_file;
int X, Y, x, y, stride;
unsigned char *data, *ix, alpha, red, green, blue;
surface = cairo_loadimage(job, us);
if (surface) {
format = cairo_image_surface_get_format(surface);
if ((format != CAIRO_FORMAT_ARGB32) && (format != CAIRO_FORMAT_RGB24))
return;
X = cairo_image_surface_get_width(surface);
Y = cairo_image_surface_get_height(surface);
stride = cairo_image_surface_get_stride(surface);
data = cairo_image_surface_get_data(surface);
fprintf(out, "save\n");
/* define image data as string array (one per raster line) */
/* see parallel code in gd_loadimage_ps(). FIXME: refactor... */
fprintf(out, "/myctr 0 def\n");
fprintf(out, "/myarray [\n");
for (y = 0; y < Y; y++) {
fprintf(out, "<");
ix = data + y * stride;
for (x = 0; x < X; x++) {
/* FIXME - this code may have endian problems */
blue = *ix++;
green = *ix++;
red = *ix++;
alpha = *ix++;
fprintf(out, "%02x%02x%02x", red, green, blue);
}
fprintf(out, ">\n");
}
fprintf(out, "] def\n");
fprintf(out,"/myproc { myarray myctr get /myctr myctr 1 add def } def\n");
/* this sets the position of the image */
fprintf(out, "%g %g translate %% lower-left coordinate\n", b.LL.x, b.LL.y);
/* this sets the rendered size to fit the box */
fprintf(out,"%g %g scale\n", b.UR.x - b.LL.x, b.UR.y - b.LL.y);
/* xsize ysize bits-per-sample [matrix] */
fprintf(out, "%d %d 8 [%d 0 0 %d 0 %d]\n", X, Y, X, -Y, Y);
fprintf(out, "{myproc} false 3 colorimage\n");
fprintf(out, "restore\n");
}
}
bool GraphicsContext3D::ImageExtractor::extractImage(bool premultiplyAlpha, bool ignoreGammaAndColorProfile)
{
if (!m_image)
return false;
// We need this to stay in scope because the native image is just a shallow copy of the data.
m_decoder = new ImageSource(premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied, ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
if (!m_decoder)
return false;
ImageSource& decoder = *m_decoder;
m_alphaOp = AlphaDoNothing;
if (m_image->data()) {
decoder.setData(m_image->data(), true);
if (!decoder.frameCount() || !decoder.frameIsCompleteAtIndex(0))
return false;
OwnPtr<NativeImageCairo> nativeImage = adoptPtr(decoder.createFrameAtIndex(0));
m_imageSurface = nativeImage->surface();
} else {
NativeImageCairo* nativeImage = m_image->nativeImageForCurrentFrame();
m_imageSurface = (nativeImage) ? nativeImage->surface() : 0;
// 1. For texImage2D with HTMLVideoElment input, assume no PremultiplyAlpha had been applied and the alpha value is 0xFF for each pixel,
// which is true at present and may be changed in the future and needs adjustment accordingly.
// 2. For texImage2D with HTMLCanvasElement input in which Alpha is already Premultiplied in this port,
// do AlphaDoUnmultiply if UNPACK_PREMULTIPLY_ALPHA_WEBGL is set to false.
if (!premultiplyAlpha && m_imageHtmlDomSource != HtmlDomVideo)
m_alphaOp = AlphaDoUnmultiply;
}
if (!m_imageSurface)
return false;
m_imageWidth = cairo_image_surface_get_width(m_imageSurface.get());
m_imageHeight = cairo_image_surface_get_height(m_imageSurface.get());
if (!m_imageWidth || !m_imageHeight)
return false;
if (cairo_image_surface_get_format(m_imageSurface.get()) != CAIRO_FORMAT_ARGB32)
return false;
unsigned int srcUnpackAlignment = 1;
size_t bytesPerRow = cairo_image_surface_get_stride(m_imageSurface.get());
size_t bitsPerPixel = 32;
unsigned padding = bytesPerRow - bitsPerPixel / 8 * m_imageWidth;
if (padding) {
srcUnpackAlignment = padding + 1;
while (bytesPerRow % srcUnpackAlignment)
++srcUnpackAlignment;
}
m_imagePixelData = cairo_image_surface_get_data(m_imageSurface.get());
m_imageSourceFormat = DataFormatBGRA8;
m_imageSourceUnpackAlignment = srcUnpackAlignment;
return true;
}
static int alloc(struct vidsrc_st **stp, const struct vidsrc *vs,
struct media_ctx **ctx, struct vidsrc_prm *prm,
const struct vidsz *size, const char *fmt,
const char *dev, vidsrc_frame_h *frameh,
vidsrc_error_h *errorh, void *arg)
{
struct vidsrc_st *st;
int err = 0;
(void)ctx;
(void)fmt;
(void)dev;
(void)errorh;
if (!stp || !prm || !size || !frameh)
return EINVAL;
st = mem_zalloc(sizeof(*st), destructor);
if (!st)
return ENOMEM;
st->vs = vs;
st->frameh = frameh;
st->arg = arg;
st->prm = *prm;
st->size = *size;
st->surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
size->w, size->h);
st->cr = cairo_create(st->surface);
info("cairo: surface with format %d (%d x %d) stride=%d\n",
cairo_image_surface_get_format(st->surface),
cairo_image_surface_get_width(st->surface),
cairo_image_surface_get_height(st->surface),
cairo_image_surface_get_stride(st->surface));
st->step = rand_u16() / 1000.0;
st->run = true;
err = pthread_create(&st->thread, NULL, read_thread, st);
if (err) {
st->run = false;
goto out;
}
out:
if (err)
mem_deref(st);
else
*stp = st;
return err;
}
gfxImageSurface::gfxImageSurface(cairo_surface_t *csurf)
{
mSize.width = cairo_image_surface_get_width(csurf);
mSize.height = cairo_image_surface_get_height(csurf);
mData = cairo_image_surface_get_data(csurf);
mFormat = (gfxImageFormat) cairo_image_surface_get_format(csurf);
mOwnsData = PR_FALSE;
mStride = cairo_image_surface_get_stride(csurf);
Init(csurf, PR_TRUE);
}
static void
cdisplay_lcms_convert_surface (GimpColorDisplay *display,
cairo_surface_t *surface)
{
CdisplayLcms *lcms = CDISPLAY_LCMS (display);
gint width = cairo_image_surface_get_width (surface);
gint height = cairo_image_surface_get_height (surface);
gint stride = cairo_image_surface_get_stride (surface);
guchar *buf = cairo_image_surface_get_data (surface);
cairo_format_t fmt = cairo_image_surface_get_format (surface);
guchar *rowbuf;
gint x, y;
guchar r, g, b, a;
if (fmt != CAIRO_FORMAT_ARGB32)
return;
if (! lcms->transform)
return;
rowbuf = g_malloc (stride);
for (y = 0; y < height; y++, buf += stride)
{
/* Switch buf from ARGB premul to ARGB non-premul, since lcms ignores the
* alpha channel. The macro takes care of byte order.
*/
for (x = 0; x < width; x++)
{
GIMP_CAIRO_ARGB32_GET_PIXEL (buf + 4*x, r, g, b, a);
rowbuf[4*x+0] = a;
rowbuf[4*x+1] = r;
rowbuf[4*x+2] = g;
rowbuf[4*x+3] = b;
}
cmsDoTransform (lcms->transform, rowbuf, rowbuf, width);
/* And back to ARGB premul */
for (x = 0; x < width; x++)
{
a = rowbuf[4*x+0];
r = rowbuf[4*x+1];
g = rowbuf[4*x+2];
b = rowbuf[4*x+3];
GIMP_CAIRO_ARGB32_SET_PIXEL (buf + 4*x, r, g, b, a);
}
}
g_free (rowbuf);
}
bool GraphicsContext3D::getImageData(Image* image, unsigned int format, unsigned int type, bool premultiplyAlpha, bool ignoreGammaAndColorProfile, Vector<uint8_t>& outputVector)
{
if (!image)
return false;
// We need this to stay in scope because the native image is just a shallow copy of the data.
ImageSource decoder(premultiplyAlpha ? ImageSource::AlphaPremultiplied : ImageSource::AlphaNotPremultiplied,
ignoreGammaAndColorProfile ? ImageSource::GammaAndColorProfileIgnored : ImageSource::GammaAndColorProfileApplied);
AlphaOp alphaOp = AlphaDoNothing;
RefPtr<cairo_surface_t> imageSurface;
if (image->data()) {
decoder.setData(image->data(), true);
if (!decoder.frameCount() || !decoder.frameIsCompleteAtIndex(0))
return false;
OwnPtr<NativeImageCairo> nativeImage = adoptPtr(decoder.createFrameAtIndex(0));
imageSurface = nativeImage->surface();
} else {
imageSurface = image->nativeImageForCurrentFrame()->surface();
if (!premultiplyAlpha)
alphaOp = AlphaDoUnmultiply;
}
if (!imageSurface)
return false;
int width = cairo_image_surface_get_width(imageSurface.get());
int height = cairo_image_surface_get_height(imageSurface.get());
if (!width || !height)
return false;
if (cairo_image_surface_get_format(imageSurface.get()) != CAIRO_FORMAT_ARGB32)
return false;
unsigned int srcUnpackAlignment = 1;
size_t bytesPerRow = cairo_image_surface_get_stride(imageSurface.get());
size_t bitsPerPixel = 32;
unsigned int padding = bytesPerRow - bitsPerPixel / 8 * width;
if (padding) {
srcUnpackAlignment = padding + 1;
while (bytesPerRow % srcUnpackAlignment)
++srcUnpackAlignment;
}
unsigned int packedSize;
// Output data is tightly packed (alignment == 1).
if (computeImageSizeInBytes(format, type, width, height, 1, &packedSize, 0) != GraphicsContext3D::NO_ERROR)
return false;
outputVector.resize(packedSize);
return packPixels(cairo_image_surface_get_data(imageSurface.get()), SourceFormatBGRA8,
width, height, srcUnpackAlignment, format, type, alphaOp, outputVector.data());
}
gboolean
_cairo_image_surface_get_has_alpha (cairo_surface_t *surface)
{
cairo_surface_metadata_t *metadata;
if (surface == NULL)
return FALSE;
metadata = cairo_surface_get_user_data (surface, &surface_metadata_key);
if (metadata != NULL)
return metadata->has_alpha;
return cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32;
}
PassRefPtr<cairo_surface_t> copyCairoImageSurface(cairo_surface_t* originalSurface)
{
// Cairo doesn't provide a way to copy a cairo_surface_t.
// See http://lists.cairographics.org/archives/cairo/2007-June/010877.html
// Once cairo provides the way, use the function instead of this.
RefPtr<cairo_surface_t> newSurface = adoptRef(cairo_image_surface_create(cairo_image_surface_get_format(originalSurface),
cairo_image_surface_get_width(originalSurface),
cairo_image_surface_get_height(originalSurface)));
RefPtr<cairo_t> cr = adoptRef(cairo_create(newSurface.get()));
cairo_set_source_surface(cr.get(), originalSurface, 0, 0);
cairo_set_operator(cr.get(), CAIRO_OPERATOR_SOURCE);
cairo_paint(cr.get());
return newSurface.release();
}
cairo_surface_t *
_cairo_boilerplate_get_image_surface (cairo_surface_t *src,
int page,
int width,
int height)
{
cairo_surface_t *surface;
cairo_t *cr;
#if 0
if (cairo_surface_get_type (src) == CAIRO_SURFACE_TYPE_IMAGE) {
int ww = cairo_image_surface_get_width (src);
int hh = cairo_image_surface_get_height (src);
if (width == ww && hh == height) {
return cairo_surface_reference (src);
} else {
cairo_format_t format = cairo_image_surface_get_format (src);
unsigned char *data = cairo_image_surface_get_data (src);
int stride = cairo_image_surface_get_stride (src);
data += stride * (hh - height) + 4 * (ww - width);
return cairo_image_surface_create_for_data (data,
format,
width,
height,
stride);
}
}
#endif
if (page != 0)
return cairo_boilerplate_surface_create_in_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
/* extract sub-surface */
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
cr = cairo_create (surface);
cairo_surface_destroy (surface);
cairo_set_source_surface (cr, src, 0, 0);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
surface = cairo_surface_reference (cairo_get_target (cr));
cairo_destroy (cr);
return surface;
}
static void
cdisplay_gamma_convert_surface (GimpColorDisplay *display,
cairo_surface_t *surface)
{
CdisplayGamma *gamma = CDISPLAY_GAMMA (display);
gint width = cairo_image_surface_get_width (surface);
gint height = cairo_image_surface_get_height (surface);
gint stride = cairo_image_surface_get_stride (surface);
guchar *buf = cairo_image_surface_get_data (surface);
cairo_format_t fmt = cairo_image_surface_get_format (surface);
gint i, j, skip;
gint r, g, b, a;
if (fmt != CAIRO_FORMAT_ARGB32)
return;
/* You will not be using the entire buffer most of the time.
* Hence, the simplistic code for this is as follows:
*
* for (j = 0; j < height; j++)
* {
* for (i = 0; i < width * bpp; i++)
* buf[i] = lookup[buf[i]];
* buf += bpl;
* }
*/
j = height;
skip = stride - 4 * width;
while (j--)
{
i = width;
while (i--)
{
GIMP_CAIRO_ARGB32_GET_PIXEL (buf, r, g, b, a);
r = gamma->lookup[r];
g = gamma->lookup[g];
b = gamma->lookup[b];
GIMP_CAIRO_ARGB32_SET_PIXEL (buf, r, g, b, a);
buf += 4;
}
buf += skip;
}
}
void
ol_gussian_blur (cairo_surface_t *surface,
double sigma)
{
ol_assert (surface != NULL);
ol_assert (sigma > 0);
cairo_format_t format = cairo_image_surface_get_format (surface);
if (format != CAIRO_FORMAT_ARGB32)
{
ol_errorf ("The surface format is %d, only ARGB32 is supported\n",
format);
return;
}
int kernel_size;
int *kernel = _calc_kernel (sigma, &kernel_size);
_apply_kernel (surface, kernel, kernel_size);
g_free (kernel);
}
const Babl *
gimp_cairo_surface_get_format (cairo_surface_t *surface)
{
g_return_val_if_fail (surface != NULL, NULL);
g_return_val_if_fail (cairo_surface_get_type (surface) ==
CAIRO_SURFACE_TYPE_IMAGE, NULL);
switch (cairo_image_surface_get_format (surface))
{
case CAIRO_FORMAT_RGB24: return babl_format ("cairo-RGB24");
case CAIRO_FORMAT_ARGB32: return babl_format ("cairo-ARGB32");
default:
break;
}
g_return_val_if_reached (NULL);
}
