int
main (int argc, char **argv)
{
uint32_t dst[SIZE];
pixman_image_t *src_img;
pixman_image_t *dst_img;
int i, j, x, y;
int ret = 0;
for (i = 0; i < n_test_cases; ++i)
{
for (j = 0; j < 2; ++j)
{
src_img = pixman_image_create_bits (testcases[i].format,
testcases[i].width,
testcases[i].height,
testcases[i].src,
testcases[i].stride);
pixman_image_set_indexed(src_img, testcases[i].indexed);
dst_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
testcases[i].width,
testcases[i].height,
dst,
testcases[i].width*4);
if (j)
{
pixman_image_set_accessors (src_img, reader, writer);
pixman_image_set_accessors (dst_img, reader, writer);
}
pixman_image_composite (PIXMAN_OP_SRC, src_img, NULL, dst_img,
0, 0, 0, 0, 0, 0, testcases[i].width, testcases[i].height);
pixman_image_unref (src_img);
pixman_image_unref (dst_img);
for (y = 0; y < testcases[i].height; ++y)
{
for (x = 0; x < testcases[i].width; ++x)
{
int offset = y * testcases[i].width + x;
if (dst[offset] != testcases[i].dst[offset])
{
printf ("test %i%c: pixel mismatch at (x=%d,y=%d): %08x expected, %08x obtained\n",
i + 1, 'a' + j,
x, y,
testcases[i].dst[offset], dst[offset]);
ret = 1;
}
}
}
}
}
return ret;
}
void mSDLSWDeinit(struct mSDLRenderer* renderer) {
if (renderer->ratio > 1) {
free(renderer->outputBuffer);
}
#if !SDL_VERSION_ATLEAST(2, 0, 0)
SDL_Surface* surface = SDL_GetVideoSurface();
SDL_UnlockSurface(surface);
#ifdef USE_PIXMAN
pixman_image_unref(renderer->pix);
pixman_image_unref(renderer->screenpix);
#endif
#endif
}
static pixman_bool_t
do_check (int i)
{
pixman_image_t *source, *dest, *mask;
pixman_op_t op;
int x, y, width, height;
pixman_image_t *dest_copy;
pixman_bool_t result = TRUE;
pixman_bool_t component_alpha;
prng_srand (i);
op = RANDOM_ELT (operators);
x = prng_rand_n (MAX_WIDTH);
y = prng_rand_n (MAX_HEIGHT);
width = prng_rand_n (MAX_WIDTH) + 4;
height = prng_rand_n (MAX_HEIGHT) + 4;
source = create_image (NULL);
mask = create_image (NULL);
dest = create_image (&dest_copy);
if (x >= dest->bits.width)
x = dest->bits.width / 2;
if (y >= dest->bits.height)
y = dest->bits.height / 2;
if (x + width > dest->bits.width)
width = dest->bits.width - x;
if (y + height > dest->bits.height)
height = dest->bits.height - y;
component_alpha = prng_rand_n (2);
pixman_image_set_component_alpha (mask, component_alpha);
pixman_image_composite32 (op, source, mask, dest,
0, 0, 0, 0,
x, y, width, height);
if (!verify (i, op, source, mask, dest, dest_copy,
x, y, width, height, component_alpha))
{
result = FALSE;
}
pixman_image_unref (source);
pixman_image_unref (mask);
pixman_image_unref (dest);
pixman_image_unref (dest_copy);
return result;
}
int
main ()
{
int o, s, m, d;
enable_fp_exceptions();
for (o = 0; o < ARRAY_LENGTH (pdf_ops); ++o)
{
pixman_op_t op = pdf_ops[o];
for (s = 0; s < ARRAY_LENGTH (pixels); ++s)
{
pixman_image_t *src;
src = pixman_image_create_bits (
PIXMAN_a8r8g8b8, 1, 1, (uint32_t *)&(pixels[s]), 4);
for (m = -1; m < ARRAY_LENGTH (pixels); ++m)
{
pixman_image_t *msk = NULL;
if (m >= 0)
{
msk = pixman_image_create_bits (
PIXMAN_a8r8g8b8, 1, 1, (uint32_t *)&(pixels[m]), 4);
}
for (d = 0; d < ARRAY_LENGTH (pixels); ++d)
{
pixman_image_t *dst;
uint32_t dp = pixels[d];
dst = pixman_image_create_bits (
PIXMAN_a8r8g8b8, 1, 1, &dp, 4);
pixman_image_composite (op, src, msk, dst,
0, 0, 0, 0, 0, 0, 1, 1);
pixman_image_unref (dst);
}
if (msk)
pixman_image_unref (msk);
}
pixman_image_unref (src);
}
}
return 0;
}
static void
Transform(DataSourceSurface* aDest,
DataSourceSurface* aSource,
const gfx3DMatrix& aTransform,
const Point& aDestOffset)
{
IntSize destSize = aDest->GetSize();
pixman_image_t* dest = pixman_image_create_bits(PIXMAN_a8r8g8b8,
destSize.width,
destSize.height,
(uint32_t*)aDest->GetData(),
aDest->Stride());
IntSize srcSize = aSource->GetSize();
pixman_image_t* src = pixman_image_create_bits(PIXMAN_a8r8g8b8,
srcSize.width,
srcSize.height,
(uint32_t*)aSource->GetData(),
aSource->Stride());
MOZ_ASSERT(src !=0 && dest != 0, "Failed to create pixman images?");
pixman_transform pixTransform = Matrix3DToPixman(aTransform);
pixman_transform pixTransformInverted;
// If the transform is singular then nothing would be drawn anyway, return here
if (!pixman_transform_invert(&pixTransformInverted, &pixTransform)) {
pixman_image_unref(dest);
pixman_image_unref(src);
return;
}
pixman_image_set_transform(src, &pixTransformInverted);
pixman_image_composite32(PIXMAN_OP_SRC,
src,
nullptr,
dest,
aDestOffset.x,
aDestOffset.y,
0,
0,
0,
0,
destSize.width,
destSize.height);
pixman_image_unref(dest);
pixman_image_unref(src);
}
WL_EXPORT void
pixman_renderer_output_destroy(struct weston_output *output)
{
struct pixman_output_state *po = get_output_state(output);
pixman_image_unref(po->shadow_image);
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
po->shadow_image = NULL;
po->hw_buffer = NULL;
free(po);
}
void qemu_pixman_image_unref(pixman_image_t *image)
{
if (image == NULL) {
return;
}
pixman_image_unref(image);
}
Bool ReUseSurface(GALINFOPTR galInfo, PixmapPtr pPixmap, Viv2DPixmapPtr toBeUpdatedpPix)
{
GenericSurfacePtr surf = gcvNULL;
gctUINT alignedWidth, alignedHeight;
gctUINT bytesPerPixel;
alignedWidth = gcmALIGN(pPixmap->drawable.width, WIDTH_ALIGNMENT);
alignedHeight = gcmALIGN(pPixmap->drawable.height, HEIGHT_ALIGNMENT);
bytesPerPixel = BITSTOBYTES(pPixmap->drawable.bitsPerPixel);
/* The same as CreatSurface */
if (bytesPerPixel < 2) {
bytesPerPixel = 2;
}
surf = (GenericSurfacePtr)toBeUpdatedpPix->mVidMemInfo;
if ( surf && surf->mVideoNode.mSizeInBytes >= (alignedWidth * alignedHeight * bytesPerPixel))
{
surf->mTiling = gcvLINEAR;
surf->mAlignedWidth = alignedWidth;
surf->mAlignedHeight = alignedHeight;
surf->mStride = alignedWidth * bytesPerPixel;
surf->mRotation = gcvSURF_0_DEGREE;
surf->mLogicalAddr = surf->mVideoNode.mLogicalAddr;
surf->mIsWrapped = gcvFALSE;
if ( surf->mData )
pixman_image_unref( (pixman_image_t *)surf->mData );
surf->mData = gcvNULL;
TRACE_EXIT(TRUE);
}
TRACE_EXIT(FALSE);
}
static cairo_int_status_t
composite_paint (cairo_image_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *pattern,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents)
{
cairo_rectangle_int_t sample;
pixman_image_t *src;
int src_x, src_y;
_cairo_pattern_sampled_area (pattern, extents, &sample);
src = _pixman_image_for_pattern (dst,
pattern, FALSE,
extents, &sample,
&src_x, &src_y);
if (unlikely (src == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
pixman_image_composite32 (_pixman_operator (op),
src, NULL, dst->pixman_image,
extents->x + src_x, extents->y + src_y,
0, 0,
extents->x - dst_x, extents->y - dst_y,
extents->width, extents->height);
pixman_image_unref (src);
return CAIRO_STATUS_SUCCESS;
}
static int
pixman_renderer_surface_copy_content(struct weston_surface *surface,
void *target, size_t size,
int src_x, int src_y,
int width, int height)
{
const pixman_format_code_t format = PIXMAN_a8b8g8r8;
const size_t bytespp = 4; /* PIXMAN_a8b8g8r8 */
struct pixman_surface_state *ps = get_surface_state(surface);
pixman_image_t *out_buf;
if (!ps->image)
return -1;
out_buf = pixman_image_create_bits(format, width, height,
target, width * bytespp);
pixman_image_set_transform(ps->image, NULL);
pixman_image_composite32(PIXMAN_OP_SRC,
ps->image, /* src */
NULL, /* mask */
out_buf, /* dest */
src_x, src_y, /* src_x, src_y */
0, 0, /* mask_x, mask_y */
0, 0, /* dest_x, dest_y */
width, height);
pixman_image_unref(out_buf);
return 0;
}
void PixmanBitmap::BlendBlit(int x, int y, Bitmap* _src, Rect src_rect, const Color& color) {
PixmanBitmap* src = (PixmanBitmap*) _src;
if (color.alpha == 0) {
if (_src != this)
Blit(x, y, _src, src_rect, 255);
return;
}
if (src != this)
pixman_image_composite32(PIXMAN_OP_SRC,
src->bitmap, (pixman_image_t*) NULL, bitmap,
src_rect.x, src_rect.y,
0, 0,
x, y,
src_rect.width, src_rect.height);
pixman_color_t tcolor = PixmanColor(color);
pixman_image_t* timage = pixman_image_create_solid_fill(&tcolor);
pixman_image_composite32(PIXMAN_OP_OVER,
timage, src->bitmap, bitmap,
0, 0,
src_rect.x, src_rect.y,
x, y,
src_rect.width, src_rect.height);
pixman_image_unref(timage);
RefreshCallback();
}
void PixmanBitmap::OpacityBlit(int x, int y, Bitmap* _src, Rect src_rect, int opacity) {
PixmanBitmap* src = (PixmanBitmap*) _src;
if (opacity == 255) {
if (_src != this)
Blit(x, y, _src, src_rect, opacity);
return;
}
if (src == this) {
pixman_color_t pcolor = {0, 0, 0, opacity << 8};
pixman_rectangle16_t rect = {src_rect.x, src_rect.y, src_rect.width, src_rect.height};
pixman_image_fill_rectangles(PIXMAN_OP_IN_REVERSE, bitmap, &pcolor, 1, &rect);
}
else {
if (opacity > 255)
opacity = 255;
pixman_color_t tcolor = {0, 0, 0, opacity << 8};
pixman_image_t* mask = pixman_image_create_solid_fill(&tcolor);
pixman_image_composite32(PIXMAN_OP_OVER,
src->bitmap, mask, bitmap,
src_rect.x, src_rect.y,
0, 0,
x, y,
src_rect.width, src_rect.height);
pixman_image_unref(mask);
}
RefreshCallback();
}
void PixmanBitmap::WaverBlit(int x, int y, Bitmap* _src, Rect src_rect, int depth, double phase, int opacity) {
if (opacity < 0)
return;
PixmanBitmap* src = (PixmanBitmap*) _src;
if (opacity > 255) opacity = 255;
pixman_image_t* mask;
if (opacity < 255) {
pixman_color_t tcolor = {0, 0, 0, opacity << 8};
mask = pixman_image_create_solid_fill(&tcolor);
}
else
mask = (pixman_image_t*) NULL;
for (int i = 0; i < src_rect.height; i++) {
int offset = (int) (depth * (1 + sin((phase + i * 20) * 3.14159 / 180)));
pixman_image_composite32(PIXMAN_OP_OVER,
src->bitmap, mask, bitmap,
src_rect.x, src_rect.y + i,
0, 0,
x + offset, y + i,
src_rect.width, 1);
}
if (mask != NULL)
pixman_image_unref(mask);
RefreshCallback();
}
cairo_surface_t *
_cairo_image_surface_create_with_pixman_format (unsigned char *data,
pixman_format_code_t pixman_format,
int width,
int height,
int stride)
{
cairo_surface_t *surface;
pixman_image_t *pixman_image;
if (! _cairo_image_surface_is_size_valid (width, height))
{
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_SIZE));
}
pixman_image = pixman_image_create_bits (pixman_format, width, height,
(uint32_t *) data, stride);
if (unlikely (pixman_image == NULL))
return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
surface = _cairo_image_surface_create_for_pixman_image (pixman_image,
pixman_format);
if (unlikely (surface->status)) {
pixman_image_unref (pixman_image);
return surface;
}
/* we can not make any assumptions about the initial state of user data */
surface->is_clear = data == NULL;
return surface;
}
void PixmanBitmap::Blit(int x, int y, Bitmap* _src, Rect src_rect, int opacity) {
if (opacity < 0)
return;
PixmanBitmap* src = (PixmanBitmap*) _src;
if (opacity > 255) opacity = 255;
pixman_image_t* mask;
if (opacity < 255) {
pixman_color_t tcolor = {0, 0, 0, opacity << 8};
mask = pixman_image_create_solid_fill(&tcolor);
}
else
mask = (pixman_image_t*) NULL;
pixman_image_composite32(PIXMAN_OP_OVER,
src->bitmap, mask, bitmap,
src_rect.x, src_rect.y,
0, 0,
x, y,
src_rect.width, src_rect.height);
if (mask != NULL)
pixman_image_unref(mask);
RefreshCallback();
}
static void process_image_data(struct fp_img_dev *dev, char **output, int *output_height)
{
//pixman stuff taken from libfprint/pixman.c, adapted for my purposes.
pixman_image_t *orig, *resized;
pixman_transform_t transform;
struct vfs0050_dev *vfs_dev = dev->priv;
struct vfs0050_line *line, *calibration_line;
char *buf = malloc(vfs_dev->scanbuf_idx);
int lines = vfs_dev->scanbuf_idx / VFS0050_FRAME_SIZE;
int i, x, sum, last_sum, diff;
int new_height;
//just grab one around middle, there should be 100
calibration_line = (struct vfs0050_line *) ((char *) vfs_dev->calbuf + (50 * VFS0050_FRAME_SIZE));
new_height = 0;
for (i = 0; i < lines; i++) {
line = (struct vfs0050_line *) ((char *) vfs_dev->scanbuf + (i * VFS0050_FRAME_SIZE));
if (!is_noise(line))
memcpy(buf + (new_height++ * VFS0050_IMG_WIDTH), line->row, VFS0050_IMG_WIDTH);
else
fp_dbg("removed noise at line: %d\n", i);
}
orig = pixman_image_create_bits(PIXMAN_a8, VFS0050_IMG_WIDTH, new_height, (uint32_t *) buf, VFS0050_IMG_WIDTH);
new_height *= VFS0050_SCALE_FACTOR; //scale for resized image
resized = pixman_image_create_bits(PIXMAN_a8, VFS0050_IMG_WIDTH, new_height, NULL, VFS0050_IMG_WIDTH);
pixman_transform_init_identity(&transform);
pixman_transform_scale(NULL, &transform, pixman_int_to_fixed(1), pixman_double_to_fixed(0.2));
pixman_image_set_transform(orig, &transform);
pixman_image_set_filter(orig, PIXMAN_FILTER_BEST, NULL, 0);
pixman_image_composite32(PIXMAN_OP_SRC,
orig,
NULL,
resized,
0, 0,
0, 0,
0, 0,
VFS0050_IMG_WIDTH, new_height
);
memcpy(buf, pixman_image_get_data(resized), VFS0050_IMG_WIDTH * new_height);
pixman_image_unref(orig);
pixman_image_unref(resized);
*output_height = new_height;
*output = buf;
}
void sw_render_free_texture(struct render_t * render, struct texture_t * texture)
{
if(!render || !texture)
return;
pixman_image_unref((pixman_image_t *)texture->priv);
free(texture);
}
/************************************************************************
* PIXMAP RELATED (START)
************************************************************************/
static gctBOOL FreeGPUSurface(VIVGPUPtr gpuctx, Viv2DPixmapPtr ppriv) {
TRACE_ENTER();
gceSTATUS status = gcvSTATUS_OK;
GenericSurfacePtr surf = gcvNULL;
gceSURF_TYPE surftype;
Bool cacheable;
surf = (GenericSurfacePtr) (ppriv->mVidMemInfo);
if (surf->mIsWrapped) {
goto delete_wrapper;
}
TRACE_INFO("DESTROYED SURFACE ADDRESS = %x - %x\n", surf, ppriv->mVidMemInfo);
surf = AddGSurfIntoPool(surf);
if ( surf ==NULL )
{
ppriv->mVidMemInfo = NULL;
TRACE_EXIT(gcvTRUE);
}
if ( surf->mData )
pixman_image_unref( (pixman_image_t *)surf->mData );
surf->mData = gcvNULL;
if ( surf->mAlignedWidth >= IMX_EXA_NONCACHESURF_WIDTH && surf->mAlignedHeight >= IMX_EXA_NONCACHESURF_HEIGHT )
{
surftype = gcvSURF_BITMAP;
cacheable = FALSE;
} else {
surftype = SURFACE_TYPE;
cacheable = SURFACE_CACHEABLE;
}
if (surf->mVideoNode.mNode != gcvNULL) {
if (surf->mVideoNode.mLogicalAddr != gcvNULL) {
status = UnlockVideoNode(gpuctx->mDriver->mHal, surf->mVideoNode.mNode, surftype);
if (status != gcvSTATUS_OK) {
TRACE_ERROR("Unable to UnLock video node\n");
TRACE_EXIT(gcvFALSE);
}
}
status = FreeVideoNode(gpuctx->mDriver->mHal, surf->mVideoNode.mNode);
if (status != gcvSTATUS_OK) {
TRACE_ERROR("Unable to Free video node\n");
TRACE_EXIT(gcvFALSE);
}
delete_wrapper:
status = gcoOS_Free(gcvNULL, surf);
if (status != gcvSTATUS_OK) {
TRACE_ERROR("Unable to Free surface\n");
TRACE_EXIT(gcvFALSE);
}
ppriv->mVidMemInfo = NULL;
}
TRACE_EXIT(gcvTRUE);
}
static cairo_int_status_t
composite_traps (cairo_image_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *pattern,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents)
{
composite_traps_info_t *info = closure;
cairo_rectangle_int_t sample;
pixman_image_t *src, *mask;
int src_x, src_y;
TRACE ((stderr, "%s\n", __FUNCTION__));
_cairo_pattern_sampled_area (pattern, extents, &sample);
src = _pixman_image_for_pattern (dst, pattern, FALSE,
extents, &sample,
&src_x, &src_y);
if (unlikely (src == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
mask = pixman_image_create_bits (info->antialias == CAIRO_ANTIALIAS_NONE ? PIXMAN_a1 : PIXMAN_a8,
extents->width, extents->height,
NULL, 0);
if (unlikely (mask == NULL)) {
pixman_image_unref (src);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
_pixman_image_add_traps (mask, extents->x, extents->y, &info->traps);
pixman_image_composite32 (_pixman_operator (op),
src, mask, dst->pixman_image,
extents->x + src_x - dst_x, extents->y + src_y - dst_y,
0, 0,
extents->x - dst_x, extents->y - dst_y,
extents->width, extents->height);
pixman_image_unref (mask);
pixman_image_unref (src);
return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t
composite_mask (cairo_image_surface_t *dst,
void *closure,
cairo_operator_t op,
const cairo_pattern_t *pattern,
int dst_x,
int dst_y,
const cairo_rectangle_int_t *extents)
{
cairo_rectangle_int_t sample;
pixman_image_t *src, *mask;
int src_x, src_y;
int mask_x, mask_y;
TRACE ((stderr, "%s\n", __FUNCTION__));
_cairo_pattern_sampled_area (pattern, extents, &sample);
src = _pixman_image_for_pattern (dst, pattern, FALSE,
extents, &sample,
&src_x, &src_y);
if (unlikely (src == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
_cairo_pattern_sampled_area (closure, extents, &sample);
mask = _pixman_image_for_pattern (dst, closure, TRUE,
extents, &sample,
&mask_x, &mask_y);
if (unlikely (mask == NULL)) {
pixman_image_unref (src);
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
}
pixman_image_composite32 (_pixman_operator (op),
src, mask, dst->pixman_image,
extents->x + src_x, extents->y + src_y,
extents->x + mask_x, extents->y + mask_y,
extents->x - dst_x, extents->y - dst_y,
extents->width, extents->height);
pixman_image_unref (mask);
pixman_image_unref (src);
return CAIRO_STATUS_SUCCESS;
}
void PixmanBitmap::TiledBlit(int ox, int oy, Rect src_rect, Bitmap* src, Rect dst_rect, int opacity) {
if (opacity < 0)
return;
if (opacity > 255) opacity = 255;
if (ox >= src_rect.width) ox %= src_rect.width;
if (oy >= src_rect.height) ox %= src_rect.height;
if (ox < 0) ox += src_rect.width * ((-ox + src_rect.width - 1) / src_rect.width);
if (oy < 0) oy += src_rect.height * ((-oy + src_rect.height - 1) / src_rect.height);
pixman_image_t* src_bm = GetSubimage(src, src_rect);
pixman_image_t* mask;
if (opacity < 255) {
pixman_color_t tcolor = {0, 0, 0, opacity << 8};
mask = pixman_image_create_solid_fill(&tcolor);
}
else
mask = (pixman_image_t*) NULL;
pixman_image_set_repeat(src_bm, PIXMAN_REPEAT_NORMAL);
pixman_transform_t xform;
pixman_transform_init_translate(&xform,
pixman_int_to_fixed(ox),
pixman_int_to_fixed(oy));
pixman_image_set_transform(src_bm, &xform);
pixman_image_composite32(PIXMAN_OP_OVER,
src_bm, mask, bitmap,
0, 0,
0, 0,
dst_rect.x, dst_rect.y,
dst_rect.width, dst_rect.height);
pixman_image_unref(src_bm);
if (mask != NULL)
pixman_image_unref(mask);
RefreshCallback();
}
int
main (int argc, char **argv)
{
#define WIDTH 400
#define HEIGHT 200
int y, x, p;
float alpha;
uint32_t *dest = malloc (WIDTH * HEIGHT * 4);
uint32_t *src1 = malloc (WIDTH * HEIGHT * 4);
pixman_image_t *dest_img, *src1_img;
dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8_sRGB,
WIDTH, HEIGHT,
dest,
WIDTH * 4);
src1_img = pixman_image_create_bits (PIXMAN_a8r8g8b8,
WIDTH, HEIGHT,
src1,
WIDTH * 4);
for (y = 0; y < HEIGHT; y ++)
{
p = WIDTH * y;
for (x = 0; x < WIDTH; x ++)
{
alpha = (float) x / WIDTH;
src1[p + x] = linear_argb_to_premult_argb (alpha, 1, 0, 1);
dest[p + x] = linear_argb_to_premult_srgb_argb (1-alpha, 0, 1, 0);
}
}
pixman_image_composite (PIXMAN_OP_ADD, src1_img, NULL, dest_img,
0, 0, 0, 0, 0, 0, WIDTH, HEIGHT);
pixman_image_unref (src1_img);
free (src1);
show_image (dest_img);
pixman_image_unref (dest_img);
free (dest);
return 0;
}
cairo_image_surface_t *
_cairo_image_surface_create_from_image (cairo_image_surface_t *other,
pixman_format_code_t format,
int x, int y,
int width, int height, int stride)
{
cairo_image_surface_t *surface;
cairo_status_t status;
pixman_image_t *image;
void *mem = NULL;
status = other->base.status;
if (unlikely (status))
goto cleanup;
if (stride) {
mem = _cairo_malloc_ab (height, stride);
if (unlikely (mem == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup;
}
}
image = pixman_image_create_bits (format, width, height, mem, stride);
if (unlikely (image == NULL)) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
goto cleanup_mem;
}
surface = (cairo_image_surface_t *)
_cairo_image_surface_create_for_pixman_image (image, format);
if (unlikely (surface->base.status)) {
status = surface->base.status;
goto cleanup_image;
}
pixman_image_composite32 (PIXMAN_OP_SRC,
other->pixman_image, NULL, image,
x, y,
0, 0,
0, 0,
width, height);
surface->base.is_clear = FALSE;
surface->owns_data = mem != NULL;
return surface;
cleanup_image:
pixman_image_unref (image);
cleanup_mem:
free (mem);
cleanup:
return (cairo_image_surface_t *) _cairo_surface_create_in_error (status);
}
void qemu_pixman_glyph_render(pixman_image_t *glyph,
pixman_image_t *surface,
pixman_color_t *fgcol,
pixman_color_t *bgcol,
int x, int y, int cw, int ch)
{
pixman_image_t *ifg = pixman_image_create_solid_fill(fgcol);
pixman_image_t *ibg = pixman_image_create_solid_fill(bgcol);
pixman_image_composite(PIXMAN_OP_SRC, ibg, NULL, surface,
0, 0, 0, 0,
cw * x, ch * y,
cw, ch);
pixman_image_composite(PIXMAN_OP_OVER, ifg, glyph, surface,
0, 0, 0, 0,
cw * x, ch * y,
cw, ch);
pixman_image_unref(ifg);
pixman_image_unref(ibg);
}
/* This test demonstrates that clipping is done totally different depending
* on whether the source is transformed or not.
*/
int
main (int argc, char **argv)
{
#define WIDTH 200
#define HEIGHT 200
#define SMALL 25
uint32_t *sbits = malloc (SMALL * SMALL * 4);
uint32_t *bits = malloc (WIDTH * HEIGHT * 4);
pixman_transform_t trans = {
{
{ pixman_double_to_fixed (1.0), pixman_double_to_fixed (0), pixman_double_to_fixed (-0.1), },
{ pixman_double_to_fixed (0), pixman_double_to_fixed (1), pixman_double_to_fixed (-0.1), },
{ pixman_double_to_fixed (0), pixman_double_to_fixed (0), pixman_double_to_fixed (1.0) }
} };
pixman_image_t *src_img = pixman_image_create_bits (PIXMAN_a8r8g8b8, SMALL, SMALL, sbits, 4 * SMALL);
pixman_image_t *dest_img = pixman_image_create_bits (PIXMAN_a8r8g8b8, WIDTH, HEIGHT, bits, 4 * WIDTH);
memset (bits, 0xff, WIDTH * HEIGHT * 4);
memset (sbits, 0x00, SMALL * SMALL * 4);
pixman_image_composite (PIXMAN_OP_IN,
src_img, NULL, dest_img,
0, 0, 0, 0, SMALL, SMALL, 200, 200);
pixman_image_set_transform (src_img, &trans);
pixman_image_composite (PIXMAN_OP_IN,
src_img, NULL, dest_img,
0, 0, 0, 0, SMALL * 2, SMALL * 2, 200, 200);
show_image (dest_img);
pixman_image_unref (src_img);
pixman_image_unref (dest_img);
free (bits);
return 0;
}
static void *
_glamor_color_convert_a1_a8(void *src_bits, void *dst_bits, int w, int h,
int stride, int revert)
{
PictFormatShort dst_format, src_format;
pixman_image_t *dst_image;
pixman_image_t *src_image;
int src_stride;
if (revert == REVERT_UPLOADING_A1) {
src_format = PICT_a1;
dst_format = PICT_a8;
src_stride = PixmapBytePad(w, 1);
}
else {
dst_format = PICT_a1;
src_format = PICT_a8;
src_stride = (((w * 8 + 7) / 8) + 3) & ~3;
}
dst_image = pixman_image_create_bits(dst_format, w, h, dst_bits, stride);
if (dst_image == NULL) {
return NULL;
}
src_image = pixman_image_create_bits(src_format,
w, h, src_bits, src_stride);
if (src_image == NULL) {
pixman_image_unref(dst_image);
return NULL;
}
pixman_image_composite(PictOpSrc, src_image, NULL, dst_image,
0, 0, 0, 0, 0, 0, w, h);
pixman_image_unref(src_image);
pixman_image_unref(dst_image);
return dst_bits;
}
static void
pixman_renderer_attach(struct weston_surface *es, struct weston_buffer *buffer)
{
struct pixman_surface_state *ps = get_surface_state(es);
struct wl_shm_buffer *shm_buffer;
pixman_format_code_t pixman_format;
weston_buffer_reference(&ps->buffer_ref, buffer);
if (ps->image) {
pixman_image_unref(ps->image);
ps->image = NULL;
}
if (!buffer)
return;
shm_buffer = wl_shm_buffer_get(buffer->resource);
if (! shm_buffer) {
weston_log("Pixman renderer supports only SHM buffers\n");
weston_buffer_reference(&ps->buffer_ref, NULL);
return;
}
switch (wl_shm_buffer_get_format(shm_buffer)) {
case WL_SHM_FORMAT_XRGB8888:
pixman_format = PIXMAN_x8r8g8b8;
break;
case WL_SHM_FORMAT_ARGB8888:
pixman_format = PIXMAN_a8r8g8b8;
break;
case WL_SHM_FORMAT_RGB565:
pixman_format = PIXMAN_r5g6b5;
break;
default:
weston_log("Unsupported SHM buffer format\n");
weston_buffer_reference(&ps->buffer_ref, NULL);
return;
break;
}
buffer->shm_buffer = shm_buffer;
buffer->width = wl_shm_buffer_get_width(shm_buffer);
buffer->height = wl_shm_buffer_get_height(shm_buffer);
ps->image = pixman_image_create_bits(pixman_format,
buffer->width, buffer->height,
wl_shm_buffer_get_data(shm_buffer),
wl_shm_buffer_get_stride(shm_buffer));
}
static cairo_gl_surface_t *
tristrip_to_surface (void *_dst,
const cairo_rectangle_int_t *extents,
cairo_antialias_t antialias,
cairo_tristrip_t *strip)
{
pixman_format_code_t pixman_format;
pixman_image_t *pixman_image;
cairo_surface_t *image, *mask;
cairo_status_t status;
pixman_format = antialias != CAIRO_ANTIALIAS_NONE ? PIXMAN_a8 : PIXMAN_a1,
pixman_image = pixman_image_create_bits (pixman_format,
extents->width,
extents->height,
NULL, 0);
if (unlikely (pixman_image == NULL))
return (cairo_gl_surface_t *)_cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
_pixman_image_add_tristrip (pixman_image, extents->x, extents->y, strip);
image = _cairo_image_surface_create_for_pixman_image (pixman_image,
pixman_format);
if (unlikely (image->status)) {
pixman_image_unref (pixman_image);
return (cairo_gl_surface_t *)image;
}
mask = _cairo_surface_create_scratch (_dst,
CAIRO_CONTENT_COLOR_ALPHA,
extents->width,
extents->height,
NULL);
if (unlikely (mask->status)) {
cairo_surface_destroy (image);
return (cairo_gl_surface_t *)mask;
}
status = _cairo_gl_surface_draw_image ((cairo_gl_surface_t *)mask,
(cairo_image_surface_t *)image,
0, 0,
extents->width, extents->height,
0, 0,
TRUE);
cairo_surface_destroy (image);
if (unlikely (status)) {
cairo_surface_destroy (mask);
return (cairo_gl_surface_t*)_cairo_surface_create_in_error (status);
}
return (cairo_gl_surface_t*)mask;
}
WL_EXPORT void
pixman_renderer_output_set_buffer(struct weston_output *output, pixman_image_t *buffer)
{
struct pixman_output_state *po = get_output_state(output);
if (po->hw_buffer)
pixman_image_unref(po->hw_buffer);
po->hw_buffer = buffer;
if (po->hw_buffer) {
output->compositor->read_format = pixman_image_get_format(po->hw_buffer);
pixman_image_ref(po->hw_buffer);
}
}
/* Creates a cairo-gl pattern surface for the given trapezoids */
static cairo_status_t
_cairo_gl_get_traps_pattern (cairo_gl_surface_t *dst,
int dst_x, int dst_y,
int width, int height,
cairo_trapezoid_t *traps,
int num_traps,
cairo_antialias_t antialias,
cairo_surface_pattern_t *pattern)
{
pixman_format_code_t pixman_format;
pixman_image_t *image;
cairo_surface_t *surface;
int i;
pixman_format = antialias != CAIRO_ANTIALIAS_NONE ? PIXMAN_a8 : PIXMAN_a1,
image = pixman_image_create_bits (pixman_format, width, height, NULL, 0);
if (unlikely (image == NULL))
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
for (i = 0; i < num_traps; i++) {
pixman_trapezoid_t trap;
trap.top = _cairo_fixed_to_16_16 (traps[i].top);
trap.bottom = _cairo_fixed_to_16_16 (traps[i].bottom);
trap.left.p1.x = _cairo_fixed_to_16_16 (traps[i].left.p1.x);
trap.left.p1.y = _cairo_fixed_to_16_16 (traps[i].left.p1.y);
trap.left.p2.x = _cairo_fixed_to_16_16 (traps[i].left.p2.x);
trap.left.p2.y = _cairo_fixed_to_16_16 (traps[i].left.p2.y);
trap.right.p1.x = _cairo_fixed_to_16_16 (traps[i].right.p1.x);
trap.right.p1.y = _cairo_fixed_to_16_16 (traps[i].right.p1.y);
trap.right.p2.x = _cairo_fixed_to_16_16 (traps[i].right.p2.x);
trap.right.p2.y = _cairo_fixed_to_16_16 (traps[i].right.p2.y);
pixman_rasterize_trapezoid (image, &trap, -dst_x, -dst_y);
}
surface = _cairo_image_surface_create_for_pixman_image (image,
pixman_format);
if (unlikely (surface->status)) {
pixman_image_unref (image);
return surface->status;
}
_cairo_pattern_init_for_surface (pattern, surface);
cairo_surface_destroy (surface);
return CAIRO_STATUS_SUCCESS;
}
