static gboolean
gth_image_svg_set_zoom (GthImage *base,
double zoom,
int *original_width,
int *original_height)
{
GthImageSvg *self;
cairo_surface_t *surface;
cairo_t *cr;
gboolean changed = FALSE;
self = GTH_IMAGE_SVG (base);
if (self->rsvg == NULL)
return FALSE;
if (zoom != self->last_zoom) {
self->last_zoom = zoom;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
zoom * self->original_width,
zoom * self->original_height);
cr = cairo_create (surface);
cairo_scale (cr, zoom, zoom);
rsvg_handle_render_cairo (self->rsvg, cr);
gth_image_set_cairo_surface (base, surface);
changed = TRUE;
cairo_destroy (cr);
cairo_surface_destroy (surface);
}
if (original_width != NULL)
*original_width = self->original_width;
if (original_height != NULL)
*original_height = self->original_height;
return changed;
}
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;
}
static GthImage *
_cairo_image_surface_create_from_raw (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
libraw_data_t *raw_data;
int result;
void *buffer = NULL;
size_t size;
GthImage *image = NULL;
raw_data = libraw_init (LIBRAW_OPIONS_NO_MEMERR_CALLBACK | LIBRAW_OPIONS_NO_DATAERR_CALLBACK);
if (raw_data == NULL) {
_libraw_set_gerror (error, errno);
goto fatal_error;
}
libraw_set_progress_handler (raw_data, _libraw_progress_cb, cancellable);
if (! _g_input_stream_read_all (istream, &buffer, &size, cancellable, error))
goto fatal_error;
raw_data->params.output_tiff = FALSE;
raw_data->params.use_camera_wb = TRUE;
raw_data->params.use_rawspeed = TRUE;
raw_data->params.highlight = FALSE;
raw_data->params.use_camera_matrix = TRUE;
raw_data->params.output_color = RAW_OUTPUT_COLOR_SRGB;
raw_data->params.output_bps = 8;
raw_data->params.half_size = (requested_size > 0);
result = libraw_open_buffer (raw_data, buffer, size);
if (LIBRAW_FATAL_ERROR (result)) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
/* */
#if RAW_USE_EMBEDDED_THUMBNAIL
if (requested_size > 0) {
/* read the thumbnail */
result = libraw_unpack_thumb (raw_data);
if (result != LIBRAW_SUCCESS) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
switch (raw_data->thumbnail.tformat) {
case LIBRAW_THUMBNAIL_JPEG:
image = _libraw_read_jpeg_data (raw_data->thumbnail.thumb,
raw_data->thumbnail.tlength,
requested_size,
cancellable,
error);
break;
case LIBRAW_THUMBNAIL_BITMAP:
image = _libraw_read_bitmap_data (raw_data->thumbnail.twidth,
raw_data->thumbnail.theight,
raw_data->thumbnail.tcolors,
8,
(guchar *) raw_data->thumbnail.thumb,
raw_data->thumbnail.tlength);
break;
default:
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Unsupported data format");
break;
}
if ((image != NULL) && (_libraw_get_tranform (raw_data) != GTH_TRANSFORM_NONE)) {
cairo_surface_t *surface;
cairo_surface_t *rotated;
surface = gth_image_get_cairo_surface (image);
rotated = _cairo_image_surface_transform (surface, _libraw_get_tranform (raw_data));
gth_image_set_cairo_surface (image, rotated);
cairo_surface_destroy (rotated);
cairo_surface_destroy (surface);
}
}
else
#endif
{
/* read the image */
libraw_processed_image_t *processed_image;
result = libraw_unpack (raw_data);
if (result != LIBRAW_SUCCESS) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
result = libraw_dcraw_process (raw_data);
if (result != LIBRAW_SUCCESS) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
processed_image = libraw_dcraw_make_mem_image (raw_data, &result);
if (result != LIBRAW_SUCCESS) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
switch (processed_image->type) {
case LIBRAW_IMAGE_JPEG:
image = _libraw_read_jpeg_data (processed_image->data,
processed_image->data_size,
-1,
cancellable,
error);
break;
case LIBRAW_IMAGE_BITMAP:
image = _libraw_read_bitmap_data (processed_image->width,
processed_image->height,
processed_image->colors,
processed_image->bits,
processed_image->data,
processed_image->data_size);
break;
default:
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Unsupported data format");
break;
}
libraw_dcraw_clear_mem (processed_image);
}
/* get the original size */
if ((original_width != NULL) && (original_height != NULL)) {
result = libraw_adjust_sizes_info_only (raw_data);
if (result != LIBRAW_SUCCESS) {
_libraw_set_gerror (error, result);
goto fatal_error;
}
*original_width = raw_data->sizes.iwidth;
*original_height = raw_data->sizes.iheight;
}
fatal_error:
if (raw_data != NULL)
libraw_close (raw_data);
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;
}
gboolean
_g_buffer_resize_image (void *buffer,
gsize count,
GthFileData *file_data,
int max_width,
int max_height,
void **resized_buffer,
gsize *resized_count,
GCancellable *cancellable,
GError **error)
{
GInputStream *istream;
const char *mime_type;
GthImageLoaderFunc loader_func;
GthImage *image;
int width;
int height;
cairo_surface_t *surface;
cairo_surface_t *scaled;
gboolean result;
if ((max_width == -1) || (max_height == -1)) {
*error = NULL;
return FALSE;
}
istream = g_memory_input_stream_new_from_data (buffer, count, NULL);
mime_type = _g_content_type_get_from_stream (istream, (file_data != NULL ? file_data->file : NULL), cancellable, NULL);
if (mime_type == NULL) {
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s", _("No suitable loader available for this file type"));
return FALSE;
}
loader_func = gth_main_get_image_loader_func (mime_type, GTH_IMAGE_FORMAT_CAIRO_SURFACE);
if (loader_func == NULL) {
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "%s", _("No suitable loader available for this file type"));
g_object_unref (istream);
return FALSE;
}
image = loader_func (istream,
NULL,
-1,
&width,
&height,
NULL,
cancellable,
error);
if (image == NULL) {
g_object_unref (istream);
return FALSE;
}
if (! scale_keeping_ratio (&width, &height, max_width, max_height, FALSE)) {
error = NULL;
g_object_unref (image);
g_object_unref (istream);
return FALSE;
}
surface = gth_image_get_cairo_surface (image);
scaled = _cairo_image_surface_scale (surface, width, height, SCALE_FILTER_BEST, NULL);
gth_image_set_cairo_surface (image, scaled);
result = gth_image_save_to_buffer (image,
mime_type,
file_data,
(char **) resized_buffer,
resized_count,
cancellable,
error);
cairo_surface_destroy (scaled);
cairo_surface_destroy (surface);
g_object_unref (image);
g_object_unref (istream);
return result;
}
