static GdkPixbuf * add_holes_to_pixbuf_small (GdkPixbuf *pixbuf, int width, int height) { GdkPixbuf *holes, *tmp, *target; char *filename; int i; filename = g_build_filename (DATADIR, "xplayer", "filmholes.png", NULL); holes = gdk_pixbuf_new_from_file (filename, NULL); g_free (filename); if (holes == NULL) { g_object_ref (pixbuf); return pixbuf; } g_assert (gdk_pixbuf_get_has_alpha (pixbuf) == FALSE); g_assert (gdk_pixbuf_get_has_alpha (holes) != FALSE); target = g_object_ref (pixbuf); for (i = 0; i < height; i += gdk_pixbuf_get_height (holes)) { gdk_pixbuf_composite (holes, target, 0, i, MIN (width, gdk_pixbuf_get_width (holes)), MIN (height - i, gdk_pixbuf_get_height (holes)), 0, i, 1, 1, GDK_INTERP_NEAREST, 255); } tmp = gdk_pixbuf_flip (holes, FALSE); g_object_unref (holes); holes = tmp; for (i = 0; i < height; i += gdk_pixbuf_get_height (holes)) { gdk_pixbuf_composite (holes, target, width - gdk_pixbuf_get_width (holes), i, MIN (width, gdk_pixbuf_get_width (holes)), MIN (height - i, gdk_pixbuf_get_height (holes)), width - gdk_pixbuf_get_width (holes), i, 1, 1, GDK_INTERP_NEAREST, 255); } g_object_unref (holes); return target; }
void Pixbuf::_forceAlpha() { if (gdk_pixbuf_get_has_alpha(_pixbuf)) return; GdkPixbuf *old = _pixbuf; _pixbuf = gdk_pixbuf_add_alpha(old, FALSE, 0, 0, 0); g_object_unref(old); }
static void file_loaded (GObject *source_object, GAsyncResult *result, gpointer user_data) { MetaBackgroundImage *image = META_BACKGROUND_IMAGE (source_object); GError *error = NULL; CoglError *catch_error = NULL; GTask *task; CoglTexture *texture; GdkPixbuf *pixbuf; int width, height, row_stride; guchar *pixels; gboolean has_alpha; task = G_TASK (result); pixbuf = g_task_propagate_pointer (task, &error); if (pixbuf == NULL) { char *uri = g_file_get_uri (image->file); g_warning ("Failed to load background '%s': %s", uri, error->message); g_clear_error (&error); g_free (uri); goto out; } width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); row_stride = gdk_pixbuf_get_rowstride (pixbuf); pixels = gdk_pixbuf_get_pixels (pixbuf); has_alpha = gdk_pixbuf_get_has_alpha (pixbuf); texture = meta_create_texture (width, height, has_alpha ? COGL_TEXTURE_COMPONENTS_RGBA : COGL_TEXTURE_COMPONENTS_RGB, META_TEXTURE_ALLOW_SLICING); if (!cogl_texture_set_data (texture, has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, row_stride, pixels, 0, &catch_error)) { g_warning ("Failed to create texture for background"); cogl_error_free (catch_error); cogl_object_unref (texture); } image->texture = texture; out: if (pixbuf != NULL) g_object_unref (pixbuf); image->loaded = TRUE; g_signal_emit (image, signals[LOADED], 0); }
/** * eel_gdk_pixbuf_fill_rectangle_with_color: * @pixbuf: Target pixbuf to fill into. * @area: Rectangle to fill. * @color: The color to use. * * Fill the rectangle with the the given color. */ void eel_gdk_pixbuf_fill_rectangle_with_color (GdkPixbuf *pixbuf, EelIRect area, guint32 color) { EelIRect target; guchar red; guchar green; guchar blue; guchar alpha; guchar *pixels; gboolean has_alpha; guint pixel_offset; guint rowstride; guchar *row_offset; int x; int y; g_return_if_fail (eel_gdk_pixbuf_is_valid (pixbuf)); target = eel_gdk_pixbuf_intersect (pixbuf, 0, 0, area); if (eel_irect_is_empty (&target)) { return; } pixels = gdk_pixbuf_get_pixels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); has_alpha = gdk_pixbuf_get_has_alpha (pixbuf); pixel_offset = has_alpha ? 4 : 3; red = EEL_RGBA_COLOR_GET_R (color); green = EEL_RGBA_COLOR_GET_G (color); blue = EEL_RGBA_COLOR_GET_B (color); alpha = EEL_RGBA_COLOR_GET_A (color); row_offset = pixels + target.y0 * rowstride; for (y = target.y0; y < target.y1; y++) { guchar *offset = row_offset + (target.x0 * pixel_offset); for (x = target.x0; x < target.x1; x++) { *(offset++) = red; *(offset++) = green; *(offset++) = blue; if (has_alpha) { *(offset++) = alpha; } } row_offset += rowstride; } }
/* * This function is taken from Bickley, Copyright (c) Intel Corporation 2008. */ static gboolean is_interesting (GdkPixbuf *pixbuf) { int width, height, y, rowstride; gboolean has_alpha; guint32 histogram[4][4][4] = {{{0,},},}; guchar *pixels; guint pxl_count = 0, count, i; width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); has_alpha = gdk_pixbuf_get_has_alpha (pixbuf); pixels = gdk_pixbuf_get_pixels (pixbuf); for (y = 0; y < height; y++) { guchar *row = pixels + (y * rowstride); int c; for (c = 0; c < width; c++) { guchar r, g, b; r = row[0]; g = row[1]; b = row[2]; histogram[r / 64][g / 64][b / 64]++; if (has_alpha) { row += 4; } else { row += 3; } pxl_count++; } } count = 0; for (i = 0; i < 4; i++) { int j; for (j = 0; j < 4; j++) { int k; for (k = 0; k < 4; k++) { /* Count how many bins have more than 1% of the pixels in the histogram */ if (histogram[i][j][k] > pxl_count / 100) { count++; } } } } /* Image is boring if there is only 1 bin with > 1% of pixels */ return count > 1; }
static CoglTexture * pixbuf_to_cogl_texture (GdkPixbuf *pixbuf) { return data_to_cogl_texture (gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_has_alpha (pixbuf), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), gdk_pixbuf_get_rowstride (pixbuf)); }
void gp_image_set_mask ( GpImage *image, GdkBitmap *mask ) { GdkPixbuf *pixbuf; GdkPixbuf *m_pixbuf; guchar *pixels, *m_pixels; guchar *p, *m_p; gint w, h; gint n_channels, rowstride; g_return_if_fail ( GP_IS_IMAGE (image) ); pixbuf = image->priv->pixbuf; if(!gdk_pixbuf_get_has_alpha ( pixbuf ) ) { /*add alpha*/ GdkPixbuf *tmp ; tmp = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0); g_object_unref(pixbuf); pixbuf = tmp; } m_pixbuf = gdk_pixbuf_copy ( pixbuf ); gdk_pixbuf_get_from_drawable ( m_pixbuf, mask, gdk_drawable_get_colormap (mask), 0,0, 0,0, -1,-1); n_channels = gdk_pixbuf_get_n_channels ( pixbuf ); rowstride = gdk_pixbuf_get_rowstride ( pixbuf ); w = gdk_pixbuf_get_width ( pixbuf ); h = gdk_pixbuf_get_height ( pixbuf ); pixels = gdk_pixbuf_get_pixels ( pixbuf ); m_pixels = gdk_pixbuf_get_pixels ( m_pixbuf ); while (h--) { guint i = w; p = pixels; m_p = m_pixels; while (i--) { if(m_p[0] == 0) { p[0] = 0; p[1] = 0; p[2] = 0; p[3] = 0; } p += n_channels; m_p += n_channels; } pixels += rowstride; m_pixels += rowstride; } g_object_unref (m_pixbuf); }
static void load_animation (GInputStream *input_stream, CbMedia *media) { GdkPixbufAnimation *animation; GdkPixbuf *frame; GError *error = NULL; cairo_surface_t *surface; cairo_t *ct; gboolean has_alpha; animation = gdk_pixbuf_animation_new_from_stream (input_stream, NULL, &error); if (error) { g_warning ("Couldn't load pixbuf: %s (%s)", error->message, media->url); mark_invalid (media); g_error_free (error); return; } frame = gdk_pixbuf_animation_get_static_image (animation); if (!gdk_pixbuf_animation_is_static_image (animation)) media->animation = animation; /* Takes ref */ else media->animation = NULL; has_alpha = gdk_pixbuf_get_has_alpha (frame); surface = cairo_image_surface_create (has_alpha ? CAIRO_FORMAT_ARGB32 : CAIRO_FORMAT_RGB24, gdk_pixbuf_get_width (frame), gdk_pixbuf_get_height (frame)); ct = cairo_create (surface); gdk_cairo_set_source_pixbuf (ct, frame, 0.0, 0.0); cairo_paint (ct); cairo_destroy (ct); media->surface = surface; if (media->surface == NULL) { g_warning ("Surface of %p is null", media); mark_invalid (media); goto out; } media->width = gdk_pixbuf_get_width (frame); media->height = gdk_pixbuf_get_height (frame); media->loaded = TRUE; media->invalid = FALSE; out: if (media->animation == NULL) g_object_unref (animation); cb_media_loading_finished (media); }
/** * gtk_clutter_texture_set_from_pixbuf: * @texture: a #GtkClutterTexture * @pixbuf: a #GdkPixbuf * @error: a return location for errors * * Sets the contents of @texture with a copy of @pixbuf. * * Return value: %TRUE on success, %FALSE on failure. */ gboolean gtk_clutter_texture_set_from_pixbuf (GtkClutterTexture *texture, GdkPixbuf *pixbuf, GError **error) { g_return_val_if_fail (GTK_CLUTTER_IS_TEXTURE (texture), FALSE); g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE); return clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (texture), gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_has_alpha (pixbuf), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), gdk_pixbuf_get_rowstride (pixbuf), gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3, 0, error); }
gint main (gint argc, gchar *argv[]) { ClutterContent *image; ClutterActor *stage; ClutterActor *box; GdkPixbuf *pixbuf; if (clutter_init(&argc, &argv) != CLUTTER_INIT_SUCCESS) { g_printerr("Failed to initialize clutter.\n"); return 1; } stage = clutter_stage_new(); clutter_stage_set_title (CLUTTER_STAGE (stage), "Image Viewer"); clutter_actor_set_size(stage, 1400, 1200); clutter_actor_set_position(stage, 100, 100); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); clutter_actor_show(stage); pixbuf = gdk_pixbuf_new_from_file("testimage_8000.png", NULL); g_assert(pixbuf); image = clutter_image_new(); clutter_image_set_data(CLUTTER_IMAGE(image), gdk_pixbuf_get_pixels(pixbuf), gdk_pixbuf_get_has_alpha(pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf), gdk_pixbuf_get_rowstride(pixbuf), NULL); g_object_unref(pixbuf); box = clutter_actor_new(); clutter_actor_set_position(box, 0, 0); clutter_actor_set_height(box, 8000); clutter_actor_set_width(box, 1200); //clutter_actor_add_constraint(box, clutter_bind_constraint_new(stage, CLUTTER_BIND_WIDTH, 0.0)); clutter_actor_set_content(box, image); clutter_actor_add_child(stage, box); clutter_actor_show(box); clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE); clutter_actor_animate(box, CLUTTER_EASE_IN_OUT_QUAD, 4000, "y", -8000.0, NULL); clutter_main(); return 0; }
static gboolean rc_area_changed_cb(gpointer data) { RendererClutter *rc = (RendererClutter *)data; PixbufRenderer *pr = rc->pr; RendererClutterAreaParam *par = rc->pending_updates->data; gint h = MAX_REGION_AREA / par->w; if (h == 0) h = 1; if (h > par->h) h = par->h; DEBUG_3("%s upload start", get_exec_time()); if (pr->pixbuf) { CoglHandle texture = clutter_texture_get_cogl_texture(CLUTTER_TEXTURE(rc->texture)); cogl_texture_set_region(texture, par->x + GET_RIGHT_PIXBUF_OFFSET(rc), par->y, par->x, par->y, par->w, h, par->w, h, gdk_pixbuf_get_has_alpha(pr->pixbuf) ? COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888, gdk_pixbuf_get_rowstride(pr->pixbuf), gdk_pixbuf_get_pixels(pr->pixbuf)); } DEBUG_3("%s upload end", get_exec_time()); rc_area_clip_add(rc, par->x, par->y, par->w, h); par->y += h; par->h -= h; if (par->h == 0) { rc->pending_updates = g_list_remove(rc->pending_updates, par); g_free(par); } if (!rc->pending_updates) { clutter_actor_queue_redraw(CLUTTER_ACTOR(rc->texture)); rc->idle_update = 0; /* FIXME: find a better place for this */ if (!rc->clut_updated) rc_prepare_post_process_lut(rc); return FALSE; } rc_schedule_texture_upload(rc); return FALSE; /* it was rescheduled, possibly with different prio */ }
BitmapPtr BitmapLoader::load(const UTF8String& sFName, PixelFormat pf) const { AVG_ASSERT(s_pBitmapLoader != 0); GError* pError = 0; GdkPixbuf* pPixBuf; { ScopeTimer timer(GDKPixbufProfilingZone); pPixBuf = gdk_pixbuf_new_from_file(sFName.c_str(), &pError); } if (!pPixBuf) { string sErr = pError->message; g_error_free(pError); throw Exception(AVG_ERR_FILEIO, sErr); } IntPoint size = IntPoint(gdk_pixbuf_get_width(pPixBuf), gdk_pixbuf_get_height(pPixBuf)); PixelFormat srcPF; if (gdk_pixbuf_get_has_alpha(pPixBuf)) { srcPF = R8G8B8A8; } else { srcPF = R8G8B8; } if (pf == NO_PIXELFORMAT) { if (m_bBlueFirst) { if (srcPF == R8G8B8A8) { pf = B8G8R8A8; } else if (srcPF == R8G8B8) { pf = B8G8R8X8; } } else { if (srcPF == R8G8B8A8) { pf = R8G8B8A8; } else if (srcPF == R8G8B8) { pf = R8G8B8X8; } } } BitmapPtr pBmp(new Bitmap(size, pf, sFName)); { ScopeTimer timer(ConvertProfilingZone); int stride = gdk_pixbuf_get_rowstride(pPixBuf); guchar* pSrc = gdk_pixbuf_get_pixels(pPixBuf); BitmapPtr pSrcBmp(new Bitmap(size, srcPF, pSrc, stride, false)); { ScopeTimer timer(RGBFlipProfilingZone); if (pixelFormatIsBlueFirst(pf) != pixelFormatIsBlueFirst(srcPF)) { FilterFlipRGB().applyInPlace(pSrcBmp); } } pBmp->copyPixels(*pSrcBmp); } g_object_unref(pPixBuf); return pBmp; }
static GdkPixbuf* create_spotlight_pixbuf(GdkPixbuf *src, guint32 color, guchar alpha) { GdkPixbuf *dest; int i, j; int width, height, has_alpha, src_row_stride, dst_row_stride; guchar *target_pixels, *original_pixels; guchar *pixsrc, *pixdest; guchar r, g, b; gint n_channels; n_channels = gdk_pixbuf_get_n_channels(src); has_alpha = gdk_pixbuf_get_has_alpha(src); width = gdk_pixbuf_get_width(src); height = gdk_pixbuf_get_height(src); g_return_val_if_fail(gdk_pixbuf_get_colorspace(src) == GDK_COLORSPACE_RGB, NULL); g_return_val_if_fail((!has_alpha && n_channels == 3) || (has_alpha && n_channels == 4), NULL); g_return_val_if_fail(gdk_pixbuf_get_bits_per_sample(src) == 8, NULL); dest = gdk_pixbuf_new(gdk_pixbuf_get_colorspace(src), has_alpha, gdk_pixbuf_get_bits_per_sample(src), width, height); dst_row_stride = gdk_pixbuf_get_rowstride(dest); src_row_stride = gdk_pixbuf_get_rowstride(src); target_pixels = gdk_pixbuf_get_pixels(dest); original_pixels = gdk_pixbuf_get_pixels(src); r = (color & 0xff0000) >> 16; g = (color & 0xff00) >> 8; b = color & 0xff; for (i = 0; i < height; i++) { gint tmp; pixdest = target_pixels + i * dst_row_stride; pixsrc = original_pixels + i * src_row_stride; for (j = 0; j < width; j++) { tmp = (*pixsrc++ * alpha + r * (255 - alpha)) / 255; *pixdest++ = (guchar) MIN(255, tmp); tmp = (*pixsrc++ * alpha + g * (255 - alpha)) / 255; *pixdest++ = (guchar) MIN(255, tmp); tmp = (*pixsrc++ * alpha + b * (255 - alpha)) / 255; *pixdest++ = (guchar) MIN(255, tmp); if (has_alpha) *pixdest++ = *pixsrc++; } } return dest; }
static nsresult moz_gdk_pixbuf_to_channel(GdkPixbuf* aPixbuf, nsIURI *aURI, nsIChannel **aChannel) { int width = gdk_pixbuf_get_width(aPixbuf); int height = gdk_pixbuf_get_height(aPixbuf); NS_ENSURE_TRUE(height < 256 && width < 256 && height > 0 && width > 0 && gdk_pixbuf_get_colorspace(aPixbuf) == GDK_COLORSPACE_RGB && gdk_pixbuf_get_bits_per_sample(aPixbuf) == 8 && gdk_pixbuf_get_has_alpha(aPixbuf) && gdk_pixbuf_get_n_channels(aPixbuf) == 4, NS_ERROR_UNEXPECTED); const int n_channels = 4; gsize buf_size = 3 + n_channels * height * width; PRUint8 * const buf = (PRUint8*)NS_Alloc(buf_size); NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY); PRUint8 *out = buf; *(out++) = width; *(out++) = height; *(out++) = 8; // bits of alpha per pixel const guchar * const pixels = gdk_pixbuf_get_pixels(aPixbuf); int rowextra = gdk_pixbuf_get_rowstride(aPixbuf) - width * n_channels; // encode the RGB data and the A data const guchar * in = pixels; PRUint8 *alpha_out = out + height * width * 3; #ifdef DEBUG PRUint8 * const alpha_start = alpha_out; #endif for (int y = 0; y < height; ++y, in += rowextra) { for (int x = 0; x < width; ++x) { *(out++) = *(in++); // R *(out++) = *(in++); // G *(out++) = *(in++); // B *(alpha_out++) = *(in++); // A } } NS_ASSERTION(out == alpha_start && alpha_out == buf + buf_size, "size miscalculation"); nsresult rv; nsCOMPtr<nsIInputStream> stream; rv = NS_NewByteInputStream(getter_AddRefs(stream), (char*)buf, buf_size); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<nsIStringInputStream> sstream = do_QueryInterface(stream); sstream->AdoptData((char*)buf, buf_size); // previous call was |ShareData| rv = NS_NewInputStreamChannel(aChannel, aURI, stream, NS_LITERAL_CSTRING("image/icon")); return rv; }
static void put_bounding_box(GdkPixbuf *pixbuf, ImageInfo *ii) { int i, width, height, rowstride, n_channels; guchar *pixels, *p; const int bb_width = get_big_image_width_sub(); const int bb_height = get_big_image_height_sub(); int ns = ii->ns; int nl = ii->nl; n_channels = gdk_pixbuf_get_n_channels (pixbuf); g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB); g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8); g_assert (!gdk_pixbuf_get_has_alpha (pixbuf)); g_assert (n_channels == 3); width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); pixels = gdk_pixbuf_get_pixels (pixbuf); int bb_min_x = (center_samp - bb_width*zoom/2) * width / ns; if (bb_min_x < 0) bb_min_x = 0; if (bb_min_x > width-1) bb_min_x = width-1; int bb_max_x = (center_samp + bb_width*zoom/2) * width / ns; if (bb_max_x < 0) bb_max_x = 0; if (bb_max_x > width-1) bb_max_x = width-1; int bb_min_y = (center_line - bb_height*zoom/2) * height / nl; if (bb_min_y < 0) bb_min_y = 0; if (bb_min_y > height-1) bb_min_y = height-1; int bb_max_y = (center_line + bb_height*zoom/2) * height / nl; if (bb_max_y < 0) bb_max_y = 0; if (bb_max_y > height-1) bb_max_y = height-1; for (i=bb_min_x; i<=bb_max_x; ++i) { p = pixels + bb_min_y * rowstride + i * n_channels; p[0] = 255; p[1] = p[2] = 0; p = pixels + bb_max_y * rowstride + i * n_channels; p[0] = 255; p[1] = p[2] = 0; } for (i=bb_min_y+1; i<bb_max_y; ++i) { p = pixels + i * rowstride + bb_min_x * n_channels; p[0] = 255; p[1] = p[2] = 0; p = pixels + i * rowstride + bb_max_x * n_channels; p[0] = 255; p[1] = p[2] = 0; } }
static CoglHandle pixbuf_to_cogl_handle (GdkPixbuf *pixbuf, gboolean add_padding) { CoglHandle texture, offscreen; CoglColor clear_color; int width, height; guint size; width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); size = MAX (width, height); if (!add_padding || width == height) return cogl_texture_new_from_data (width, height, COGL_TEXTURE_NONE, gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, COGL_PIXEL_FORMAT_ANY, gdk_pixbuf_get_rowstride (pixbuf), gdk_pixbuf_get_pixels (pixbuf)); texture = cogl_texture_new_with_size (size, size, COGL_TEXTURE_NO_SLICING, COGL_PIXEL_FORMAT_ANY); offscreen = cogl_offscreen_new_to_texture (texture); cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0); cogl_push_framebuffer (offscreen); cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR); cogl_pop_framebuffer (); cogl_handle_unref (offscreen); cogl_texture_set_region (texture, 0, 0, (size - width) / 2, (size - height) / 2, width, height, width, height, gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, gdk_pixbuf_get_rowstride (pixbuf), gdk_pixbuf_get_pixels (pixbuf)); return texture; }
static cairo_surface_t * display_create_drm_surface_from_file(struct display *display, const char *filename, struct rectangle *rect) { cairo_surface_t *surface; GdkPixbuf *pixbuf; GError *error = NULL; int stride, i; unsigned char *pixels, *p, *end; struct drm_surface_data *data; pixbuf = gdk_pixbuf_new_from_file_at_scale(filename, rect->width, rect->height, FALSE, &error); if (error != NULL) return NULL; if (!gdk_pixbuf_get_has_alpha(pixbuf) || gdk_pixbuf_get_n_channels(pixbuf) != 4) { gdk_pixbuf_unref(pixbuf); return NULL; } stride = gdk_pixbuf_get_rowstride(pixbuf); pixels = gdk_pixbuf_get_pixels(pixbuf); for (i = 0; i < rect->height; i++) { p = pixels + i * stride; end = p + rect->width * 4; while (p < end) { unsigned int t; MULT(p[0], p[0], p[3], t); MULT(p[1], p[1], p[3], t); MULT(p[2], p[2], p[3], t); p += 4; } } surface = display_create_drm_surface(display, rect); data = cairo_surface_get_user_data(surface, &surface_data_key); cairo_device_acquire(display->device); glBindTexture(GL_TEXTURE_2D, data->texture); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, rect->width, rect->height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); cairo_device_release(display->device); gdk_pixbuf_unref(pixbuf); return surface; }
static jobject dnd_target_get_image(JNIEnv *env) { GdkPixbuf *buf; GInputStream *stream; jobject result = NULL; GdkAtom targets[] = { TARGET_MIME_PNG_ATOM, TARGET_MIME_JPEG_ATOM, TARGET_MIME_TIFF_ATOM, TARGET_MIME_BMP_ATOM, 0}; GdkAtom *cur_target = targets; selection_data_ctx ctx; while(*cur_target != 0 && result == NULL) { if (dnd_target_receive_data(env, *cur_target, &ctx)) { stream = g_memory_input_stream_new_from_data(ctx.data, ctx.length * (ctx.format / 8), (GDestroyNotify)g_free); buf = gdk_pixbuf_new_from_stream(stream, NULL, NULL); if (buf) { int w; int h; int stride; guchar *data; jbyteArray data_array; jobject buffer; if (!gdk_pixbuf_get_has_alpha(buf)) { GdkPixbuf *tmp_buf = gdk_pixbuf_add_alpha(buf, FALSE, 0, 0, 0); g_object_unref(buf); buf = tmp_buf; } w = gdk_pixbuf_get_width(buf); h = gdk_pixbuf_get_height(buf); stride = gdk_pixbuf_get_rowstride(buf); data = gdk_pixbuf_get_pixels(buf); //Actually, we are converting RGBA to BGRA, but that's the same operation data = (guchar*) convert_BGRA_to_RGBA((int*) data, stride, h); data_array = env->NewByteArray(stride * h); env->SetByteArrayRegion(data_array, 0, stride*h, (jbyte*) data); buffer = env->CallStaticObjectMethod(jByteBufferCls, jByteBufferWrap, data_array); result = env->NewObject(jGtkPixelsCls, jGtkPixelsInit, w, h, buffer); g_object_unref(buf); g_free(data); // data from convert_BGRA_to_RGBA } g_object_unref(stream); } ++cur_target; } return result; }
/** * gwy_gl_material_sample_to_pixbuf: * @gl_material: A GL material to sample. * @pixbuf: A pixbuf to sample gl_material to (in horizontal direction). * * Samples GL material to a provided pixbuf. **/ void gwy_gl_material_sample_to_pixbuf(GwyGLMaterial *gl_material, GdkPixbuf *pixbuf) { GwyGLMaterial *glm = gl_material; gint width, height, rowstride, i, j, bpp; gboolean has_alpha; guchar *row, *pdata; guchar alpha; gdouble p, q; g_return_if_fail(GWY_IS_GL_MATERIAL(gl_material)); g_return_if_fail(GDK_IS_PIXBUF(pixbuf)); width = gdk_pixbuf_get_width(pixbuf); height = gdk_pixbuf_get_height(pixbuf); rowstride = gdk_pixbuf_get_rowstride(pixbuf); has_alpha = gdk_pixbuf_get_has_alpha(pixbuf); pdata = gdk_pixbuf_get_pixels(pixbuf); bpp = 3 + (has_alpha ? 1 : 0); q = (width == 1) ? 0.0 : 1.0/(width - 1.0); p = (height == 1) ? 0.0 : 1.0/(height - 1.0); alpha = (guchar)CLAMP(MAX_CVAL*glm->ambient.a, 0.0, 255.0); for (j = 0; j < width; j++) { gdouble VRp = j*q*(2.0 - j*q); gdouble s = pow(VRp, 128.0*glm->shininess); GwyRGBA s0; s0.r = glm->emission.r + 0.3*glm->ambient.r + glm->specular.r*s; s0.g = glm->emission.g + 0.3*glm->ambient.g + glm->specular.g*s; s0.b = glm->emission.b + 0.3*glm->ambient.b + glm->specular.b*s; for (i = 0; i < height; i++) { gdouble LNp = 1.0 - i*p; gdouble v; row = pdata + i*rowstride + j*bpp; v = s0.r + glm->diffuse.r*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); v = s0.g + glm->diffuse.g*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); v = s0.b + glm->diffuse.b*LNp; *(row++) = (guchar)CLAMP(MAX_CVAL*v, 0.0, 255.0); if (has_alpha) *(row++) = alpha; } } }
/* Create and initalize global sticky notes instance */ void stickynotes_applet_init (PanelApplet *panel_applet) { stickynotes = g_new(StickyNotes, 1); stickynotes->notes = NULL; stickynotes->applets = NULL; stickynotes->last_timeout_data = 0; g_set_application_name (_("Sticky Notes")); /* Register size for icons */ gtk_icon_size_register ("stickynotes_icon_size", 8,8); gtk_window_set_default_icon_name ("consort-sticky-notes-applet"); stickynotes->icon_normal = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default (), "consort-sticky-notes-applet", 48, 0, NULL); stickynotes->icon_prelight = gdk_pixbuf_new ( gdk_pixbuf_get_colorspace (stickynotes->icon_normal), gdk_pixbuf_get_has_alpha (stickynotes->icon_normal), gdk_pixbuf_get_bits_per_sample ( stickynotes->icon_normal), gdk_pixbuf_get_width (stickynotes->icon_normal), gdk_pixbuf_get_height (stickynotes->icon_normal)); stickynotes_make_prelight_icon (stickynotes->icon_prelight, stickynotes->icon_normal, 30); stickynotes->gconf = gconf_client_get_default(); stickynotes->visible = TRUE; stickynotes_applet_init_icons(); stickynotes_applet_init_prefs(); /* Watch GConf values */ gconf_client_add_dir (stickynotes->gconf, GCONF_PATH, GCONF_CLIENT_PRELOAD_NONE, NULL); gconf_client_notify_add (stickynotes->gconf, GCONF_PATH "/defaults", (GConfClientNotifyFunc) preferences_apply_cb, NULL, NULL, NULL); gconf_client_notify_add (stickynotes->gconf, GCONF_PATH "/settings", (GConfClientNotifyFunc) preferences_apply_cb, NULL, NULL, NULL); /* Max height for large notes*/ stickynotes->max_height = 0.8*gdk_screen_get_height( gdk_screen_get_default() ); /* Load sticky notes */ stickynotes_load (gtk_widget_get_screen (GTK_WIDGET (panel_applet))); install_check_click_on_desktop (); }
/* * Returns a copy of pixbuf src rotated 90 degrees clockwise or 90 counterclockwise */ void rotate90(GdkPixbuf *dest, const GdkPixbuf *src, int sw, int sh, bool counter_clockwise) { gint has_alpha; //gint sw, sh, srs; gint srs; gint drs; guchar *s_pix; guchar *d_pix; gint i, j; gint a; //GdkPixbuf *buffer; guchar *b_pix; gint brs; gint w, h; if (src == 0) return; //sw = gdk_pixbuf_get_width(src); //sh = gdk_pixbuf_get_height(src); has_alpha = gdk_pixbuf_get_has_alpha(src); srs = gdk_pixbuf_get_rowstride(src); s_pix = gdk_pixbuf_get_pixels(src); drs = gdk_pixbuf_get_rowstride(dest); d_pix = gdk_pixbuf_get_pixels(dest); a = has_alpha ? 4 : 3; if (buffer == 0) { buffer = gdk_pixbuf_new(GDK_COLORSPACE_RGB, has_alpha, 8, ROTATE_BUFFER_WIDTH, ROTATE_BUFFER_HEIGHT); } b_pix = gdk_pixbuf_get_pixels(buffer); brs = gdk_pixbuf_get_rowstride(buffer); for (i = 0; i < sh; i+= ROTATE_BUFFER_WIDTH) { w = MIN(ROTATE_BUFFER_WIDTH, sh - i); for (j = 0; j < sw; j += ROTATE_BUFFER_HEIGHT) { gint x, y; h = MIN(ROTATE_BUFFER_HEIGHT, sw - j); pixbuf_copy_block_rotate(s_pix, srs, j, i, b_pix, brs, h, w, a, counter_clockwise); if (counter_clockwise) { x = i; y = sw - h - j; } else { x = sh - w - i; y = j; } pixbuf_copy_block(b_pix, brs, w, h, d_pix, drs, x, y, a); } } }
static CoglHandle pixbuf_to_cogl_handle (GdkPixbuf *pixbuf, gboolean add_padding) { return data_to_cogl_handle (gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_has_alpha (pixbuf), gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), gdk_pixbuf_get_rowstride (pixbuf), add_padding); }
void rotate180(GdkPixbuf *buffer) { if (buffer == 0) return; const gint width = gdk_pixbuf_get_width(buffer); if (width <= 1) { return; } const gint height = gdk_pixbuf_get_height(buffer); const gint brs = gdk_pixbuf_get_rowstride(buffer); guchar *s_pix = gdk_pixbuf_get_pixels(buffer); guchar *d_pix = s_pix + (height - 1) * brs; const gint a = gdk_pixbuf_get_has_alpha(buffer) ? 4 : 3; guchar * const sbuf = new guchar[width * a]; guchar * const dbuf = new guchar[width * a]; guchar * const tmp = new guchar[a]; while (s_pix < d_pix) { memcpy(sbuf, s_pix, width * a); memcpy(dbuf, d_pix, width * a); guchar *s = sbuf; guchar *d = dbuf + (width - 1) * a; for (int i = 0; i < width; ++i) { memcpy(tmp, s, a); memcpy(s, d, a); memcpy(d, tmp, a); s += a; d -= a; } memcpy(s_pix, sbuf, width * a); memcpy(d_pix, dbuf, width * a); s_pix += brs; d_pix -= brs; } if (s_pix == d_pix) { memcpy(sbuf, s_pix, width * a); guchar *s = sbuf; guchar *d = sbuf + (width - 1) * a; while (s < d) { memcpy(tmp, s, a); memcpy(s, d, a); memcpy(d, tmp, a); s += a; d -= a; } memcpy(s_pix, sbuf, width * a); } delete[] sbuf; delete[] dbuf; delete[] tmp; }
static CoglHandle pixbuf_to_cogl_handle (GdkPixbuf *pixbuf) { return cogl_texture_new_from_data (gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf), COGL_TEXTURE_NONE, gdk_pixbuf_get_has_alpha (pixbuf) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, COGL_PIXEL_FORMAT_ANY, gdk_pixbuf_get_rowstride (pixbuf), gdk_pixbuf_get_pixels (pixbuf)); }
/** * eel_gdk_pixbuf_new_from_pixbuf_sub_area: * @pixbuf: The source pixbuf. * @area: The area within the source pixbuf to use for the sub pixbuf. * This area needs to be contained within the bounds of the * source pixbuf, otherwise it will be clipped to that. * * Return value: A newly allocated pixbuf that shares the pixel data * of the source pixbuf in order to represent a sub area. * * Create a pixbuf from a sub area of another pixbuf. The resulting pixbuf * will share the pixel data of the source pixbuf. Memory bookeeping is * all taken care for the caller. All you need to do is g_object_unref() * the resulting pixbuf to properly free resources. */ GdkPixbuf * eel_gdk_pixbuf_new_from_pixbuf_sub_area (GdkPixbuf *pixbuf, EelIRect area) { GdkPixbuf *sub_pixbuf; EelIRect target; guchar *pixels; g_return_val_if_fail (eel_gdk_pixbuf_is_valid (pixbuf), NULL); g_return_val_if_fail (!eel_irect_is_empty (&area), NULL); /* Clip the pixbuf by the given area; bail if no work */ target = eel_gdk_pixbuf_intersect (pixbuf, 0, 0, area); if (eel_irect_is_empty (&target)) { return NULL; } /* Since we are going to be sharing the given pixbuf's data, we need * to ref it. It will be unreffed in the destroy function above */ g_object_ref (pixbuf); /* Compute the offset into the pixel data */ pixels = gdk_pixbuf_get_pixels (pixbuf) + (target.y0 * gdk_pixbuf_get_rowstride (pixbuf)) + (target.x0 * (gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3)); /* Make a pixbuf pretending its real estate is the sub area */ sub_pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha (pixbuf), 8, eel_irect_get_width (target), eel_irect_get_height (target), gdk_pixbuf_get_rowstride (pixbuf), pixbuf_destroy_callback, pixbuf); return sub_pixbuf; }
static cairo_surface_t * display_create_shm_surface_from_file(struct display *display, const char *filename, struct rectangle *rect) { cairo_surface_t *surface; GdkPixbuf *pixbuf; GError *error = NULL; int stride, i; unsigned char *pixels, *p, *end, *dest_data; int dest_stride; uint32_t *d; pixbuf = gdk_pixbuf_new_from_file_at_scale(filename, rect->width, rect->height, FALSE, &error); if (error != NULL) return NULL; if (!gdk_pixbuf_get_has_alpha(pixbuf) || gdk_pixbuf_get_n_channels(pixbuf) != 4) { gdk_pixbuf_unref(pixbuf); return NULL; } stride = gdk_pixbuf_get_rowstride(pixbuf); pixels = gdk_pixbuf_get_pixels(pixbuf); surface = display_create_shm_surface(display, rect); dest_data = cairo_image_surface_get_data (surface); dest_stride = cairo_image_surface_get_stride (surface); for (i = 0; i < rect->height; i++) { d = (uint32_t *) (dest_data + i * dest_stride); p = pixels + i * stride; end = p + rect->width * 4; while (p < end) { unsigned int t; unsigned char a, r, g, b; a = p[3]; MULT(r, p[0], a, t); MULT(g, p[1], a, t); MULT(b, p[2], a, t); p += 4; *d++ = (a << 24) | (r << 16) | (g << 8) | b; } } gdk_pixbuf_unref(pixbuf); return surface; }
GdkPixbuf * eel_create_spotlight_pixbuf (GdkPixbuf* src) { GdkPixbuf *dest; int i, j; int width, height, has_alpha, src_row_stride, dst_row_stride; guchar *target_pixels, *original_pixels; guchar *pixsrc, *pixdest; g_return_val_if_fail (gdk_pixbuf_get_colorspace (src) == GDK_COLORSPACE_RGB, NULL); g_return_val_if_fail ((!gdk_pixbuf_get_has_alpha (src) && gdk_pixbuf_get_n_channels (src) == 3) || (gdk_pixbuf_get_has_alpha (src) && gdk_pixbuf_get_n_channels (src) == 4), NULL); g_return_val_if_fail (gdk_pixbuf_get_bits_per_sample (src) == 8, NULL); dest = create_new_pixbuf (src); has_alpha = gdk_pixbuf_get_has_alpha (src); width = gdk_pixbuf_get_width (src); height = gdk_pixbuf_get_height (src); dst_row_stride = gdk_pixbuf_get_rowstride (dest); src_row_stride = gdk_pixbuf_get_rowstride (src); target_pixels = gdk_pixbuf_get_pixels (dest); original_pixels = gdk_pixbuf_get_pixels (src); for (i = 0; i < height; i++) { pixdest = target_pixels + i * dst_row_stride; pixsrc = original_pixels + i * src_row_stride; for (j = 0; j < width; j++) { *pixdest++ = lighten_component (*pixsrc++); *pixdest++ = lighten_component (*pixsrc++); *pixdest++ = lighten_component (*pixsrc++); if (has_alpha) { *pixdest++ = *pixsrc++; } } } return dest; }
static void flip_pixbuf (GdkPixbuf *pixbuf, jboolean flip_x, jboolean flip_y, jint width, jint height) { gint src_rs; guchar *src_pix; src_rs = gdk_pixbuf_get_rowstride (pixbuf); src_pix = gdk_pixbuf_get_pixels (pixbuf); if (flip_x) { gint i, channels; guchar buf[4]; channels = gdk_pixbuf_get_has_alpha (pixbuf) ? 4 : 3; for (i = 0; i < height; i++) { guchar *left = src_pix + i * src_rs; guchar *right = left + channels * (width - 1); while (left < right) { g_memmove (buf, left, channels); g_memmove (left, right, channels); g_memmove (right, buf, channels); left += channels; right -= channels; } } } if (flip_y) { guchar *top = src_pix; guchar *bottom = top + (height - 1) * src_rs; gpointer buf = g_malloc (src_rs); while (top < bottom) { g_memmove (buf, top, src_rs); g_memmove (top, bottom, src_rs); g_memmove (bottom, buf, src_rs); top += src_rs; bottom -= src_rs; } g_free (buf); } }
static void opt_show_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { OptShow *show = OPT_SHOW(object); OptShowPrivate *priv; priv = show->priv; switch (prop_id) { case PROP_TITLE_BORDER_SIZE: priv->title_border_size = g_value_get_int (value); break; case PROP_TITLE_BULLET_PAD: priv->title_bullet_pad = g_value_get_int (value); break; case PROP_BULLET_BORDER_SIZE: priv->bullet_border_size = g_value_get_int (value); break; case PROP_BULLET_PAD: priv->bullet_pad = g_value_get_int (value); break; case PROP_TITLE_FONT: if (priv->title_font) g_free (priv->title_font); priv->title_font = g_value_dup_string (value); break; case PROP_BULLET_FONT: if (priv->bullet_font) g_free (priv->bullet_font); priv->bullet_font = g_value_dup_string (value); break; case PROP_BACKGROUND: priv->background = g_value_get_object (value); clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (priv->bg), gdk_pixbuf_get_pixels (priv->background), gdk_pixbuf_get_has_alpha (priv->background), gdk_pixbuf_get_width (priv->background), gdk_pixbuf_get_height (priv->background), gdk_pixbuf_get_rowstride (priv->background), gdk_pixbuf_get_n_channels (priv->background), 0, NULL); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static Image* LoadImage (ArchiveFile& file, const char *extension) { RGBAImage* image = (RGBAImage *) 0; /* load the buffer from pk3 or filesystem */ ScopedArchiveBuffer buffer(file); GdkPixbufLoader *loader = gdk_pixbuf_loader_new_with_type(extension, (GError**) 0); if (loader == (GdkPixbufLoader*)0) { g_warning("could not get a loader for: '%s'\n", extension); return image; } GError *error = (GError *) 0; if (gdk_pixbuf_loader_write(loader, (const guchar *) buffer.buffer, static_cast<gsize> (buffer.length), &error)) { int pos = 0; GdkPixbuf *pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); const int width = gdk_pixbuf_get_width(pixbuf); const int height = gdk_pixbuf_get_height(pixbuf); const gboolean hasAlpha = gdk_pixbuf_get_has_alpha(pixbuf); const int stepWidth = gdk_pixbuf_get_n_channels(pixbuf); const guchar *pixels = gdk_pixbuf_get_pixels(pixbuf); image = new RGBAImage(width, height, false); byte *rgba = image->getRGBAPixels(); const int rowextra = gdk_pixbuf_get_rowstride(pixbuf) - width * stepWidth; for (int y = 0; y < height; ++y, pixels += rowextra) { for (int x = 0; x < width; ++x) { rgba[pos++] = *(pixels++); rgba[pos++] = *(pixels++); rgba[pos++] = *(pixels++); if (hasAlpha && *pixels != 255) image->setHasAlpha(true); rgba[pos++] = hasAlpha ? *(pixels++) : 255; } } g_object_unref(pixbuf); } else { g_warning("image could not get loaded: '%s' %s\n", file.getName().c_str(), (error != (GError *) 0) ? error->message : ""); if (error) g_error_free(error); } gdk_pixbuf_loader_close(loader, (GError**) 0); return image; }