void render() { draw_fill(ctx, rgba(0,0,0,127)); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, window->width); cairo_surface_t * surface = cairo_image_surface_create_for_data(ctx->buffer, CAIRO_FORMAT_ARGB32, window->width, window->height, stride); cairo_t * cr = cairo_create(surface); cairo_set_line_width (cr, 6); cairo_rectangle (cr, 12, 12, 232, 70); cairo_new_sub_path (cr); cairo_arc (cr, 64, 64, 40, 0, 2*M_PI); cairo_new_sub_path (cr); cairo_arc_negative (cr, 192, 64, 40, 0, -2*M_PI); cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD); cairo_set_source_rgb (cr, 0, 0.7, 0); cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_stroke (cr); cairo_translate (cr, 0, 128); cairo_rectangle (cr, 12, 12, 232, 70); cairo_new_sub_path (cr); cairo_arc (cr, 64, 64, 40, 0, 2*M_PI); cairo_new_sub_path (cr); cairo_arc_negative (cr, 192, 64, 40, 0, -2*M_PI); cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING); cairo_set_source_rgb (cr, 0, 0, 0.9); cairo_fill_preserve (cr); cairo_set_source_rgb (cr, 0, 0, 0); cairo_stroke (cr); cairo_surface_flush(surface); cairo_destroy(cr); cairo_surface_flush(surface); cairo_surface_destroy(surface); }
inline static cairo_pattern_t * create_stipple (const char *color_name, guchar stipple_data[]) { cairo_surface_t *surface; cairo_pattern_t *pattern; GdkColor color; int stride; const int width = 8; const int height = 8; gdk_color_parse (color_name, &color); /* stipple_data[2] = stipple_data[14] = color.red >> 8; stipple_data[1] = stipple_data[13] = color.green >> 8; stipple_data[0] = stipple_data[12] = color.blue >> 8; */ stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, width); g_assert (stride>0); NG_DEBUG ("stride = %i", stride); surface = cairo_image_surface_create_for_data (stipple_data, CAIRO_FORMAT_ARGB32, width, height, stride); pattern = cairo_pattern_create_for_surface (surface); cairo_surface_destroy (surface); cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT); return pattern; }
cairo_t* gui_screen_t::getGraphics() { // get buffer auto bufferInfo = canvas->getBuffer(); if (bufferInfo.buffer == 0) { return 0; } bufferSize.width = bufferInfo.width; bufferSize.height = bufferInfo.height; // get the surface ready and go: if (existingSurface == 0 || existingSurfaceBuffer != bufferInfo.buffer) { if (existingContext != 0) { cairo_destroy(existingContext); } existingSurface = cairo_image_surface_create_for_data((uint8_t*) bufferInfo.buffer, CAIRO_FORMAT_ARGB32, bufferInfo.width, bufferInfo.height, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, bufferInfo.width)); existingSurfaceBuffer = bufferInfo.buffer; existingContext = cairo_create(existingSurface); } return existingContext; }
static void display_text_draw(struct font_freetype_text *text, struct graphics_priv *gr, struct graphics_gc_priv *fg, struct graphics_gc_priv *bg, struct point *p) { int i,x,y,stride; struct font_freetype_glyph *g, **gp; struct color transparent={0x0,0x0,0x0,0x0}; gp=text->glyph; i=text->glyph_count; x=p->x << 6; y=p->y << 6; while (i-- > 0) { g=*gp++; if (g->w && g->h && bg ) { unsigned char *shadow; stride=cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, g->w+2); shadow=g_malloc(stride*(g->h+2)); gr->freetype_methods.get_shadow(g, shadow, stride, &bg->c, &transparent); draw_rgb_image_buffer(gr->cairo, g->w+2, g->h+2, ((x+g->x)>>6)-1, ((y+g->y)>>6)-1, stride, shadow); g_free(shadow); } x+=g->dx; y+=g->dy; }
/** * cairo_image_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: the format of pixels in the buffer * @width: the width of the image to be stored in the buffer * @height: the height of the image to be stored in the buffer * @stride: the number of bytes between the start of rows in the * buffer as allocated. This value should always be computed by * cairo_format_stride_for_width() before allocating the data * buffer. * * Creates an image surface for the provided pixel data. The output * buffer must be kept around until the #cairo_surface_t is destroyed * or cairo_surface_finish() is called on the surface. The initial * contents of @data will be used as the initial image contents; you * must explicitly clear the buffer, using, for example, * cairo_rectangle() and cairo_fill() if you want it cleared. * * Note that the stride may be larger than * width*bytes_per_pixel to provide proper alignment for each pixel * and row. This alignment is required to allow high-performance rendering * within cairo. The correct way to obtain a legal stride value is to * call cairo_format_stride_for_width() with the desired format and * maximum image width value, and the use the resulting stride value * to allocate the data and to create the image surface. See * cairo_format_stride_for_width() for example code. * * Return value: a pointer to the newly created surface. The caller * owns the surface and should call cairo_surface_destroy() when done * with it. * * This function always returns a valid pointer, but it will return a * pointer to a "nil" surface in the case of an error such as out of * memory or an invalid stride value. In case of invalid stride value * the error status of the returned surface will be * %CAIRO_STATUS_INVALID_STRIDE. You can use * cairo_surface_status() to check for this. * * See cairo_surface_set_user_data() for a means of attaching a * destroy-notification fallback to the surface if necessary. **/ cairo_surface_t * cairo_image_surface_create_for_data (unsigned char *data, cairo_format_t format, int width, int height, int stride) { pixman_format_code_t pixman_format; int minstride; if (! CAIRO_FORMAT_VALID (format)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_FORMAT)); if ((stride & (CAIRO_STRIDE_ALIGNMENT-1)) != 0) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE)); minstride = cairo_format_stride_for_width (format, width); if (stride < 0) { if (stride > -minstride) { return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE)); } } else { if (stride < minstride) { return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE)); } } pixman_format = _cairo_format_to_pixman_format_code (format); return _cairo_image_surface_create_with_pixman_format (data, pixman_format, width, height, stride); }
static cairo_surface_t * radeon_surface_create_internal (cairo_drm_device_t *device, cairo_format_t format, int width, int height) { radeon_surface_t *surface; cairo_status_t status; surface = malloc (sizeof (radeon_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); radeon_surface_init (surface, device, format, width, height); if (width && height) { surface->base.stride = cairo_format_stride_for_width (surface->base.format, width); surface->base.bo = radeon_bo_create (to_radeon_device (&device->base), surface->base.stride * height, RADEON_GEM_DOMAIN_GTT); if (unlikely (surface->base.bo == NULL)) { status = _cairo_drm_surface_finish (&surface->base); free (surface); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } } return &surface->base.base; }
void CairoGet(ImageBuffer& b, Size isz, cairo_surface_t *surface, cairo_surface_t *alpha_surface) { cairo_surface_flush(surface); byte *a = (byte *)cairo_image_surface_get_data(surface); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, isz.cx); RGBA *t = b; byte *aa = NULL; if(alpha_surface) { cairo_surface_flush(alpha_surface); aa = (byte *)cairo_image_surface_get_data(alpha_surface); } for(int yy = 0; yy < isz.cy; yy++) { RGBA *s = (RGBA *)a; RGBA *e = s + isz.cx; if(aa) { RGBA *ss = (RGBA *)aa; while(s < e) { *t = *s++; (t++)->a = (ss++)->r; } aa += stride; } else while(s < e) { *t = *s++; (t++)->a = 255; } a += stride; } }
static cairo_test_status_t draw (cairo_t *cr, int width, int height) { const cairo_test_context_t *ctx = cairo_test_get_context (cr); cairo_format_t format = CAIRO_FORMAT_ARGB32; cairo_t *cr_src; cairo_surface_t *png, *src; uint8_t *data; int stride; png = cairo_test_create_surface_from_png (ctx, png_filename); stride = cairo_format_stride_for_width (format, width) + 12; data = xcalloc (stride, height); src = cairo_image_surface_create_for_data (data, format, width, height, stride); cr_src = cairo_create (src); cairo_set_source_surface (cr_src, png, 0, 0); cairo_paint (cr_src); cairo_destroy (cr_src); cairo_set_source_surface (cr, src, 0, 0); cairo_paint (cr); cairo_surface_destroy (png); cairo_surface_finish (src); cairo_surface_destroy (src); free (data); return CAIRO_TEST_SUCCESS; }
RenderImageCairo::RenderImageCairo(void* data, size_t len) { int x, y, n; stbi_buffer_ = stbi_load_from_memory((const stbi_uc*)data, len, &x, &y, &n, 4); Color* pColorBegin = (Color*)stbi_buffer_; for (int i = 0; i < x*y; i++) { Color* pColor = pColorBegin + i; Color origin = *pColor; uint8 a = ColorGetA(origin); uint8 r = ColorGetB(origin); uint8 g = ColorGetG(origin); uint8 b = ColorGetR(origin); if (a < 255) { *pColor = ColorSetARGB(a, r*a/255, g*a/255, b*a/255); } else { *pColor = ColorSetARGB(a, r, g, b); } } size_.SetSize(x, y); cairo_format_t format = CAIRO_FORMAT_ARGB32; int stride = cairo_format_stride_for_width(format, x); image_surface_ = cairo_image_surface_create_for_data(stbi_buffer_, format, x, y, stride); }
static cairo_surface_t * _cairo_boilerplate_image16_create_similar (cairo_surface_t *other, cairo_content_t content, int width, int height) { cairo_format_t format; cairo_surface_t *surface; int stride; void *ptr; switch (content) { case CAIRO_CONTENT_ALPHA: format = CAIRO_FORMAT_A8; break; case CAIRO_CONTENT_COLOR: format = CAIRO_FORMAT_RGB16_565; break; default: case CAIRO_CONTENT_COLOR_ALPHA: format = CAIRO_FORMAT_ARGB32; break; } stride = cairo_format_stride_for_width(format, width); ptr = malloc (stride* height); surface = cairo_image_surface_create_for_data (ptr, format, width, height, stride); cairo_surface_set_user_data (surface, &key, ptr, free); return surface; }
static cairo_surface_t * intel_surface_create (cairo_drm_device_t *device, cairo_format_t format, int width, int height) { intel_surface_t *surface; cairo_status_t status; surface = malloc (sizeof (intel_surface_t)); if (unlikely (surface == NULL)) return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); intel_surface_init (surface, &intel_surface_backend, device, format, width, height); if (width && height) { /* Vol I, p134: size restrictions for textures */ width = (width + 3) & -4; height = (height + 1) & -2; surface->drm.stride = cairo_format_stride_for_width (surface->drm.format, width); surface->drm.bo = &intel_bo_create (to_intel_device (&device->base), surface->drm.stride * height, surface->drm.stride * height, TRUE, I915_TILING_NONE, surface->drm.stride)->base; if (surface->drm.bo == NULL) { status = _cairo_drm_surface_finish (&surface->drm); free (surface); return _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY)); } } return &surface->drm.base; }
void WriteImage( // source image data in RGB24 format uint8_t *srcData, int srcWidth, int srcHeight, // offset int offsetX, int offsetY, // resize int tgtWidth, int tgtHeight) { typedef boost::shared_ptr<cairo_surface_t> SurfacePtr; cairo_save(ctx_); cairo_translate(ctx_, offsetX, offsetY); cairo_scale(ctx_, static_cast<double>(tgtWidth)/srcWidth, static_cast<double>(tgtHeight)/srcHeight); { int stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, srcWidth); SurfacePtr srcSurface( cairo_image_surface_create_for_data( srcData, CAIRO_FORMAT_RGB24, srcWidth, srcHeight, stride), cairo_surface_destroy); cairo_set_source_surface(ctx_, srcSurface.get(), 0, 0); } cairo_paint(ctx_); cairo_restore(ctx_); }
static void size_allocate_callback(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data) { dt_iop_module_t *self = (dt_iop_module_t *)user_data; dt_iop_zonesystem_gui_data_t *g = (dt_iop_zonesystem_gui_data_t *)self->gui_data; if(g->image) cairo_surface_destroy(g->image); free(g->image_buffer); /* load the dt logo as a brackground */ char filename[PATH_MAX] = { 0 }; char datadir[PATH_MAX] = { 0 }; char *logo; dt_logo_season_t season = get_logo_season(); if(season != DT_LOGO_SEASON_NONE) logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.svg", (int)season); else logo = g_strdup("%s/pixmaps/idbutton.svg"); dt_loc_get_datadir(datadir, sizeof(datadir)); snprintf(filename, sizeof(filename), logo, datadir); g_free(logo); RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL); if(svg) { cairo_surface_t *surface; cairo_t *cr; RsvgDimensionData dimension; rsvg_handle_get_dimensions(svg, &dimension); float svg_size = MAX(dimension.width, dimension.height); float final_size = MIN(allocation->width, allocation->height) * 0.75; float factor = final_size / svg_size; float final_width = dimension.width * factor * darktable.gui->ppd, final_height = dimension.height * factor * darktable.gui->ppd; int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width); g->image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8)); surface = dt_cairo_image_surface_create_for_data(g->image_buffer, CAIRO_FORMAT_ARGB32, final_width, final_height, stride); if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { free(g->image_buffer); g->image_buffer = NULL; } else { cr = cairo_create(surface); cairo_scale(cr, factor, factor); rsvg_handle_render_cairo(svg, cr); cairo_destroy(cr); cairo_surface_flush(surface); g->image = surface; g->image_width = final_width / darktable.gui->ppd; g->image_height = final_height / darktable.gui->ppd; } g_object_unref(svg); } }
gint image_setup (GimpDrawable *drawable, gint interactive) { /* Set the tile cache size */ /* ======================= */ gimp_tile_cache_ntiles ((drawable->width + gimp_tile_width() - 1) / gimp_tile_width ()); /* Get some useful info on the input drawable */ /* ========================================== */ input_drawable = drawable; output_drawable = drawable; if (! gimp_drawable_mask_intersect (drawable->drawable_id, &border_x, &border_y, &border_w, &border_h)) return FALSE; width = input_drawable->width; height = input_drawable->height; gimp_pixel_rgn_init (&source_region, input_drawable, 0, 0, width, height, FALSE, FALSE); maxcounter = (glong) width * (glong) height; if (mapvals.transparent_background == TRUE) { gimp_rgba_set (&background, 0.0, 0.0, 0.0, 0.0); } else { gimp_context_get_background (&background); gimp_rgb_set_alpha (&background, 1.0); } /* Assume at least RGB */ /* =================== */ in_channels = 3; if (gimp_drawable_has_alpha (input_drawable->drawable_id) == TRUE) in_channels++; if (interactive == TRUE) { preview_rgb_stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, PREVIEW_WIDTH); preview_rgb_data = g_new0 (guchar, preview_rgb_stride * PREVIEW_HEIGHT); preview_surface = cairo_image_surface_create_for_data (preview_rgb_data, CAIRO_FORMAT_RGB24, PREVIEW_WIDTH, PREVIEW_HEIGHT, preview_rgb_stride); } return TRUE; }
/* Create a cairo surface using the specified framebuffer */ cairo_surface_t *cairo_linuxfb_surface_create(cairo_linuxfb_device_t *device, const char *fb_name) { cairo_surface_t *surface; // Open the file for reading and writing device->fb_fd = open(fb_name, O_RDWR); if (device->fb_fd == -1) { perror("Error: cannot open framebuffer device"); goto handle_allocate_error; } // Get variable screen information if (ioctl(device->fb_fd, FBIOGET_VSCREENINFO, &device->fb_vinfo) == -1) { perror("Error: reading variable information"); goto handle_ioctl_error; } /* Set virtual display size double the width for double buffering */ device->fb_vinfo.yoffset = 0; device->fb_vinfo.yres_virtual = device->fb_vinfo.yres * 2; if (ioctl(device->fb_fd, FBIOPUT_VSCREENINFO, &device->fb_vinfo)) { perror("Error setting variable screen info from fb"); goto handle_ioctl_error; } // Get fixed screen information if (ioctl(device->fb_fd, FBIOGET_FSCREENINFO, &device->fb_finfo) == -1) { perror("Error reading fixed information"); goto handle_ioctl_error; } // Map the device to memory device->fb_data = (unsigned char *)mmap(0, device->fb_finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, device->fb_fd, 0); if ((int)device->fb_data == -1) { perror("Error: failed to map framebuffer device to memory"); goto handle_ioctl_error; } /* Create the cairo surface which will be used to draw to */ surface = cairo_image_surface_create_for_data(device->fb_data, CAIRO_FORMAT_RGB16_565, device->fb_vinfo.xres, device->fb_vinfo.yres_virtual, cairo_format_stride_for_width(CAIRO_FORMAT_RGB16_565, device->fb_vinfo.xres)); cairo_surface_set_user_data(surface, NULL, device, &cairo_linuxfb_surface_destroy); return surface; handle_ioctl_error: close(device->fb_fd); handle_allocate_error: free(device); exit(1); }
void init_graphicslib(void) { int stride; stride=cairo_format_stride_for_width(CAIRO_FORMAT_RGB16_565, 160); printf("stride is %d\n", stride); cs=cairo_image_surface_create_for_data(cairobuff, CAIRO_FORMAT_RGB16_565, 160, 120, stride); c=cairo_create(cs); }
static cairo_surface_t * display_create_shm_surface(struct display *display, struct rectangle *rectangle) { struct shm_surface_data *data; cairo_surface_t *surface; struct wl_visual *visual; int stride, fd; char filename[] = "/tmp/wayland-shm-XXXXXX"; data = malloc(sizeof *data); if (data == NULL) return NULL; stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, rectangle->width); data->length = stride * rectangle->height; fd = mkstemp(filename); if (fd < 0) { fprintf(stderr, "open %s failed: %m", filename); return NULL; } if (ftruncate(fd, data->length) < 0) { fprintf(stderr, "ftruncate failed: %m"); close(fd); return NULL; } data->map = mmap(NULL, data->length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); unlink(filename); if (data->map == MAP_FAILED) { fprintf(stderr, "mmap failed: %m"); close(fd); return NULL; } surface = cairo_image_surface_create_for_data (data->map, CAIRO_FORMAT_ARGB32, rectangle->width, rectangle->height, stride); cairo_surface_set_user_data (surface, &surface_data_key, data, shm_surface_data_destroy); visual = wl_display_get_premultiplied_argb_visual(display->display); data->data.buffer = wl_shm_create_buffer(display->shm, fd, rectangle->width, rectangle->height, stride, visual); close(fd); return surface; }
virtual int ARGB(Plugin::FeatureSet features, int width, int height, unsigned char *bitmap, int sampleRate) { const double lower = MIN_FREQ; const double higher = MAX_FREQ; const double lower_log = log10(lower); const double higher_log = log10(higher); // set up cairo surface cairo_surface_t *surface; cairo_format_t format = CAIRO_FORMAT_ARGB32; int stride = cairo_format_stride_for_width(format, width); surface = cairo_image_surface_create_for_data (bitmap, format, width, height, stride); // set up cairo context cairo_t *cr; cr = cairo_create(surface); cairo_scale(cr, width, height); cairo_set_source_rgba(cr, BG_COLOUR); cairo_paint(cr); // find number of frames for peak/spec centroid unsigned int peakFrames = features[0].size(); unsigned int scFrames = features[1].size(); double scScale = (double)scFrames/(double)peakFrames; // for each peak frame, draw a colored line for (unsigned int peakFrame=0; peakFrame<peakFrames; peakFrame++) { // find spectral contrast, clip and scale double sc = features[1].at(floor(scScale*peakFrame)).values[0]; if (sc < lower) sc=lower; if (sc > higher) sc=higher; sc = (log10(sc)-lower_log)/(higher_log-lower_log); // get peak values double peak1 = features[0].at(peakFrame).values[0]; double peak2 = features[0].at(peakFrame).values[1]; // draw waveform cairo_set_source_rgba(cr, red(sc), green(sc), blue(sc), 1.0); cairo_line_to(cr, (double)peakFrame/(double)peakFrames, 0.5-(peak1*0.5)); cairo_line_to(cr, (double)peakFrame/(double)peakFrames, 0.5-(peak2*0.5)); cairo_set_line_width (cr, 0.1/(double)width); cairo_stroke (cr); } // clean up cairo_destroy(cr); cairo_surface_destroy (surface); return 0; }
static void save_file(GtkWidget *widget, t_env *rt) { cairo_surface_t *surface; surface = cairo_image_surface_create_for_data((unsigned char *)rt->tmp_data, CAIRO_FORMAT_ARGB32, rt->w, rt->h, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, rt->w)); cairo_surface_write_to_png(surface, gtk_entry_get_text(GTK_ENTRY(widget))); gtk_widget_destroy(rt->dialog); }
ImageGStreamer::ImageGStreamer(GstBuffer*& buffer, IntSize size, cairo_format_t& cairoFormat) : m_image(0) , m_surface(0) { m_surface = cairo_image_surface_create_for_data(GST_BUFFER_DATA(buffer), cairoFormat, size.width(), size.height(), cairo_format_stride_for_width(cairoFormat, size.width())); ASSERT(cairo_surface_status(m_surface) == CAIRO_STATUS_SUCCESS); m_image = BitmapImage::create(m_surface); }
cairo_surface_t* UpdateChunk::createImage() const { ASSERT(m_sharedMemory); if (!m_sharedMemory) return 0; int stride = cairo_format_stride_for_width(imageFormat, m_rect.width()); return cairo_image_surface_create_for_data(static_cast<unsigned char*>(m_sharedMemory->data()), imageFormat, m_rect.width(), m_rect.height(), stride); }
cairo_surface_t *cairo_linuxfb_surface_create(const char *fb_name) { cairo_linuxfb_device_t *device; cairo_surface_t *surface; if (fb_name == NULL) { fb_name = "/dev/fb1"; } device = malloc(sizeof(*device)); // Open the file for reading and writing device->fb_fd = open(fb_name, O_RDWR); if (device->fb_fd == -1) { perror("Error: cannot open framebuffer device"); exit(1); } // Get variable screen information if (ioctl(device->fb_fd, FBIOGET_VSCREENINFO, &device->fb_vinfo) == -1) { perror("Error reading variable information"); exit(3); } // Figure out the size of the screen in bytes device->fb_screensize = device->fb_vinfo.xres * device->fb_vinfo.yres * device->fb_vinfo.bits_per_pixel / 8; // Map the device to memory device->fb_data = (char *)mmap(0, device->fb_screensize, PROT_READ | PROT_WRITE, MAP_SHARED, device->fb_fd, 0); if ((int)device->fb_data == -1) { perror("Error: failed to map framebuffer device to memory"); exit(4); } // Get fixed screen information if (ioctl(device->fb_fd, FBIOGET_FSCREENINFO, &device->fb_finfo) == -1) { perror("Error reading fixed information"); exit(2); } surface = cairo_image_surface_create_for_data(device->fb_data, CAIRO_FORMAT_RGB16_565, device->fb_vinfo.xres, device->fb_vinfo.yres, cairo_format_stride_for_width(CAIRO_FORMAT_RGB16_565, device->fb_vinfo.xres)); cairo_surface_set_user_data(surface, NULL, device, &cairo_linuxfb_surface_destroy); return surface; }
CairoFrame::CairoFrame(coord_t w, coord_t h) : RawFrame(w, h, RawFrame::BGRAn8, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, w)) { crs = cairo_image_surface_create_for_data(_data, CAIRO_FORMAT_ARGB32, _w, _h, _pitch); if (cairo_surface_status(crs) != CAIRO_STATUS_SUCCESS) { throw std::runtime_error("Cairo surface creation failed"); } }
LcCairoPainter* LcCairoPainter::createImagePainter(unsigned char* data , int width, int height) { cairo_surface_t* surface; cairo_t* cr; int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_ARGB32, width, height, stride); cr = cairo_create(surface); cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD); cairo_set_operator(cr, CAIRO_OPERATOR_OVER); cairo_set_tolerance(cr, 0.25); cairo_set_antialias(cr, CAIRO_ANTIALIAS_GOOD); return new LcCairoPainter(surface, cr); }
int ui_create_window(lua_State *L) { struct window_fb *window = lua_newuserdata(L, sizeof(struct window_fb)); /* open the file for reading and writing */ window->fb_fd = open("/dev/fb0", O_RDWR); if (window->fb_fd == -1) { perror("Error: cannot open framebuffer device"); exit(1); } /* get variable screen information */ if (ioctl(window->fb_fd, FBIOGET_VSCREENINFO, &window->fb_vinfo) == -1) { perror("Error reading variable information"); exit(3); } /* figure out the size of the screen in bytes */ window->fb_screensize = window->fb_vinfo.xres * window->fb_vinfo.yres * window->fb_vinfo.bits_per_pixel / 8; /* map the device to memory */ window->fb_data = mmap(0, window->fb_screensize, PROT_READ | PROT_WRITE, MAP_SHARED, window->fb_fd, 0); if (window->fb_data == (unsigned char *)-1) { perror("Error: failed to map framebuffer device to memory"); exit(4); } /* clear screen */ memset(window->fb_data, 0x010101, window->fb_screensize); window->surface = cairo_image_surface_create_for_data(window->fb_data, CAIRO_FORMAT_RGB16_565, window->fb_vinfo.xres, window->fb_vinfo.yres, cairo_format_stride_for_width(CAIRO_FORMAT_RGB16_565, window->fb_vinfo.xres)); window->ev_fd = open("/dev/input/event1", O_RDWR); if (window->ev_fd == -1) { perror("Error: cannot open keyboard"); exit(1); } luaL_getmetatable(L, "ui.window"); lua_setmetatable(L, -2); return 1; }
void guac_rdp_glyph_new(rdpContext* context, rdpGlyph* glyph) { int x, y, i; int stride; unsigned char* image_buffer; unsigned char* image_buffer_row; unsigned char* data = glyph->aj; int width = glyph->cx; int height = glyph->cy; /* Init Cairo buffer */ stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width); image_buffer = malloc(height*stride); image_buffer_row = image_buffer; /* Copy image data from image data to buffer */ for (y = 0; y<height; y++) { unsigned int* image_buffer_current; /* Get current buffer row, advance to next */ image_buffer_current = (unsigned int*) image_buffer_row; image_buffer_row += stride; for (x = 0; x<width;) { /* Get byte from image data */ unsigned int v = *(data++); /* Read bits, write pixels */ for (i = 0; i<8 && x<width; i++, x++) { /* Output RGB */ if (v & 0x80) *(image_buffer_current++) = 0xFF000000; else *(image_buffer_current++) = 0x00000000; /* Next bit */ v <<= 1; } } } /* Store glyph surface */ ((guac_rdp_glyph*) glyph)->surface = cairo_image_surface_create_for_data( image_buffer, CAIRO_FORMAT_ARGB32, width, height, stride); }
cairo_surface_t * joy_gfx3d_screen_cairo_surface_create(JoyScreen *self, GFX3D_Image image) { g_return_val_if_fail(JOY_IS_GFX3D_SCREEN(self), NULL); g_return_val_if_fail(image, NULL); struct Private *priv = GET_PRIVATE(self); #if CAIRO_HAS_GFX3D_SURFACE cairo_surface_t *surface = cairo_gfx3d_surface_create(priv->display, image); cairo_status_t status = cairo_surface_status(surface); if (G_UNLIKELY(CAIRO_STATUS_SUCCESS != status)) { return NULL; } cairo_gfx3d_surface_set_owner(surface, TRUE); return surface; #else // CAIRO_HAS_GFX3D_SURFACE GFX3D_Rect rect; GFX3D_Image_GetRect(image, &rect); gint stride; void *pixels = GFX3D_NATIVE_Surface_GetAddress( GFX3D_Image_Get_NATIVE_Surface(image), &stride); if (G_UNLIKELY(!pixels)) { return NULL; } stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, rect.iWidth); cairo_surface_t *surface = cairo_image_surface_create_for_data(pixels, CAIRO_FORMAT_ARGB32, rect.iWidth, rect.iHeight, stride); cairo_status_t status = cairo_surface_status(surface); if (G_UNLIKELY(CAIRO_STATUS_SUCCESS != status)) { cairo_surface_destroy(surface); return NULL; } struct Data *data = g_slice_new0(struct Data); if (G_UNLIKELY(!data)) { cairo_surface_destroy(surface); return NULL; } data->display = priv->display; data->image = image; status = cairo_surface_set_user_data(surface, &key, data, (cairo_destroy_func_t)data_destroy); if (G_UNLIKELY(CAIRO_STATUS_SUCCESS != status)) { cairo_surface_destroy(surface); g_slice_free(struct Data, data); return NULL; } return surface; #endif // CAIRO_HAS_GFX3D_SURFACE }
cairo_surface_t *CreateCairoSurface(const Image& img) { Size isz = img.GetSize(); cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, isz.cx, isz.cy); cairo_surface_flush(surface); byte *a = (byte *)cairo_image_surface_get_data(surface); int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, isz.cx); for(int yy = 0; yy < isz.cy; yy++) { Copy((RGBA *)a, img[yy], isz.cx); a += stride; } cairo_surface_mark_dirty(surface); return surface; }
static void _pdf_doc_render_page( struct _pdf_doc *self, cairo_t *cr, int x, int y, int pageno, mume_matrix_t ctm, mume_rect_t rect) { /* TODO: implement a fz_device to rendering directly to cairo. */ fz_colorspace *colorspace; fz_bbox bbox; fz_device *idev; fz_pixmap *pixmap; fz_display_list *list; cairo_format_t format; cairo_surface_t *surface; int stride; #ifdef _WIN32 colorspace = fz_device_bgr; #else colorspace = fz_device_rgb; #endif list = _pdf_doc_get_list(self, pageno); bbox = _mume_rect_to_fz_bbox(rect); pixmap = fz_new_pixmap_with_rect(colorspace, bbox); if (NULL == pixmap) { mume_error(("fz_new_pixmap_with_rect(%d, %d, %d, %d)\n", bbox.x0, bbox.y0, bbox.x1, bbox.y1)); return; } fz_clear_pixmap_with_color(pixmap, 255); idev = fz_new_draw_device(self->glyph_cache, pixmap); fz_execute_display_list( list, idev, _mume_matrix_to_fz_matrix(ctm), bbox); fz_free_device(idev); /* Create cairo surface. */ format = CAIRO_FORMAT_ARGB32; stride = cairo_format_stride_for_width(format, pixmap->w); surface = cairo_image_surface_create_for_data( pixmap->samples, format, pixmap->w, pixmap->h, stride); if (surface) { cairo_set_source_surface(cr, surface, x, y); cairo_rectangle(cr, x, y, rect.width, rect.height); cairo_fill(cr); cairo_surface_destroy(surface); } fz_drop_pixmap(pixmap); }
static void remmina_rdp_event_connected(RemminaProtocolWidget* gp, RemminaPluginRdpUiObject* ui) { rfContext* rfi; int stride; rfi = GET_DATA(gp); gtk_widget_realize(rfi->drawing_area); stride = cairo_format_stride_for_width(rfi->cairo_format, rfi->width); rfi->surface = cairo_image_surface_create_for_data((unsigned char*) rfi->primary_buffer, rfi->cairo_format, rfi->width, rfi->height, stride); gtk_widget_queue_draw_area(rfi->drawing_area, 0, 0, rfi->width, rfi->height); remmina_rdp_event_update_scale(gp); }