498 lines
16 KiB
C
498 lines
16 KiB
C
#include <Elementary.h>
|
|
#include "config.h"
|
|
|
|
// a set of commonly found resolution buckets to try size the image down
|
|
// to to match width OR height so we can avoid decoding a larger image from
|
|
// disk making startup time faster by picking the right res that's encoded
|
|
// already in the file... the more resolutions we encode the bigger
|
|
// the file so it's a tradeoff, thus commenting out a lot of the resolutions
|
|
// because they are so close or can just miildly crop another res...
|
|
// only encode resolutiosn less than the original image a well as throw in
|
|
// the original as the highest res option
|
|
// pick onne of each y resolution and scale accordingly so e.g. Nx480, Nx600,
|
|
// Nx720, Nx788, Nx800, Nx900, ...
|
|
static const int resolutions[] =
|
|
{
|
|
// not bothering below 640x480
|
|
// 640, 480,
|
|
// 800, 480,
|
|
854, 480,
|
|
// 768, 576,
|
|
// 1024, 576,
|
|
// 800, 600,
|
|
1024, 600,
|
|
1280, 720,
|
|
// 1024, 768,
|
|
// 1152, 768
|
|
// 1280, 768
|
|
1366, 768,
|
|
1280, 800,
|
|
// 1280, 854,
|
|
// 1152, 864,
|
|
// 1152, 900,
|
|
// 1440, 900,
|
|
1600, 900,
|
|
// 1280, 960,
|
|
1440, 960,
|
|
// 1280, 1024,
|
|
// 1400, 1050,
|
|
// 1680, 1050,
|
|
// 1440, 1080,
|
|
// 1920, 1080,
|
|
// 2048, 1080,
|
|
// 2880, 1080,
|
|
3840, 1080,
|
|
// 1600, 1200,
|
|
1920, 1200,
|
|
// 1920, 1280,
|
|
2560, 1440,
|
|
// 3840, 1440,
|
|
// 5120, 1440,
|
|
// 2048, 1536,
|
|
2560, 1600,
|
|
// 2880, 1620,
|
|
// 2880, 1800,
|
|
3200, 1800,
|
|
// 2560, 2048,
|
|
// 3840, 2160,
|
|
4096, 2160,
|
|
// 5120, 2160,
|
|
5120, 2880,
|
|
6016, 3384,
|
|
// 7680, 4320,
|
|
8192, 4320,
|
|
|
|
// one day... we may have to add more resolutions here. when that day comes...
|
|
// we'll do that. until then... I think 8k is "good enough"
|
|
0, 0 // sentinel
|
|
};
|
|
// when we have more res's above bump this to be that + 1 at a minimum
|
|
#define MAX_RES_NUM 20
|
|
|
|
#define ETC1 -1
|
|
#define ETC2 -2
|
|
|
|
static Evas_Object *win = NULL, *subwin = NULL, *image = NULL, *rend = NULL;
|
|
|
|
typedef struct
|
|
{
|
|
int from_w, from_h, to_w, to_h;
|
|
Eina_Bool last : 1;
|
|
} Mip;
|
|
|
|
static Mip *
|
|
_resolutions_calc(int w, int h)
|
|
{
|
|
int i, j = 0;
|
|
int nw, nh, pw = 0, ph = 0;
|
|
Mip *mips = calloc(1, sizeof(Mip) * MAX_RES_NUM);
|
|
|
|
if (!mips) return NULL;
|
|
for (i = 0; resolutions[i]; i += 2)
|
|
{
|
|
nh = resolutions[i + 1];
|
|
nw = (w * nh) / h;
|
|
if ((nh >= h) || (nw >= w))
|
|
{
|
|
mips[j].from_w = pw;
|
|
mips[j].from_h = ph;
|
|
mips[j].to_w = 1000000000;
|
|
mips[j].to_h = 1000000000;
|
|
mips[j].last = EINA_TRUE;
|
|
break;
|
|
}
|
|
|
|
mips[j].from_w = pw;
|
|
mips[j].from_h = ph;
|
|
mips[j].to_w = nw;
|
|
mips[j].to_h = nh;
|
|
|
|
j++;
|
|
pw = nw + 1;
|
|
ph = nh + 1;
|
|
}
|
|
return mips;
|
|
}
|
|
|
|
EAPI int
|
|
elm_main(int argc, char **argv)
|
|
{
|
|
const char *edje_cc, *mode, *file, *outfile;
|
|
int bg_r = 64;
|
|
int bg_g = 64;
|
|
int bg_b = 64;
|
|
char dir_buf[128], img_buf[256], edc_buf[256], cmd_buf[1024], qual_buf[64];
|
|
const char *dir, *quality_string = NULL, *img_name = NULL;
|
|
Mip *mips = NULL;
|
|
int i, imw, imh, w, h, quality;
|
|
int ret = 0, mips_num = 0;
|
|
Eina_Bool alpha;
|
|
FILE *f;
|
|
|
|
if (argc <= 1)
|
|
{
|
|
printf("USAGE: enlightenment_wallpaper_gen EDJE FILL INPUT OUT QUALITY [R G B]\n"
|
|
"\n"
|
|
" EDJE is edje_cc command to use (full path or in $PATH)\n"
|
|
" FILL is one of:\n"
|
|
" stretch\n"
|
|
" tile\n"
|
|
" center (requires R G B)\n"
|
|
" scale_in (requires R G B)\n"
|
|
" scale_out\n"
|
|
" pan\n"
|
|
" INPUT is some image file to put into the wallpaper edj\n"
|
|
" OUT is the paht/location of the wallpaper edj output\n"
|
|
" QUALITY is:\n"
|
|
" 0-100 (0-99 is lossy, 100 is lossless compression)\n"
|
|
" etc1\n"
|
|
" etc2\n"
|
|
" R, G, B are Red, Green and Blue values 0 to 255\n"
|
|
"\n"
|
|
" e.g.\n"
|
|
" enlightenment_wallpaper_gen edje_cc scale_out cat.jpg wallpaper.edj 80\n"
|
|
" enlightenment_wallpaper_gen edje_cc center mylogo.png wallpaper.edj 100 48 64 64\n"
|
|
" enlightenment_wallpaper_gen /usr/local/bin/edje_cc tile pattern.jpg wallpaper.edj 98\n"
|
|
" enlightenment_wallpaper_gen /opt/e/bin/edje_cc scale_out hugeimg.jpg wallpaper.edj etc1\n"
|
|
);
|
|
return 1;
|
|
}
|
|
|
|
elm_config_preferred_engine_set("buffer");
|
|
win = elm_win_add(NULL, "Wallpaper-Gen", ELM_WIN_BASIC);
|
|
elm_win_norender_push(win);
|
|
evas_object_show(win);
|
|
|
|
subwin = elm_win_add(win, "inlined", ELM_WIN_INLINED_IMAGE);
|
|
rend = elm_win_inlined_image_object_get(subwin);
|
|
elm_win_norender_push(subwin);
|
|
evas_object_show(subwin);
|
|
|
|
if (argc < 6) return 2;
|
|
edje_cc = argv[1];
|
|
mode = argv[2];
|
|
file = argv[3];
|
|
outfile = argv[4];
|
|
if (!strcmp(argv[5], "etc1")) quality = ETC1;
|
|
else if (!strcmp(argv[5], "etc2")) quality = ETC2;
|
|
else
|
|
{
|
|
quality = atoi(argv[5]);
|
|
if (quality < 0) quality = 0;
|
|
else if (quality > 100) quality = 100;
|
|
}
|
|
|
|
image = evas_object_image_filled_add(evas_object_evas_get(subwin));
|
|
evas_object_image_file_set(image, file, NULL);
|
|
evas_object_image_size_get(image, &w, &h);
|
|
if ((w <= 0) || (h <= 0)) return 3;
|
|
alpha = evas_object_image_alpha_get(image);
|
|
elm_win_alpha_set(subwin, alpha);
|
|
evas_object_show(image);
|
|
|
|
snprintf(dir_buf, sizeof(dir_buf), "/tmp/e_bg-XXXXXX");
|
|
dir = mkdtemp(dir_buf);
|
|
if (!dir) return 4;
|
|
|
|
if ((!strcmp(mode, "center")) ||
|
|
(!strcmp(mode, "scale_in")))
|
|
{ // need backing rgb color here
|
|
if (argc < 9) return 5;
|
|
bg_r = atoi(argv[6]);
|
|
bg_g = atoi(argv[7]);
|
|
bg_b = atoi(argv[8]);
|
|
}
|
|
if ((!strcmp(mode, "stretch")) ||
|
|
(!strcmp(mode, "scale_in")) ||
|
|
(!strcmp(mode, "scale_out")) ||
|
|
(!strcmp(mode, "pan")))
|
|
{ // need to produce multiple scaled versions
|
|
mips = _resolutions_calc(w, h);
|
|
if (!mips) return 6;
|
|
for (i = 0; mips[i].to_w; i++)
|
|
{
|
|
mips_num++;
|
|
if (mips[i].last)
|
|
{
|
|
imw = w;
|
|
imh = h;
|
|
}
|
|
else
|
|
{
|
|
imw = mips[i].to_w;
|
|
imh = mips[i].to_h;
|
|
}
|
|
evas_object_resize(subwin, imw, imh);
|
|
evas_object_resize(image, imw, imh);
|
|
elm_win_render(subwin);
|
|
if (mips[i].last)
|
|
snprintf(img_buf, sizeof(img_buf), "%s/img.png",
|
|
dir);
|
|
else
|
|
snprintf(img_buf, sizeof(img_buf), "%s/img-%ix%i.png",
|
|
dir, imw, imh);
|
|
if (!evas_object_image_save(rend, img_buf, NULL, "compress=0"))
|
|
{
|
|
ret = 7;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
}
|
|
// no multiple resolutions -0 save out original
|
|
if (!mips)
|
|
{
|
|
evas_object_resize(subwin, w, h);
|
|
evas_object_resize(image, w, h);
|
|
elm_win_render(subwin);
|
|
snprintf(img_buf, sizeof(img_buf), "%s/img.png", dir);
|
|
if (!evas_object_image_save(rend, img_buf, NULL, "compress=0"))
|
|
{
|
|
ret = 8;
|
|
goto cleanup;
|
|
}
|
|
}
|
|
if ((quality == ETC1) && (alpha)) quality = ETC2; // etc1 -> etc2 if alpha
|
|
if (quality == 100) quality_string = "COMP";
|
|
else
|
|
{
|
|
if (quality == ETC1) quality_string = "LOSSY_ETC1";
|
|
else if (quality == ETC2) quality_string = "LOSSY_ETC2";
|
|
else
|
|
{
|
|
snprintf(qual_buf, sizeof(qual_buf), "LOSSY %i", quality);
|
|
quality_string = qual_buf;
|
|
}
|
|
}
|
|
// generate edc
|
|
snprintf(edc_buf, sizeof(edc_buf), "%s/bg.edc", dir);
|
|
f = fopen(edc_buf, "w");
|
|
if (!f) goto cleanup;
|
|
if ((mips) && (mips_num > 1))
|
|
{
|
|
fprintf(f,
|
|
"images {\n"
|
|
" set { name: \"img\";\n");
|
|
for (i = mips_num - 1; i >= 0; i--)
|
|
{
|
|
fprintf(f,
|
|
" image {\n");
|
|
if (mips[i].last)
|
|
{
|
|
fprintf(f,
|
|
" image: \"img.png\" %s;\n",
|
|
quality_string);
|
|
}
|
|
else
|
|
{
|
|
imw = mips[i].to_w;
|
|
imh = mips[i].to_h;
|
|
fprintf(f,
|
|
" image: \"img-%ix%i.png\" %s;\n",
|
|
imw, imh, quality_string);
|
|
}
|
|
fprintf(f,
|
|
" size: %i %i %i %i;\n"
|
|
" }\n",
|
|
mips[i].from_w, mips[i].from_h,
|
|
mips[i].to_w, mips[i].to_h);
|
|
}
|
|
fprintf(f,
|
|
" }\n"
|
|
"}\n");
|
|
img_name = "img";
|
|
}
|
|
else
|
|
{
|
|
fprintf(f, "images.image: \"img.png\" %s;\n", quality_string);
|
|
img_name = "img.png";
|
|
}
|
|
fprintf(f,
|
|
"collections {\n"
|
|
" group { name: \"e/desktop/background\";\n"
|
|
" data.item: \"noanimation\" \"1\";\n");
|
|
if (!strcmp(mode, "stretch"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"0\"; }\n");
|
|
fprintf(f,
|
|
" parts {\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" scale_hint: STATIC;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, img_name);
|
|
}
|
|
else if (!strcmp(mode, "tile"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"1\"; }\n");
|
|
fprintf(f,
|
|
" parts {\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" }\n"
|
|
" fill.size.relative: 0 0;\n"
|
|
" fill.size.offset: %i %i;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, img_name, w, h);
|
|
}
|
|
else if (!strcmp(mode, "center"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"2\"; }\n");
|
|
fprintf(f,
|
|
" parts {\n"
|
|
" part { name: \"col\"; type: RECT; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" color: %i %i %i 255;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" }\n"
|
|
" min: %i %i; max: %i %i;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, bg_r, bg_g, bg_b, img_name, w, h, w, h);
|
|
}
|
|
else if (!strcmp(mode, "scale_in"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"3\"; }\n");
|
|
fprintf(f,
|
|
" parts {\n"
|
|
" part { name: \"col\"; type: RECT; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" color: %i %i %i 255;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" scale_hint: STATIC;\n"
|
|
" }\n"
|
|
" aspect: (%i/%i) (%i/%i); aspect_preference: BOTH;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, bg_r, bg_g, bg_b, img_name, w, h, w, h);
|
|
}
|
|
else if (!strcmp(mode, "scale_out"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"4\"; }\n");
|
|
fprintf(f,
|
|
" parts {\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" scale_hint: STATIC;\n"
|
|
" }\n"
|
|
" aspect: (%i/%i) (%i/%i); aspect_preference: NONE;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, img_name, w, h, w, h);
|
|
}
|
|
else if (!strcmp(mode, "pan"))
|
|
{
|
|
fprintf(f, " data { item: \"style\" \"5\"; }\n");
|
|
fprintf(f,
|
|
" script {\n"
|
|
" public cur_anim; public cur_x; public cur_y;\n"
|
|
" public prev_x; public prev_y;\n"
|
|
" public total_x; public total_y;\n"
|
|
" public pan_bg(val, Float:v) {\n"
|
|
" new Float:x, Float:y, Float:px, Float: py;\n"
|
|
" px = get_float(prev_x);\n"
|
|
" py = get_float(prev_y);\n"
|
|
" if (get_int(total_x) > 1) {\n"
|
|
" x = float(get_int(cur_x)) / (get_int(total_x) - 1);\n"
|
|
" x = px - (px - x) * v;\n"
|
|
" } else {\n"
|
|
" x = 0.0;\n"
|
|
" v = 1.0;\n"
|
|
" }\n"
|
|
" if (get_int(total_y) > 1) {\n"
|
|
" y = float(get_int(cur_y)) / (get_int(total_y) - 1);\n"
|
|
" y = py - (py - y) * v;\n"
|
|
" } else {\n"
|
|
" y = 0.0;\n"
|
|
" v = 1.0; }\n"
|
|
" set_state_val(PART:\"bg\", STATE_ALIGNMENT, x, y);\n"
|
|
" if (v >= 1.0) {\n"
|
|
" set_int(cur_anim, 0);\n"
|
|
" set_float(prev_x, x);\n"
|
|
" set_float(prev_y, y);\n"
|
|
" return 0;\n"
|
|
" }\n"
|
|
" return 1;\n"
|
|
" }\n"
|
|
" public message(Msg_Type:type, id, ...) {\n"
|
|
" if ((type == MSG_FLOAT_SET) && (id == 0)) {\n"
|
|
" new ani;\n"
|
|
" get_state_val(PART:\"bg\", STATE_ALIGNMENT, prev_x, prev_y);\n"
|
|
" set_int(cur_x, round(getfarg(3)));\n"
|
|
" set_int(total_x, round(getfarg(4)));\n"
|
|
" set_int(cur_y, round(getfarg(5)));\n"
|
|
" set_int(total_y, round(getfarg(6)));\n"
|
|
" ani = get_int(cur_anim);\n"
|
|
" if (ani > 0) cancel_anim(ani);\n"
|
|
" ani = anim(getfarg(2), \"pan_bg\", 0);\n"
|
|
" set_int(cur_anim, ani);\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
" parts {\n"
|
|
" part { name: \"bg\"; mouse_events: 0;\n"
|
|
" description { state: \"default\" 0.0;\n"
|
|
" image {\n"
|
|
" normal: \"%s\";\n"
|
|
" scale_hint: STATIC;\n"
|
|
" }\n"
|
|
" aspect: (%i/%i) (%i/%i); aspect_preference: NONE;\n"
|
|
" }\n"
|
|
" }\n"
|
|
" program {\n"
|
|
" signal: \"load\"; source: \"\";\n"
|
|
" script {\n"
|
|
" custom_state(PART:\"bg\", \"default\", 0.0);\n"
|
|
" set_state(PART:\"bg\", \"custom\", 0.0);\n"
|
|
" set_float(prev_x, 0.0);\n"
|
|
" set_float(prev_y, 0.0);\n"
|
|
" }\n"
|
|
" }\n"
|
|
" }\n"
|
|
, img_name, w, h, w, h);
|
|
}
|
|
fprintf(f,
|
|
" }\n"
|
|
"}\n");
|
|
fclose(f);
|
|
if (snprintf(cmd_buf, sizeof(cmd_buf),
|
|
"%s -fastdecomp -threads -id %s -fd %s -sd %s -vd %s -dd %s -md %s "
|
|
"%s/bg.edc %s",
|
|
edje_cc, dir, dir, dir, dir, dir, dir,
|
|
dir, outfile) >= (int)sizeof(cmd_buf))
|
|
{
|
|
ret = 9;
|
|
goto cleanup;
|
|
}
|
|
ret = system(cmd_buf);
|
|
cleanup:
|
|
free(mips);
|
|
ecore_file_recursive_rm(dir);
|
|
evas_object_del(win);
|
|
return ret;
|
|
}
|
|
ELM_MAIN()
|