From aeefd1959aad3b80a0fe02083edbd5ebfb09510b Mon Sep 17 00:00:00 2001 From: Tomas Bzatek Date: Sun, 18 Sep 2016 19:34:56 +0200 Subject: Introduce resizing thresholds This commit brings deeper changes to the image sizes concept. The goal was to allow more flexible input in resizing vs. supplied files mixed mode. Instead of hard flags the decision whether to resize or copy an image is now based on threshold. While not 100% universal, it brings more control regarding image size bounds. Also brings a level of tolerance for specific errors (off-by-one exports). Image sizes' rules are a bit simpler, hopefully easier to understand. A lot can be achieved by combination of thresholds. --- src/generators.c | 322 ++++++++++++++++++++++++++---------------- src/items.c | 19 +++ src/items.h | 5 + src/jpeg-utils.cpp | 8 +- src/jpeg-utils.h | 1 + src/setup.c | 17 ++- src/setup.h | 8 +- templates/classic/default.xml | 99 ++++++------- templates/fluid/fluid.xml | 6 +- 9 files changed, 301 insertions(+), 184 deletions(-) diff --git a/src/generators.c b/src/generators.c index 1ecb3c6..b9df04c 100644 --- a/src/generators.c +++ b/src/generators.c @@ -186,80 +186,107 @@ get_item_titles (TGallerySetup *setup, *title_desc = g_strstrip (*title_desc); } -static void -get_image_paths (TGallerySetup *setup, - TAlbum *items, - TIndexItem *item, - TPathInfo *path_info, - TImageSize *image_size, - gchar **full_img_src, - gchar **full_img_dst, - gchar **page_img_dst) +static gchar * +get_image_source_path (TGallerySetup *setup, + TAlbum *items, + TIndexItem *item, + TPathInfo *path_info, + TImageSize *image_size) { - gchar *s1, *s2, *s3; - gchar *target_image_dir; - - if (full_img_src) - *full_img_src = NULL; - if (full_img_dst) - *full_img_dst = NULL; - if (page_img_dst) - *page_img_dst = NULL; - - if (full_img_src == NULL && image_size == NULL) - return; + const gchar *s; - s1 = NULL; + s = NULL; /* image_size == NULL means return real image source path */ if (image_size) { /* ignore combinations that are not valid */ if ((items->type == GALLERY_TYPE_INDEX && ! image_size->is_thumbnail) || (image_size->is_thumbnail && item->hidden) || (image_size->is_thumbnail && items->type == GALLERY_TYPE_INDEX && (item->thumbnail == NULL || strlen (item->thumbnail) == 0))) - return; + return NULL; if (image_size->is_thumbnail && items->type == GALLERY_TYPE_INDEX) - s1 = item->thumbnail; + s = item->thumbnail; - if (s1 == NULL && item->image_sizes != NULL) - s1 = g_hash_table_lookup (item->image_sizes, image_size->name); - - /* go through the fallback */ - while (s1 == NULL && image_size->fallback_size != NULL) { - image_size = lookup_image_size_for_name (setup, image_size->fallback_size); - s1 = item->image_sizes ? g_hash_table_lookup (item->image_sizes, image_size->name) : NULL; - } + if (s == NULL && item->image_sizes != NULL) + s = g_hash_table_lookup (item->image_sizes, image_size->name); } - /* we have reached our target image size, s1 == NULL means the image should be resized from the source image */ - if (s1 == NULL) - s1 = item->path; + /* we have reached our target image size, s == NULL means the image should be resized from the source image */ + if (s == NULL) + s = item->path; - if (s1 == NULL) { + if (s == NULL) { log_error ("Unable to find image source for item #%d (\"%s\") for image size \"%s\"\n", get_item_index (items, item), item->title, image_size->name); - return; + return NULL; } - if (full_img_src) - *full_img_src = g_build_filename (path_info->src_dir, s1, NULL); + return g_build_filename (path_info->src_dir, s, NULL); +} - if (image_size) { - target_image_dir = g_strdup_printf ("%s%s", TARGET_IMAGE_DIR_PREFIX, image_size->name); - s2 = g_path_get_basename (s1); - if (image_size->is_thumbnail) { - s3 = g_strdup_printf (THUMBNAIL_NAME_FORMAT, get_item_index (items, item), s2); - g_free (s2); - s2 = s3; - } - if (full_img_dst) - *full_img_dst = g_build_filename (path_info->dest_dir, target_image_dir, s2, NULL); - if (page_img_dst) - *page_img_dst = g_build_filename (target_image_dir, s2, NULL); - g_free (s2); - g_free (target_image_dir); +static gchar * +get_image_dest_path (TGallerySetup *setup, + TAlbum *items, + TIndexItem *item, + TPathInfo *path_info, + TImageSize *image_size, + gboolean page_link) +{ + gchar *src; + gchar *dst; + gchar *s, *s2; + gchar *target_image_dir; + + g_assert (image_size != NULL); + + src = get_image_source_path (setup, items, item, path_info, image_size); + + target_image_dir = g_strdup_printf ("%s%s", TARGET_IMAGE_DIR_PREFIX, image_size->name); + s = g_path_get_basename (src); + if (image_size->is_thumbnail) { + s2 = g_strdup_printf (THUMBNAIL_NAME_FORMAT, get_item_index (items, item), s); + g_free (s); + s = s2; } + if (page_link) + dst = g_build_filename (target_image_dir, s, NULL); + else + dst = g_build_filename (path_info->dest_dir, target_image_dir, s, NULL); + + g_free (s); + g_free (target_image_dir); + g_free (src); + + return dst; } +static gchar * +get_image_dest_path_with_fallback (TGallerySetup *setup, + TAlbum *items, + TIndexItem *item, + TPathInfo *path_info, + TImageSize *image_size, + gboolean page_link) +{ + gchar *dst; + TImageSize *tmp_image_size; + + if (image_size->fallback_size == NULL) + return get_image_dest_path (setup, items, item, path_info, image_size, page_link); + + tmp_image_size = image_size; + while ((dst = get_image_dest_path (setup, items, item, path_info, tmp_image_size, FALSE)), + tmp_image_size->fallback_size && g_access (dst, R_OK) != 0) { + g_free (dst); + tmp_image_size = lookup_image_size_for_name (setup, tmp_image_size->fallback_size); + } + + if (page_link) { + g_free (dst); + dst = get_image_dest_path (setup, items, item, path_info, tmp_image_size, page_link); + } + + return dst; +} static void metadata_apply_overrides (ExifData *exif_data, @@ -330,40 +357,61 @@ struct HaveImageSizeData { TGallerySetup *setup; TAlbum *items; TIndexItem *item; + TPathInfo *path_info; }; +static gboolean +have_generated_image (TGallerySetup *setup, + TAlbum *items, + TIndexItem *item, + TPathInfo *path_info, + TImageSize *image_size) +{ + gchar *img_dst; + int res; + + img_dst = get_image_dest_path (setup, items, item, path_info, image_size, FALSE); + if (img_dst == NULL) + return FALSE; + res = g_access (img_dst, R_OK); + g_free (img_dst); + + return (res == 0); +} + static gboolean have_image_size_cb (gchar **args, gpointer user_data) { struct HaveImageSizeData *data = user_data; + TImageSize *image_size; g_return_val_if_fail (g_strv_length (args) != 2, FALSE); /* incl. trailing NULL */ /* no image size of that name available */ - if (! lookup_image_size_for_name (data->setup, *args)) + image_size = lookup_image_size_for_name (data->setup, *args); + if (image_size == NULL) return FALSE; if (data->item->image_sizes && g_hash_table_lookup (data->item->image_sizes, *args)) return TRUE; - /* FIXME: rework this */ -/* if (data->item->path) - return TRUE; */ - - return FALSE; + /* check for generated image */ + return have_generated_image (data->setup, data->items, data->item, data->path_info, image_size); } static gboolean have_album_image_size_cb (gchar **args, gpointer user_data) { struct HaveImageSizeData *data = user_data; + TImageSize *image_size; TIndexItem *iter_item; int i; g_return_val_if_fail (g_strv_length (args) != 2, FALSE); /* incl. trailing NULL */ /* no image size of that name available */ - if (! lookup_image_size_for_name (data->setup, *args)) + image_size = lookup_image_size_for_name (data->setup, *args); + if (image_size == NULL) return FALSE; for (i = 0; i < data->items->items->len; i++) { @@ -374,9 +422,9 @@ have_album_image_size_cb (gchar **args, gpointer user_data) if (iter_item->image_sizes && g_hash_table_lookup (iter_item->image_sizes, *args)) return TRUE; - /* FIXME: rework this */ -/* if (iter_item->path) - return TRUE; */ + /* check for generated image */ + if (have_generated_image (data->setup, data->items, iter_item, data->path_info, image_size)) + return TRUE; } return FALSE; @@ -399,6 +447,7 @@ generate_image (TGallerySetup *setup, unsigned long img_w, img_h; unsigned long src_img_w, src_img_h; unsigned long tmpw, tmph; + int src_img_quality, img_quality; GList *l; TImageSize *image_size; ExifData *exif_data; @@ -408,19 +457,20 @@ generate_image (TGallerySetup *setup, for (l = g_list_first (setup->design->image_sizes); l; l = g_list_next (l)) { image_size = l->data; - /* fallback mode, don't generate any image and use different image size */ - if (image_size->fallback_size != NULL && (item->image_sizes == NULL || g_hash_table_lookup (item->image_sizes, image_size->name) == NULL)) + img_src = get_image_source_path (setup, items, item, path_info, image_size); + if (img_src == NULL) continue; - - get_image_paths (setup, items, item, path_info, image_size, &img_src, &img_dst, NULL); - if (img_src == NULL || img_dst == NULL) - continue; - if (g_access (img_src, R_OK) != 0) { log_error (" Error opening image %s for size \"%s\": %s\n", img_src, image_size->name, g_strerror (errno)); + g_free (img_src); res = TRUE; continue; } + img_dst = get_image_dest_path (setup, items, item, path_info, image_size, FALSE); + if (img_dst == NULL) { + g_free (img_src); + continue; + } exif_data = exif_data_new_empty (); metadata_apply_overrides (exif_data, setup, path_info, items, item, image_size); @@ -428,17 +478,16 @@ generate_image (TGallerySetup *setup, /* Do something when required */ res = res || needs_update (img_src, img_dst); if (! query_update) { - /* Determine whether to perform file copy or resize */ - if (! image_size->is_thumbnail && image_size->no_resize && (! item->image_sizes || (item->image_sizes && g_hash_table_lookup (item->image_sizes, image_size->name)))) { + /* Always copy supplied image size */ + if (! image_size->is_thumbnail && item->image_sizes && g_hash_table_lookup (item->image_sizes, image_size->name)) { if (! copy_file (img_src, img_dst)) log_error (" Error copying image %s to %s\n", img_src, img_dst); } /* Resize image */ else { - get_image_sizes (img_src, &src_img_w, &src_img_h, setup->autorotate); + get_image_sizes (img_src, &src_img_w, &src_img_h, &src_img_quality, setup->autorotate); if (src_img_w > 0 && src_img_h > 0) { - stats_images_inc (); - + img_quality = image_size->quality; if (image_size->is_thumbnail && image_size->thumb_crop_style != CROP_STYLE_NORMAL) { switch (image_size->thumb_crop_style) { case CROP_STYLE_SQUARED: @@ -463,14 +512,41 @@ generate_image (TGallerySetup *setup, tmpw = image_size->portrait_width; tmph = image_size->portrait_height; } - calculate_sizes (tmpw, tmph, &img_w, &img_h); + /* Check for image size suitability */ + if (! image_size->is_thumbnail && src_img_w + image_size->availability_threshold < tmpw && src_img_h + image_size->availability_threshold < tmph) { +/* printf (" Warning: source image %s (%lux%lu) is not large enough for the \"%s\" image size (need %lux%lu)\n", img_src, src_img_w, src_img_h, image_size->name, tmpw, tmph); */ + g_free (img_src); + g_free (img_dst); + continue; + } + /* Calculate dimensions */ + if (src_img_w < tmpw + image_size->no_resize_threshold && src_img_h < tmph + image_size->no_resize_threshold) { +/* printf (" Note: image %s dimensions (%lux%lu) are within bounds (%lux%lu..%lux%lu), passing by...\n", + img_src, src_img_w, src_img_h, tmpw - image_size->availability_threshold, tmph - image_size->availability_threshold, + tmpw + image_size->no_resize_threshold, tmph + image_size->no_resize_threshold); */ + } else { + calculate_sizes (tmpw, tmph, &img_w, &img_h); + if (setup->warn_resize) + printf (" Warning: resizing image %s from %lux%lu to %lux%lu\n", img_src, src_img_w, src_img_h, img_w, img_h); + } + /* Calculate compression quality */ + if (src_img_quality >= image_size->quality + image_size->quality_threshold) { + if (setup->warn_resize) + printf (" Warning: lowering compression quality of %s from %d to %d\n", img_src, src_img_quality, img_quality); + } else { + img_quality = src_img_quality; + } } /* Perform resize and strip */ - if (setup->warn_resize && ! image_size->is_thumbnail) - printf (" Warning: resizing image %s from %lux%lu to %lux%lu\n", img_src, src_img_w, src_img_h, img_w, img_h); - if (! resize_image (img_src, img_dst, img_w, img_h, image_size->quality, image_size->is_thumbnail, setup->autorotate, exif_data)) - log_error (" Error resizing image %s\n", img_src); + stats_images_inc (); + if (src_img_w == img_w && src_img_h == img_h && src_img_quality == img_quality) { + if (! copy_file (img_src, img_dst)) + log_error (" Error copying image %s to %s\n", img_src, img_dst); + } else { + if (! resize_image (img_src, img_dst, img_w, img_h, img_quality, image_size->is_thumbnail, setup->autorotate, exif_data)) + log_error (" Error resizing image %s\n", img_src); + } } else { log_error ("generate_image: image %s sizes are %lux%lu\n", img_src, src_img_w, src_img_h); } @@ -671,7 +747,6 @@ add_next_prev_links (TGallerySetup *setup, int item_index; int i; gchar *s; - gchar *preload_imgname; item_index = get_item_index (items, item); for (i = item_index - 2; i >= 0; i--) { @@ -705,10 +780,11 @@ add_next_prev_links (TGallerySetup *setup, else replace_table_add_key (replace_table, "LINK_PREV", get_index_filename (items, theme, NULL, NULL)); - if (next_item != NULL && setup->preload && image_size != NULL) { - get_image_paths (setup, items, next_item, path_info, image_size, NULL, NULL, &preload_imgname); - } - replace_table_add_key (replace_table, "IMG_SRC_PRELOAD", preload_imgname ? preload_imgname : ""); + s = NULL; + if (next_item != NULL && setup->preload && image_size != NULL) + s = get_image_dest_path_with_fallback (setup, items, next_item, path_info, image_size, TRUE); + replace_table_add_key (replace_table, "IMG_SRC_PRELOAD", s ? s : ""); + g_free (s); } static ExifData * @@ -719,7 +795,7 @@ get_img_exif_data (TGallerySetup *setup, TImageSize *image_size) { ExifData *exif; - gchar *img_orig_src; + gchar *img_src; gchar *img_dst; gchar *s; @@ -735,31 +811,29 @@ get_img_exif_data (TGallerySetup *setup, /* Get EXIF data from the source image */ if (exif == NULL) { - img_orig_src = NULL; - get_image_paths (setup, items, item, path_info, NULL, &img_orig_src, NULL, NULL); - if (img_orig_src != NULL && g_access (img_orig_src, R_OK) == 0) - exif = read_exif (img_orig_src); + img_src = get_image_source_path (setup, items, item, path_info, NULL); + if (img_src != NULL && g_access (img_src, R_OK) == 0) + exif = read_exif (img_src); /* -- silently succeed if (exif == NULL) log_error ("write_html_image: error getting exif data from file \"%s\"\n", img_orig_src); */ - g_free (img_orig_src); + g_free (img_src); } + /* Try supplied image file */ + if (exif == NULL && item->image_sizes != NULL) { + img_src = get_image_source_path (setup, items, item, path_info, image_size); + if (img_src != NULL && g_access (img_src, R_OK) == 0) + exif = read_exif (img_src); + g_free (img_src); + } /* Try destination image size instead, though it might have the metadata stripped */ if (exif == NULL) { - img_orig_src = img_dst = NULL; - get_image_paths (setup, items, item, path_info, image_size, &img_orig_src, &img_dst, NULL); - if (img_orig_src != NULL && g_access (img_orig_src, R_OK) == 0) - exif = read_exif (img_orig_src); - if (exif == NULL && img_dst != NULL && g_access (img_dst, R_OK) == 0) + img_dst = get_image_dest_path (setup, items, item, path_info, image_size, FALSE); + if (img_dst != NULL && g_access (img_dst, R_OK) == 0) exif = read_exif (img_dst); - /* -- silently succeed - if (exif == NULL) - log_error ("write_html_image: error getting exif data from file \"%s\"\n", img_dst); - */ g_free (img_dst); - g_free (img_orig_src); } if (exif != NULL) @@ -790,10 +864,8 @@ process_img_item (TGallerySetup *setup, gchar *s1, *s2, *s3, *s4; gchar *img_dst; gchar *img_dst_page; - gchar *img_orig_dst; - gchar *img_orig_dst_page; gchar *title, *title_desc; - TImageSize *orig_image_size; + TImageSize *tmp_image_size; ExifData *exif = NULL; struct HaveImageSizeData *img_size_data; @@ -822,12 +894,13 @@ process_img_item (TGallerySetup *setup, g_free (s1); } else { - get_image_paths (setup, items, item, path_info, thumb_image_size, NULL, &s2, &s3); + s2 = get_image_dest_path (setup, items, item, path_info, thumb_image_size, FALSE); + s3 = get_image_dest_path (setup, items, item, path_info, thumb_image_size, TRUE); } img_thumb_w = img_thumb_h = 0; if (s2 != NULL) - get_image_sizes (s2, &img_thumb_w, &img_thumb_h, setup->autorotate); + get_image_sizes (s2, &img_thumb_w, &img_thumb_h, NULL, setup->autorotate); if (img_thumb_w == img_thumb_h) replace_table_add_key (replace_table, "THUMB_ORIENTATION", "squared"); @@ -856,36 +929,35 @@ process_img_item (TGallerySetup *setup, /* Image stuff */ if (image_size != NULL) { /* First calculate image paths */ - img_dst = img_dst_page = NULL; - get_image_paths (setup, items, item, path_info, image_size, NULL, &img_dst, &img_dst_page); + img_dst = get_image_dest_path_with_fallback (setup, items, item, path_info, image_size, FALSE); + img_dst_page = get_image_dest_path_with_fallback (setup, items, item, path_info, image_size, TRUE); /* Retrieve image sizes */ - get_image_sizes (img_dst, &img_w, &img_h, setup->autorotate); + get_image_sizes (img_dst, &img_w, &img_h, NULL, setup->autorotate); + exif = get_img_exif_data (setup, path_info, items, item, image_size); replace_table_add_key_int (replace_table, "IMG_SIZE_W", img_w); replace_table_add_key_int (replace_table, "IMG_SIZE_H", img_h); replace_table_add_key (replace_table, "IMG_SRC", img_dst_page); - exif = get_img_exif_data (setup, path_info, items, item, image_size); + g_free (img_dst); + g_free (img_dst_page); - /* TODO: legacy stuff, subject to removal */ - orig_image_size = NULL; + /* Legacy stuff, subject to removal */ + tmp_image_size = NULL; /* Take the last image size from the sorted list */ if (g_list_length (setup->design->image_sizes) > 0) - orig_image_size = (TImageSize *) g_list_last (setup->design->image_sizes); - if (orig_image_size != NULL) { - img_orig_dst = img_orig_dst_page = NULL; - get_image_paths (setup, items, item, path_info, orig_image_size, NULL, &img_orig_dst, &img_orig_dst_page); - get_image_sizes (img_orig_dst, &img_orig_w, &img_orig_h, setup->autorotate); + tmp_image_size = (TImageSize *) (g_list_last (setup->design->image_sizes))->data; + if (tmp_image_size != NULL && tmp_image_size != image_size) { + img_dst = get_image_dest_path_with_fallback (setup, items, item, path_info, tmp_image_size, FALSE); + img_dst_page = get_image_dest_path_with_fallback (setup, items, item, path_info, tmp_image_size, TRUE); + get_image_sizes (img_dst, &img_orig_w, &img_orig_h, NULL, setup->autorotate); g_hash_table_replace (defines, g_strdup ("HAVE_FULLSIZE"), g_strdup ("")); replace_table_add_key_int (replace_table, "IMG_SIZE_FULLSIZE_W", img_orig_w); replace_table_add_key_int (replace_table, "IMG_SIZE_FULLSIZE_H", img_orig_h); - replace_table_add_key (replace_table, "IMG_SRC_FULLSIZE", img_orig_dst_page); - g_free (img_orig_dst); - g_free (img_orig_dst_page); + replace_table_add_key (replace_table, "IMG_SRC_FULLSIZE", img_dst_page); + g_free (img_dst); + g_free (img_dst_page); } - - g_free (img_dst); - g_free (img_dst_page); } /* Get title and description from IPTC/EXIF/JPEG if not defined */ @@ -928,8 +1000,9 @@ process_img_item (TGallerySetup *setup, /* Single image size callback */ img_size_data = g_new0 (struct HaveImageSizeData, 1); img_size_data->setup = setup; - img_size_data->item = item; img_size_data->items = items; + img_size_data->item = item; + img_size_data->path_info = path_info; block_parser_register_function (block_parser, "have_image_size", have_image_size_cb, img_size_data, g_free); } @@ -1048,6 +1121,7 @@ write_html_page (TGallerySetup *setup, img_size_data = g_new0 (struct HaveImageSizeData, 1); img_size_data->setup = setup; img_size_data->items = items; + img_size_data->path_info = path_info; block_parser_register_function (block_parser, "have_album_image_size", have_album_image_size_cb, img_size_data, g_free); /* Picture page tags */ diff --git a/src/items.c b/src/items.c index d475f91..0ddc3b1 100644 --- a/src/items.c +++ b/src/items.c @@ -550,6 +550,25 @@ get_child_gallery_type (const gchar *filename) return result; } +/* + * dup_path_info: duplicate pathinfo data + */ +TPathInfo * +dup_path_info (TPathInfo *path_info) +{ + TPathInfo *info; + + info = g_malloc0 (sizeof (TPathInfo)); + info->album_path = g_strdup (path_info->album_path); + info->dest_dir = g_strdup (path_info->dest_dir); + info->dest_root = g_strdup (path_info->dest_root); + info->source_root = g_strdup (path_info->source_root); + info->src_dir = g_strdup (path_info->src_dir); + info->templates_root = g_strdup (path_info->templates_root); + + return info; +} + /* * free_path_info: free allocated pathinfo data */ diff --git a/src/items.h b/src/items.h index 2d0df59..24a521f 100644 --- a/src/items.h +++ b/src/items.h @@ -126,6 +126,11 @@ void get_album_titles (const gchar *filename, gchar **title, gchar **description */ TGalleryType get_child_gallery_type (const gchar *filename); +/* + * dup_path_info: duplicate pathinfo data + */ +TPathInfo * dup_path_info (TPathInfo *path_info); + /* * free_path_info: free allocated pathinfo data */ diff --git a/src/jpeg-utils.cpp b/src/jpeg-utils.cpp index ddac2c7..11d2c4e 100644 --- a/src/jpeg-utils.cpp +++ b/src/jpeg-utils.cpp @@ -556,7 +556,8 @@ resize_image (const gchar *src, const gchar *dst, MagickResizeImage (magick_wand, size_x, size_y, LanczosFilter, 1.0); } - MagickSetImageCompressionQuality (magick_wand, quality); + if ((int) MagickGetImageCompressionQuality (magick_wand) != quality) + MagickSetImageCompressionQuality (magick_wand, quality); /* Write the image and destroy it. */ if (MagickWriteImage (magick_wand, dst) == MagickFalse) { @@ -578,6 +579,7 @@ resize_image (const gchar *src, const gchar *dst, void get_image_sizes (const gchar *img, unsigned long *width, unsigned long *height, + int *quality, gboolean autorotate) { MagickWand *magick_wand; @@ -587,6 +589,8 @@ get_image_sizes (const gchar *img, *width = -1; *height = -1; + if (quality) + *quality = -1; g_assert (img != NULL); @@ -610,6 +614,8 @@ get_image_sizes (const gchar *img, *width = MagickGetImageWidth (magick_wand); *height = MagickGetImageHeight (magick_wand); + if (quality) + *quality = (int) MagickGetImageCompressionQuality (magick_wand); magick_wand = DestroyMagickWand (magick_wand); } diff --git a/src/jpeg-utils.h b/src/jpeg-utils.h index 3c56eaf..405d9b0 100644 --- a/src/jpeg-utils.h +++ b/src/jpeg-utils.h @@ -107,6 +107,7 @@ gboolean resize_image (const gchar *src, const gchar *dst, */ void get_image_sizes (const gchar *img, unsigned long *width, unsigned long *height, + int *quality, gboolean autorotate); /* diff --git a/src/setup.c b/src/setup.c index b2cd800..7b59030 100644 --- a/src/setup.c +++ b/src/setup.c @@ -152,7 +152,7 @@ image_sizes_compare_func (TImageSize *a, TImageSize *b) sa = a->landscape_width + a->landscape_height + a->portrait_width + a->portrait_height + a->square_size; sb = b->landscape_width + b->landscape_height + b->portrait_width + b->portrait_height + b->square_size; - return sb - sa; + return sa - sb; } /* @@ -218,10 +218,6 @@ parse_design_setup_xml (const gchar *filename) } g_free (s); - s = g_strdup_printf ("/design_setup/image_sizes/size[%d]/no_resize", i + 1); - image_size->no_resize = xml_file_get_node_present (xml, s); - g_free (s); - s = g_strdup_printf ("/design_setup/image_sizes/size[%d]/landscape", i + 1); image_size->landscape_width = xml_file_get_node_attribute_long_with_default (xml, s, "w", 0); image_size->landscape_height = xml_file_get_node_attribute_long_with_default (xml, s, "h", 0); @@ -248,6 +244,13 @@ parse_design_setup_xml (const gchar *filename) s = g_strdup_printf ("/design_setup/image_sizes/size[%d]/fallback", i + 1); image_size->fallback_size = xml_file_get_node_attribute (xml, s, "size"); g_free (s); + + s = g_strdup_printf ("/design_setup/image_sizes/size[%d]/threshold", i + 1); + image_size->no_resize_threshold = xml_file_get_node_attribute_long_with_default (xml, s, "no_resize", DEFAULT_NO_RESIZE_THRESHOLD); + image_size->availability_threshold = xml_file_get_node_attribute_long_with_default (xml, s, "availability", DEFAULT_AVAILABILITY_THRESHOLD); + image_size->quality_threshold = xml_file_get_node_attribute_long_with_default (xml, s, "quality", DEFAULT_QUALITY_THRESHOLD); + g_free (s); + } design->image_sizes = g_list_sort (design->image_sizes, (GCompareFunc) image_sizes_compare_func); @@ -368,7 +371,9 @@ makeup_legacy_design (const gchar *filename) image_size->portrait_height = xml_file_get_node_attribute_long_with_default (xml, s, "portrait_h", 0); image_size->square_size = xml_file_get_node_attribute_long_with_default (xml, s, "square", 0); image_size->quality = xml_file_get_node_attribute_long_with_default (xml, s, "quality", -1); - image_size->no_resize = (i != 0); + image_size->no_resize_threshold = DEFAULT_NO_RESIZE_THRESHOLD; + image_size->availability_threshold = DEFAULT_AVAILABILITY_THRESHOLD; + image_size->quality_threshold = DEFAULT_QUALITY_THRESHOLD; image_size->is_thumbnail = (i == 0); image_size->thumb_crop_style = ((i == 0) && squared_thumbs) ? CROP_STYLE_SQUARED : CROP_STYLE_NORMAL; g_free (s); diff --git a/src/setup.h b/src/setup.h index faf02f6..54b89b2 100644 --- a/src/setup.h +++ b/src/setup.h @@ -27,6 +27,10 @@ G_BEGIN_DECLS #define THUMBNAIL_NAME_FORMAT "%.3d_%s" #define TARGET_IMAGE_DIR_PREFIX "_" +#define DEFAULT_NO_RESIZE_THRESHOLD 1 +#define DEFAULT_AVAILABILITY_THRESHOLD 1 +#define DEFAULT_QUALITY_THRESHOLD 5 + #define SETUP_XML "setup.xml" #define SETUP_V2_XML "setup2.xml" #define SETUP_NATIVE_VERSION 200 /* 2.0 */ @@ -104,8 +108,10 @@ typedef struct { int crop_width; int crop_height; int quality; - gboolean no_resize; gchar *fallback_size; + int no_resize_threshold; + int availability_threshold; + int quality_threshold; TCropStyle thumb_crop_style; } TImageSize; diff --git a/templates/classic/default.xml b/templates/classic/default.xml index 8cf709e..6db84ee 100644 --- a/templates/classic/default.xml +++ b/templates/classic/default.xml @@ -3,59 +3,69 @@ - + + + - + + + + + + - - + it's independent now and considered more like a bigger image size for + large screens. --> - - - - + + + + + + - - - - - - - - - - + - - - - - - - diff --git a/templates/fluid/fluid.xml b/templates/fluid/fluid.xml index b4e528b..49e8547 100644 --- a/templates/fluid/fluid.xml +++ b/templates/fluid/fluid.xml @@ -6,15 +6,15 @@ - + - + @@ -26,8 +26,8 @@ - + -- cgit v1.2.3