cairo_surface_t *
_cairo_image_surface_scale (cairo_surface_t *image,
int scaled_width,
int scaled_height,
scale_filter_t filter,
GthAsyncTask *task)
{
int src_width;
int src_height;
cairo_surface_t *scaled;
cairo_surface_metadata_t *metadata;
resize_filter_t *resize_filter;
ScaleReal x_factor;
ScaleReal y_factor;
cairo_surface_t *tmp;
src_width = cairo_image_surface_get_width (image);
src_height = cairo_image_surface_get_height (image);
if ((src_width == scaled_width) && (src_height == scaled_height))
return _cairo_image_surface_copy (image);
scaled = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
scaled_width,
scaled_height);
_cairo_image_surface_copy_metadata (image, scaled);
metadata = _cairo_image_surface_get_metadata (scaled);
if (metadata->original_width <= 0) {
metadata->original_width = src_width;
metadata->original_height = src_height;
}
if (scaled == NULL)
return NULL;
if (g_once_init_enter (&coefficients_initialization)) {
initialize_coefficients (1.0, 0.0);
g_once_init_leave (&coefficients_initialization, 1);
}
resize_filter = resize_filter_create (task);
resize_filter_set_type (resize_filter, filter);
resize_filter->total_lines = scaled_width + scaled_height;
resize_filter->processed_lines = 0;
x_factor = (ScaleReal) scaled_width / src_width;
y_factor = (ScaleReal) scaled_height / src_height;
tmp = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
src_height,
scaled_width);
horizontal_scale_transpose (image, tmp, x_factor, resize_filter);
horizontal_scale_transpose (tmp, scaled, y_factor, resize_filter);
resize_filter_destroy (resize_filter);
cairo_surface_destroy (tmp);
return scaled;
}
void
_cairo_image_surface_clear_metadata (cairo_surface_t *surface)
{
cairo_surface_metadata_t *metadata;
metadata = _cairo_image_surface_get_metadata (surface);
_cairo_surface_metadata_init (metadata);
}
void
_cairo_image_surface_copy_metadata (cairo_surface_t *src,
cairo_surface_t *dest)
{
cairo_surface_metadata_t *src_metadata;
cairo_surface_metadata_t *dest_metadata;
src_metadata = _cairo_image_surface_get_metadata (src);
dest_metadata = _cairo_image_surface_get_metadata (dest);
dest_metadata->valid_data = src_metadata->valid_data;
dest_metadata->has_alpha = src_metadata->has_alpha;
dest_metadata->original_width = src_metadata->original_width;
dest_metadata->original_height = src_metadata->original_height;
dest_metadata->thumbnail.image_width = src_metadata->thumbnail.image_width;
dest_metadata->thumbnail.image_height = src_metadata->thumbnail.image_height;
}
gboolean
_cairo_image_surface_get_has_alpha (cairo_surface_t *surface)
{
cairo_surface_metadata_t *metadata;
gboolean has_alpha;
int width;
int height;
int row_stride;
guchar *row;
int h, w;
if (surface == NULL)
return FALSE;
metadata = _cairo_image_surface_get_metadata (surface);
if ((metadata != NULL) && (metadata->valid_data & _CAIRO_METADATA_FLAG_HAS_ALPHA))
return metadata->has_alpha;
has_alpha = FALSE;
if (cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32) {
/* search an alpha value lower than 255 */
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
row_stride = cairo_image_surface_get_stride (surface);
row = _cairo_image_surface_flush_and_get_data (surface);
for (h = 0; ! has_alpha && (h < height); h++) {
guchar *pixel = row;
for (w = 0; w < width; w++) {
if (pixel[CAIRO_ALPHA] < 255) {
has_alpha = TRUE;
break;
}
pixel += 4;
}
row += row_stride;
}
}
_cairo_metadata_set_has_alpha (metadata, has_alpha);
return has_alpha;
}
cairo_surface_t *
_cairo_image_surface_create_from_pixbuf (GdkPixbuf *pixbuf)
{
cairo_surface_t *surface;
cairo_surface_metadata_t *metadata;
int width;
int height;
int p_stride;
int p_n_channels;
guchar *p_pixels;
int s_stride;
unsigned char *s_pixels;
int h, w;
guint32 pixel;
guchar r, g, b, a;
if (pixbuf == NULL)
return NULL;
g_object_get (G_OBJECT (pixbuf),
"width", &width,
"height", &height,
"rowstride", &p_stride,
"n-channels", &p_n_channels,
"pixels", &p_pixels,
NULL );
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
s_stride = cairo_image_surface_get_stride (surface);
s_pixels = _cairo_image_surface_flush_and_get_data (surface);
metadata = _cairo_image_surface_get_metadata (surface);
_cairo_metadata_set_has_alpha (metadata, (p_n_channels == 4));
if (p_n_channels == 4) {
guchar *s_iter;
guchar *p_iter;
for (h = 0; h < height; h++) {
s_iter = s_pixels;
p_iter = p_pixels;
for (w = 0; w < width; w++) {
a = p_iter[3];
if (a == 0xff) {
pixel = CAIRO_RGBA_TO_UINT32 (p_iter[0], p_iter[1], p_iter[2], 0xff);
}
else if (a == 0) {
pixel = 0;
}
else {
r = _cairo_multiply_alpha (p_iter[0], a);
g = _cairo_multiply_alpha (p_iter[1], a);
b = _cairo_multiply_alpha (p_iter[2], a);
pixel = CAIRO_RGBA_TO_UINT32 (r, g, b, a);
}
memcpy (s_iter, &pixel, sizeof (guint32));
s_iter += 4;
p_iter += p_n_channels;
}
s_pixels += s_stride;
p_pixels += p_stride;
}
}
else {
guchar *s_iter;
guchar *p_iter;
for (h = 0; h < height; h++) {
s_iter = s_pixels;
p_iter = p_pixels;
for (w = 0; w < width; w++) {
pixel = CAIRO_RGBA_TO_UINT32 (p_iter[0], p_iter[1], p_iter[2], 0xff);
memcpy (s_iter, &pixel, sizeof (guint32));
s_iter += 4;
p_iter += p_n_channels;
}
s_pixels += s_stride;
p_pixels += p_stride;
}
}
cairo_surface_mark_dirty (surface);
return surface;
}
GthImage *
gth_pixbuf_new_from_file (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gboolean scale_to_original,
GCancellable *cancellable,
GError **error)
{
ScaleData scale_data;
GdkPixbufLoader *pixbuf_loader;
GdkPixbuf *pixbuf;
GthImage *image;
gboolean original_size_rotated = FALSE;
if (original_width != NULL)
*original_width = -1;
if (original_height != NULL)
*original_height = -1;
scale_data.requested_size = requested_size;
scale_data.original_width = -1;
scale_data.original_height = -1;
scale_data.loader_width = -1;
scale_data.loader_height = -1;
pixbuf_loader = gdk_pixbuf_loader_new ();
g_signal_connect (pixbuf_loader,
"size-prepared",
G_CALLBACK (pixbuf_loader_size_prepared_cb),
&scale_data);
pixbuf = load_from_stream (pixbuf_loader, istream, requested_size, cancellable, error);
g_object_unref (pixbuf_loader);
if ((pixbuf != NULL) && scale_to_original) {
GdkPixbuf *tmp;
tmp = _gdk_pixbuf_scale_simple_safe (pixbuf, scale_data.original_width, scale_data.original_height, GDK_INTERP_NEAREST);
g_object_unref (pixbuf);
pixbuf = tmp;
}
if ((original_width != NULL) && (original_height != NULL)) {
if (file_data != NULL) {
char *path;
path = g_file_get_path (file_data->file);
if (path != NULL) {
gdk_pixbuf_get_file_info (path, &scale_data.original_width, &scale_data.original_height);
original_size_rotated = TRUE;
g_free (path);
}
}
}
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
if (rotated != NULL) {
if (! original_size_rotated) {
/* swap width and height */
int tmp = scale_data.original_width;
scale_data.original_width = scale_data.original_height;
scale_data.original_height =tmp;
}
g_object_unref (pixbuf);
pixbuf = rotated;
}
}
image = gth_image_new ();
if (pixbuf != NULL) {
cairo_surface_t *surface;
cairo_surface_metadata_t *metadata;
surface = _cairo_image_surface_create_from_pixbuf (pixbuf);
metadata = _cairo_image_surface_get_metadata (surface);
metadata->original_width = scale_data.original_width;
metadata->original_height = scale_data.original_height;
metadata->has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
gth_image_set_cairo_surface (image, surface);
}
if (original_width != NULL)
*original_width = scale_data.original_width;
if (original_height != NULL)
*original_height = scale_data.original_height;
if (loaded_original != NULL)
*loaded_original = (pixbuf != NULL) && (scale_data.original_width == gdk_pixbuf_get_width (pixbuf)) && (scale_data.original_height == gdk_pixbuf_get_height (pixbuf));
_g_object_unref (pixbuf);
return image;
}
GthImage *
_cairo_image_surface_create_from_webp (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image;
WebPDecoderConfig config;
guchar *buffer;
gssize bytes_read;
int width, height;
cairo_surface_t *surface;
cairo_surface_metadata_t *metadata;
WebPIDecoder *idec;
image = gth_image_new ();
if (! WebPInitDecoderConfig (&config))
return image;
buffer = g_new (guchar, BUFFER_SIZE);
bytes_read = g_input_stream_read (istream,
buffer,
BUFFER_SIZE,
cancellable,
error);
if (WebPGetFeatures (buffer, bytes_read, &config.input) != VP8_STATUS_OK) {
g_free (buffer);
return image;
}
width = config.input.width;
height = config.input.height;
if (original_width != NULL)
*original_width = width;
if (original_height != NULL)
*original_height = height;
#if SCALING_WORKS
if (requested_size > 0)
scale_keeping_ratio (&width, &height, requested_size, requested_size, FALSE);
#endif
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
metadata = _cairo_image_surface_get_metadata (surface);
_cairo_metadata_set_has_alpha (metadata, config.input.has_alpha);
config.options.no_fancy_upsampling = 1;
#if SCALING_WORKS
if (requested_size > 0) {
config.options.use_scaling = 1;
config.options.scaled_width = width;
config.options.scaled_height = height;
}
#endif
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
config.output.colorspace = MODE_BGRA;
#elif G_BYTE_ORDER == G_BIG_ENDIAN
config.output.colorspace = MODE_ARGB;
#endif
config.output.u.RGBA.rgba = (uint8_t *) _cairo_image_surface_flush_and_get_data (surface);
config.output.u.RGBA.stride = cairo_image_surface_get_stride (surface);
config.output.u.RGBA.size = cairo_image_surface_get_stride (surface) * height;
config.output.is_external_memory = 1;
idec = WebPINewDecoder (&config.output);
if (idec == NULL) {
g_free (buffer);
return image;
}
do {
VP8StatusCode status = WebPIAppend (idec, buffer, bytes_read);
if ((status != VP8_STATUS_OK) && (status != VP8_STATUS_SUSPENDED))
break;
}
while ((bytes_read = g_input_stream_read (istream,
buffer,
BUFFER_SIZE,
cancellable,
error)) > 0);
cairo_surface_mark_dirty (surface);
if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
gth_image_set_cairo_surface (image, surface);
WebPIDelete (idec);
WebPFreeDecBuffer (&config.output);
g_free (buffer);
return image;
}
GthImage *
_cairo_image_surface_create_from_tiff (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width_p,
int *original_height_p,
gboolean *loaded_original_p,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image;
Handle handle;
TIFF *tif;
gboolean first_directory;
int best_directory;
int max_width, max_height, min_diff;
uint32 image_width;
uint32 image_height;
uint32 spp;
uint16 extrasamples;
uint16 *sampleinfo;
uint16 orientation;
char emsg[1024];
cairo_surface_t *surface;
cairo_surface_metadata_t*metadata;
uint32 *raster;
image = gth_image_new ();
handle.cancellable = cancellable;
handle.size = 0;
if ((file_data != NULL) && (file_data->info != NULL)) {
handle.istream = g_buffered_input_stream_new (istream);
handle.size = g_file_info_get_size (file_data->info);
}
else {
void *data;
gsize size;
/* read the whole stream to get the file size */
if (! _g_input_stream_read_all (istream, &data, &size, cancellable, error))
return image;
handle.istream = g_memory_input_stream_new_from_data (data, size, g_free);
handle.size = size;
}
TIFFSetErrorHandler (tiff_error_handler);
TIFFSetWarningHandler (tiff_error_handler);
tif = TIFFClientOpen ("gth-tiff-reader", "r",
&handle,
tiff_read,
tiff_write,
tiff_seek,
tiff_close,
tiff_size,
NULL,
NULL);
if (tif == NULL) {
g_object_unref (handle.istream);
g_set_error_literal (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Couldn't allocate memory for writing TIFF file");
return image;
}
/* find the best image to load */
first_directory = TRUE;
best_directory = -1;
max_width = -1;
max_height = -1;
min_diff = 0;
do {
int width;
int height;
if (TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &width) != 1)
continue;
if (TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &height) != 1)
continue;
if (! TIFFRGBAImageOK (tif, emsg))
continue;
if (width > max_width) {
max_width = width;
max_height = height;
if (requested_size <= 0)
best_directory = TIFFCurrentDirectory (tif);
}
if (requested_size > 0) {
int diff = abs (requested_size - width);
if (first_directory) {
min_diff = diff;
best_directory = TIFFCurrentDirectory (tif);
}
else if (diff < min_diff) {
min_diff = diff;
best_directory = TIFFCurrentDirectory (tif);
}
}
first_directory = FALSE;
}
while (TIFFReadDirectory (tif));
if (best_directory == -1) {
TIFFClose (tif);
g_object_unref (handle.istream);
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Invalid TIFF format");
return image;
}
/* read the image */
TIFFSetDirectory (tif, best_directory);
TIFFGetField (tif, TIFFTAG_IMAGEWIDTH, &image_width);
TIFFGetField (tif, TIFFTAG_IMAGELENGTH, &image_height);
TIFFGetField (tif, TIFFTAG_SAMPLESPERPIXEL, &spp);
TIFFGetFieldDefaulted (tif, TIFFTAG_EXTRASAMPLES, &extrasamples, &sampleinfo);
if (TIFFGetFieldDefaulted (tif, TIFFTAG_ORIENTATION, &orientation) != 1)
orientation = ORIENTATION_TOPLEFT;
if (original_width_p)
*original_width_p = max_width;
if (original_height_p)
*original_height_p = max_height;
if (loaded_original_p)
*loaded_original_p = (max_width == image_width);
surface = _cairo_image_surface_create (CAIRO_FORMAT_ARGB32, image_width, image_height);
if (surface == NULL) {
TIFFClose (tif);
g_object_unref (handle.istream);
g_set_error_literal (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Couldn't allocate memory for writing TIFF file");
return image;
}
metadata = _cairo_image_surface_get_metadata (surface);
_cairo_metadata_set_has_alpha (metadata, (extrasamples == 1) || (spp == 4));
_cairo_metadata_set_original_size (metadata, max_width, max_height);
raster = (uint32*) _TIFFmalloc (image_width * image_height * sizeof (uint32));
if (raster == NULL) {
cairo_surface_destroy (surface);
TIFFClose (tif);
g_object_unref (handle.istream);
g_set_error_literal (error,
GDK_PIXBUF_ERROR,
GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,
"Couldn't allocate memory for writing TIFF file");
return image;
}
if (TIFFReadRGBAImageOriented (tif, image_width, image_height, raster, orientation, 0)) {
guchar *surface_row;
int line_step;
int x, y, temp;
guchar r, g, b, a;
uint32 *src_pixel;
surface_row = _cairo_image_surface_flush_and_get_data (surface);
line_step = cairo_image_surface_get_stride (surface);
src_pixel = raster;
for (y = 0; y < image_height; y++) {
guchar *dest_pixel = surface_row;
if (g_cancellable_is_cancelled (cancellable))
goto stop_loading;
for (x = 0; x < image_width; x++) {
r = TIFFGetR (*src_pixel);
g = TIFFGetG (*src_pixel);
b = TIFFGetB (*src_pixel);
a = TIFFGetA (*src_pixel);
CAIRO_SET_RGBA (dest_pixel, r, g, b, a);
dest_pixel += 4;
src_pixel += 1;
}
surface_row += line_step;
}
}
stop_loading:
cairo_surface_mark_dirty (surface);
if (! g_cancellable_is_cancelled (cancellable))
gth_image_set_cairo_surface (image, surface);
_TIFFfree (raster);
cairo_surface_destroy (surface);
TIFFClose (tif);
g_object_unref (handle.istream);
return image;
}
