/* Handles compositing with a clip surface when we have to do the operation * in two pieces and combine them together. */ static cairo_status_t clip_and_composite_combine (const cairo_composite_rectangles_t*extents, draw_func_t draw_func, void *draw_closure) { cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; cairo_image_surface_t *tmp, *clip; int clip_x, clip_y; cairo_status_t status; TRACE ((stderr, "%s\n", __FUNCTION__)); tmp = (cairo_image_surface_t *) _cairo_image_surface_create_with_pixman_format (NULL, dst->pixman_format, extents->bounded.width, extents->bounded.height, 0); if (unlikely (tmp->base.status)) return tmp->base.status; pixman_image_composite32 (PIXMAN_OP_SRC, dst->pixman_image, NULL, tmp->pixman_image, extents->bounded.x, extents->bounded.y, 0, 0, 0, 0, extents->bounded.width, extents->bounded.height); status = draw_func (tmp, draw_closure, extents->op, &extents->source_pattern.base, extents->bounded.x, extents->bounded.y, &extents->bounded); if (unlikely (status)) goto error; clip = (cairo_image_surface_t *) _cairo_clip_get_surface (extents->clip, &dst->base, &clip_x, &clip_y); if (unlikely (clip->base.status)) goto error; pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, clip->pixman_image, NULL, dst->pixman_image, extents->bounded.x - clip_x, extents->bounded.y - clip_y, 0, 0, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); pixman_image_composite32 (PIXMAN_OP_ADD, tmp->pixman_image, clip->pixman_image, dst->pixman_image, 0, 0, extents->bounded.x - clip_x, extents->bounded.y - clip_y, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); cairo_surface_destroy (&clip->base); error: cairo_surface_destroy (&tmp->base); return status; }
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(); }
/* Handles compositing with a clip surface when we have to do the operation * in two pieces and combine them together. */ static cairo_status_t clip_and_composite_combine (const cairo_composite_rectangles_t*extents, draw_func_t draw_func, void *draw_closure) { cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; cairo_image_surface_t *tmp, *clip; int clip_x, clip_y; cairo_status_t status; tmp = (cairo_image_surface_t *) _cairo_surface_create_similar_solid (&dst->base, dst->base.content, extents->bounded.width, extents->bounded.height, CAIRO_COLOR_TRANSPARENT); if (unlikely (tmp->base.status)) return tmp->base.status; pixman_image_composite32 (PIXMAN_OP_SRC, dst->pixman_image, NULL, tmp->pixman_image, extents->bounded.x, extents->bounded.y, 0, 0, 0, 0, extents->bounded.width, extents->bounded.height); status = draw_func (tmp, draw_closure, extents->op, &extents->source_pattern.base, extents->bounded.x, extents->bounded.y, &extents->bounded); if (unlikely (status)) goto error; clip = (cairo_image_surface_t *) get_clip_surface (dst, extents, &clip_x, &clip_y); if (unlikely (clip->base.status)) goto error; pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, clip->pixman_image, NULL, dst->pixman_image, extents->bounded.x - clip_x, extents->bounded.y - clip_y, 0, 0, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); pixman_image_composite32 (PIXMAN_OP_ADD, tmp->pixman_image, clip->pixman_image, dst->pixman_image, 0, 0, extents->bounded.x - clip_x, extents->bounded.y - clip_y, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); cairo_surface_destroy (&clip->base); error: cairo_surface_destroy (&tmp->base); return status; }
void Bitmap::CheckPixels(uint32_t flags) { if (flags & System) { DynamicFormat format(32,8,24,8,16,8,8,8,0,PF::Alpha); uint32_t pixel; Bitmap bmp(reinterpret_cast<void*>(&pixel), 1, 1, 4, format); pixman_image_composite32(PIXMAN_OP_SRC, bitmap, (pixman_image_t*) NULL, bmp.bitmap, 0, 32, 0, 0, 0, 0, 1, 1); bg_color = Color((pixel>>24)&0xFF, (pixel>>16)&0xFF, (pixel>>8)&0xFF, pixel&0xFF); pixman_image_composite32(PIXMAN_OP_SRC, bitmap, (pixman_image_t*) NULL, bmp.bitmap, 16, 32, 0, 0, 0, 0, 1, 1); sh_color = Color((pixel>>24)&0xFF, (pixel>>16)&0xFF, (pixel>>8)&0xFF, pixel&0xFF); }
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::FlipBlit(int x, int y, Bitmap* _src, Rect src_rect, bool horizontal, bool vertical) { if (!horizontal && !vertical) { Blit(x, y, _src, src_rect, 255); return; } PixmanBitmap* src = (PixmanBitmap*) _src; pixman_transform_t xform; pixman_transform_init_scale(&xform, pixman_int_to_fixed(horizontal ? -1 : 1), pixman_int_to_fixed(vertical ? -1 : 1)); pixman_transform_translate((pixman_transform_t*) NULL, &xform, pixman_int_to_fixed(horizontal ? src_rect.width : 0), pixman_int_to_fixed(vertical ? src_rect.height : 0)); pixman_image_set_transform(bitmap, &xform); 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_transform_init_identity(&xform); pixman_image_set_transform(bitmap, &xform); 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_snapshot (void *abstract_surface) { cairo_image_surface_t *image = abstract_surface; cairo_image_surface_t *clone; clone = (cairo_image_surface_t *) _cairo_image_surface_create_with_pixman_format (NULL, image->pixman_format, image->width, image->height, 0); if (unlikely (clone->base.status)) return &clone->base; if (clone->stride == image->stride) { memcpy (clone->data, image->data, clone->stride * clone->height); } else { pixman_image_composite32 (PIXMAN_OP_SRC, image->pixman_image, NULL, clone->pixman_image, 0, 0, 0, 0, 0, 0, image->width, image->height); } clone->base.is_clear = FALSE; return &clone->base; }
Bitmap* PixmanBitmap::Resample(int scale_w, int scale_h, const Rect& src_rect) { PixmanBitmap *dst = new PixmanBitmap(scale_w, scale_h, GetTransparent()); double zoom_x = (double)src_rect.width / scale_w; double zoom_y = (double)src_rect.height / scale_h; pixman_transform_t xform; pixman_transform_init_scale(&xform, pixman_double_to_fixed(zoom_x), pixman_double_to_fixed(zoom_y)); pixman_image_set_transform(bitmap, &xform); pixman_image_composite32(PIXMAN_OP_SRC, bitmap, (pixman_image_t*) NULL, dst->bitmap, src_rect.x, src_rect.y, 0, 0, 0, 0, scale_w, scale_h); pixman_transform_init_identity(&xform); pixman_image_set_transform(bitmap, &xform); return dst; }
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 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; }
/* A convenience function for when one needs to coerce an image * surface to an alternate format. */ cairo_image_surface_t * _cairo_image_surface_coerce_to_format (cairo_image_surface_t *surface, cairo_format_t format) { cairo_image_surface_t *clone; cairo_status_t status; status = surface->base.status; if (unlikely (status)) return (cairo_image_surface_t *)_cairo_surface_create_in_error (status); if (surface->format == format) return (cairo_image_surface_t *)cairo_surface_reference(&surface->base); clone = (cairo_image_surface_t *) cairo_image_surface_create (format, surface->width, surface->height); if (unlikely (clone->base.status)) return clone; pixman_image_composite32 (PIXMAN_OP_SRC, surface->pixman_image, NULL, clone->pixman_image, 0, 0, 0, 0, 0, 0, surface->width, surface->height); clone->base.is_clear = FALSE; clone->base.device_transform = surface->base.device_transform; clone->base.device_transform_inverse = surface->base.device_transform_inverse; return clone; }
static void copy_to_hw_buffer(struct weston_output *output, pixman_region32_t *region) { struct pixman_output_state *po = get_output_state(output); pixman_region32_t output_region; pixman_region32_init(&output_region); pixman_region32_copy(&output_region, region); region_global_to_output(output, &output_region); pixman_image_set_clip_region32 (po->hw_buffer, &output_region); pixman_image_composite32(PIXMAN_OP_SRC, po->shadow_image, /* src */ NULL /* mask */, po->hw_buffer, /* dest */ 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ pixman_image_get_width (po->hw_buffer), /* width */ pixman_image_get_height (po->hw_buffer) /* height */); pixman_image_set_clip_region32 (po->hw_buffer, NULL); }
/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's * defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip)) */ static cairo_status_t clip_and_composite_source (const cairo_composite_rectangles_t *extents, draw_func_t draw_func, void *draw_closure) { cairo_image_surface_t *dst = (cairo_image_surface_t *)extents->surface; cairo_image_surface_t *mask; pixman_image_t *src; int src_x, src_y; cairo_status_t status = CAIRO_STATUS_SUCCESS; TRACE ((stderr, "%s\n", __FUNCTION__)); mask = create_composite_mask (dst, draw_closure, draw_func, extents); if (unlikely (mask->base.status)) return mask->base.status; pixman_image_composite32 (PIXMAN_OP_OUT_REVERSE, mask->pixman_image, NULL, dst->pixman_image, 0, 0, 0, 0, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); src = _pixman_image_for_pattern (dst, &extents->source_pattern.base, FALSE, &extents->bounded, &extents->source_sample_area, &src_x, &src_y); if (unlikely (src == NULL)) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto error; } pixman_image_composite32 (PIXMAN_OP_ADD, src, mask->pixman_image, dst->pixman_image, extents->bounded.x + src_x, extents->bounded.y + src_y, 0, 0, extents->bounded.x, extents->bounded.y, extents->bounded.width, extents->bounded.height); pixman_image_unref (src); error: cairo_surface_destroy (&mask->base); return status; }
int main () { static const pixman_point_fixed_t inner = { 0x0000, 0x0000 }; static const pixman_point_fixed_t outer = { 0x0000, 0x0000 }; static const pixman_fixed_t r_inner = 0; static const pixman_fixed_t r_outer = 64 << 16; static const pixman_gradient_stop_t stops[] = { { 0x00000, { 0x6666, 0x6666, 0x6666, 0xffff } }, { 0x10000, { 0x0000, 0x0000, 0x0000, 0xffff } } }; static const pixman_transform_t transform = { { { 0x0, 0x26ee, 0x0}, { 0xffffeeef, 0x0, 0x0}, { 0x0, 0x0, 0x10000} } }; static const pixman_color_t z = { 0x0000, 0x0000, 0x0000, 0x0000 }; pixman_image_t *dest, *radial, *zero; int i; double before, after; dest = pixman_image_create_bits ( PIXMAN_x8r8g8b8, 640, 429, NULL, -1); zero = pixman_image_create_solid_fill (&z); radial = pixman_image_create_radial_gradient ( &inner, &outer, r_inner, r_outer, stops, ARRAY_LENGTH (stops)); pixman_image_set_transform (radial, &transform); pixman_image_set_repeat (radial, PIXMAN_REPEAT_PAD); #define N_COMPOSITE 500 before = gettime(); for (i = 0; i < N_COMPOSITE; ++i) { before -= gettime(); pixman_image_composite ( PIXMAN_OP_SRC, zero, NULL, dest, 0, 0, 0, 0, 0, 0, 640, 429); before += gettime(); pixman_image_composite32 ( PIXMAN_OP_OVER, radial, NULL, dest, - 150, -158, 0, 0, 0, 0, 640, 361); } after = gettime(); write_png (dest, "radial.png"); printf ("Average time to composite: %f\n", (after - before) / N_COMPOSITE); 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 PixmanBitmap::MaskBlit(int x, int y, Bitmap* _src, Rect src_rect) { PixmanBitmap* src = (PixmanBitmap*) _src; pixman_image_composite32(PIXMAN_OP_DISJOINT_IN_REVERSE, src->bitmap, (pixman_image_t*) NULL, bitmap, src_rect.x, src_rect.y, 0, 0, x, y, src_rect.width, src_rect.height); RefreshCallback(); }
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; }
static void _cairo_surface_snapshot_copy_on_write (cairo_surface_t *surface) { cairo_surface_snapshot_t *snapshot = (cairo_surface_snapshot_t *) surface; cairo_image_surface_t *image; cairo_image_surface_t *clone; void *extra; cairo_status_t status; /* We need to make an image copy of the original surface since the * snapshot may exceed the lifetime of the original device, i.e. * when we later need to use the snapshot the data may have already * been lost. */ status = _cairo_surface_acquire_source_image (snapshot->target, &image, &extra); if (unlikely (status)) { snapshot->target = _cairo_surface_create_in_error (status); status = _cairo_surface_set_error (surface, status); return; } clone = (cairo_image_surface_t *) _cairo_image_surface_create_with_pixman_format (NULL, image->pixman_format, image->width, image->height, 0); if (likely (clone->base.status == CAIRO_STATUS_SUCCESS)) { if (clone->stride == image->stride) { memcpy (clone->data, image->data, image->stride * image->height); } else { pixman_image_composite32 (PIXMAN_OP_SRC, image->pixman_image, NULL, clone->pixman_image, 0, 0, 0, 0, 0, 0, image->width, image->height); } clone->base.is_clear = FALSE; snapshot->clone = &clone->base; } else { snapshot->clone = &clone->base; status = _cairo_surface_set_error (surface, clone->base.status); } _cairo_surface_release_source_image (snapshot->target, image, extra); snapshot->target = snapshot->clone; snapshot->base.type = snapshot->target->type; }
void mSDLSWRunloop(struct mSDLRenderer* renderer, void* user) { struct mCoreThread* context = user; SDL_Event event; #if !SDL_VERSION_ATLEAST(2, 0, 0) SDL_Surface* surface = SDL_GetVideoSurface(); #endif while (mCoreThreadIsActive(context)) { while (SDL_PollEvent(&event)) { mSDLHandleEvent(context, &renderer->player, &event); } if (mCoreSyncWaitFrameStart(&context->impl->sync)) { #if SDL_VERSION_ATLEAST(2, 0, 0) SDL_UnlockTexture(renderer->sdlTex); SDL_RenderCopy(renderer->sdlRenderer, renderer->sdlTex, 0, 0); SDL_RenderPresent(renderer->sdlRenderer); int stride; SDL_LockTexture(renderer->sdlTex, 0, (void**) &renderer->outputBuffer, &stride); renderer->core->setVideoBuffer(renderer->core, renderer->outputBuffer, stride / BYTES_PER_PIXEL); #else #ifdef USE_PIXMAN if (renderer->ratio > 1) { pixman_image_composite32(PIXMAN_OP_SRC, renderer->pix, 0, renderer->screenpix, 0, 0, 0, 0, 0, 0, renderer->viewportWidth, renderer->viewportHeight); } #else switch (renderer->ratio) { #if defined(__ARM_NEON) && COLOR_16_BIT case 2: _neon2x(surface->pixels, renderer->outputBuffer, width, height); break; case 4: _neon4x(surface->pixels, renderer->outputBuffer, width, height); break; #endif case 1: break; default: abort(); } #endif SDL_UnlockSurface(surface); SDL_Flip(surface); SDL_LockSurface(surface); #endif } mCoreSyncWaitFrameEnd(&context->impl->sync); } }
bool Bitmap::WritePNG(std::ostream& os) const { size_t const width = GetWidth(), height = GetHeight(); size_t const stride = width * 4; std::vector<uint32_t> data(width * height); EASYRPG_SHARED_PTR<pixman_image_t> dst (pixman_image_create_bits(PIXMAN_a8r8g8b8, width, height, &data.front(), stride), pixman_image_unref); pixman_image_composite32(PIXMAN_OP_SRC, bitmap, NULL, dst.get(), 0, 0, 0, 0, 0, 0, width, height); return ImagePNG::WritePNG(os, width, height, &data.front()); }
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); }
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; }
cairo_surface_t * _cairo_image_surface_snapshot (void *abstract_surface) { cairo_image_surface_t *image = abstract_surface; cairo_image_surface_t *clone; /* If we own the image, we can simply steal the memory for the snapshot */ if (image->owns_data && image->base._finishing) { clone = (cairo_image_surface_t *) _cairo_image_surface_create_for_pixman_image (image->pixman_image, image->pixman_format); if (unlikely (clone->base.status)) return &clone->base; image->pixman_image = NULL; image->owns_data = FALSE; clone->transparency = image->transparency; clone->color = image->color; clone->owns_data = FALSE; return &clone->base; } clone = (cairo_image_surface_t *) _cairo_image_surface_create_with_pixman_format (NULL, image->pixman_format, image->width, image->height, 0); if (unlikely (clone->base.status)) return &clone->base; if (clone->stride == image->stride) { memcpy (clone->data, image->data, clone->stride * clone->height); } else { pixman_image_composite32 (PIXMAN_OP_SRC, image->pixman_image, NULL, clone->pixman_image, 0, 0, 0, 0, 0, 0, image->width, image->height); } clone->base.is_clear = FALSE; return &clone->base; }
static int pixman_renderer_read_pixels(struct weston_output *output, pixman_format_code_t format, void *pixels, uint32_t x, uint32_t y, uint32_t width, uint32_t height) { struct pixman_output_state *po = get_output_state(output); pixman_transform_t transform; pixman_image_t *out_buf; if (!po->hw_buffer) { errno = ENODEV; return -1; } out_buf = pixman_image_create_bits(format, width, height, pixels, (PIXMAN_FORMAT_BPP(format) / 8) * width); /* Caller expects vflipped source image */ pixman_transform_init_translate(&transform, pixman_int_to_fixed (x), pixman_int_to_fixed (y - pixman_image_get_height (po->hw_buffer))); pixman_transform_scale(&transform, NULL, pixman_fixed_1, pixman_fixed_minus_1); pixman_image_set_transform(po->hw_buffer, &transform); pixman_image_composite32(PIXMAN_OP_SRC, po->hw_buffer, /* src */ NULL /* mask */, out_buf, /* dest */ 0, 0, /* src_x, src_y */ 0, 0, /* mask_x, mask_y */ 0, 0, /* dest_x, dest_y */ pixman_image_get_width (po->hw_buffer), /* width */ pixman_image_get_height (po->hw_buffer) /* height */); pixman_image_set_transform(po->hw_buffer, NULL); pixman_image_unref(out_buf); return 0; }
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(); }
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 inline void blend_to_pixmap_from_pixmap(const RedDrawable_p* dest, const SpiceRect& area, const SpicePoint& offset, const PixelsSource_p* source, int src_x, int src_y) { pixman_image_t *dest_surface = dest->source.pixmap.pixman_image; pixman_image_t *src_surface = source->pixmap.pixman_image; pixman_image_composite32 (PIXMAN_OP_ATOP, src_surface, NULL, dest_surface, src_x + offset.x, src_y + offset.y, 0, 0, area.left + offset.x, area.top + offset.y, area.right - area.left, area.bottom - area.top); }