static void finalize_store_wrapper(struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data)
{
dt_lua_lock();
lua_State *L = darktable.lua_state.state;
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_getfield(L, -1, self->plugin_name);
lua_getfield(L, -1, "finalize_store");
if(lua_isnil(L, -1))
{
lua_pop(L, 3);
dt_lua_unlock();
return;
}
luaA_push_type(L, self->parameter_lua_type, data);
lua_storage_t *d = (lua_storage_t *)data;
push_lua_data(L,d);
dt_lua_goto_subtable(L,"files");
push_lua_data(L,d);
dt_lua_goto_subtable(L,"extra");
dt_lua_treated_pcall(L,3,0);
lua_pop(L, 2);
dt_lua_unlock();
}
int dt_lua_widget_trigger_callback(lua_State *L)
{
int nargs = lua_gettop(L) -2;
lua_widget widget;
luaA_to(L,lua_widget,&widget,1);
const char* name = lua_tostring(L,2);
lua_getuservalue(L,1);
lua_getfield(L,-1,name);
if(!lua_isnil(L,-1)) {
lua_pushvalue(L,1);
for(int i = 0 ; i < nargs ; i++) {
lua_pushvalue(L,i+3);
}
dt_lua_treated_pcall(L,nargs+1,0);
dt_lua_redraw_screen();
}
return 0;
}
static int autotype_next(lua_State *L)
{
/* CONVENTION
each block has the following stack on entry and exit
1 : the object
2 : the last entry ("next" convention)
each block should return according to "next" convention on success
each block should leave the key untouched if it doesn't know about it
each block should replace the key with "nil" if the key was the last entry it can handle
*/
// printf("aaaaa %s %d\n",__FUNCTION__,__LINE__);
if(luaL_getmetafield(L, 1, "__len"))
{
lua_pushvalue(L, -3);
lua_call(L, 1, 1);
int length = lua_tonumber(L, -1);
lua_pop(L, 1);
int key = 0;
if(lua_isnil(L, -1) && length > 0)
{
key = 1;
}
else if(lua_isnumber(L, -1) && lua_tonumber(L, -1) < length)
{
key = lua_tonumber(L, -1) + 1;
}
else if(lua_isnumber(L, -1) && lua_tonumber(L, -1) == length)
{
// numbers are done, move-on to something else
lua_pop(L, 1);
lua_pushnil(L);
}
if(key)
{
lua_pop(L, 1);
lua_pushnumber(L, key);
lua_pushnumber(L, key);
lua_gettable(L, -3);
return 2;
}
}
// stack at this point : {object,key}
int key_in_get = false;
luaL_getmetafield(L, 1, "__get");
if(lua_isnil(L, -2))
{
key_in_get = true;
}
else
{
lua_pushvalue(L, -2);
lua_gettable(L, -2);
if(lua_isnil(L, -1))
{
key_in_get = false;
lua_pop(L, 2);
}
else
{
key_in_get = true;
lua_pop(L, 1);
}
}
if(key_in_get)
{
lua_pushvalue(L, -2);
int nil_found = false;
while(!nil_found)
{
if(lua_next(L, -2))
{
// we have a next
lua_pop(L, 1);
lua_pushvalue(L, -4);
lua_pushvalue(L, -2);
// hacky way to avoid a subfunction just to do a pcall around getting a value in a table
luaL_loadstring(L,"args ={...}; return args[1][args[2]]");
lua_insert(L,-3);
int result = dt_lua_treated_pcall(L,2,1);
if(result == LUA_OK)
{
return 2;
}
else
{
lua_pop(L, 1);
// and loop to find the next possible value
}
}
else
{
// key was the last for __get
lua_pop(L, 2);
lua_pushnil(L);
nil_found = true;
}
}
}
// stack at this point : {object,key}
if(lua_isnil(L, -1))
{
return 1;
}
else
{
return luaL_error(L, "invalid key to 'next' : %s", lua_tostring(L, 2));
}
}
static int store_wrapper(struct dt_imageio_module_storage_t *self, struct dt_imageio_module_data_t *self_data,
const int imgid, dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata,
const int num, const int total, const gboolean high_quality, const gboolean upscale)
{
/* construct a temporary file name */
char tmpdir[PATH_MAX] = { 0 };
gboolean from_cache = FALSE;
dt_loc_get_tmp_dir(tmpdir, sizeof(tmpdir));
char dirname[PATH_MAX] = { 0 };
dt_image_full_path(imgid, dirname, sizeof(dirname), &from_cache);
dt_image_path_append_version(imgid, dirname, sizeof(dirname));
gchar *filename = g_path_get_basename(dirname);
gchar *end = g_strrstr(filename, ".") + 1;
g_strlcpy(end, format->extension(fdata), sizeof(dirname) - (end - dirname));
gchar *complete_name = g_build_filename(tmpdir, filename, (char *)NULL);
if(dt_imageio_export(imgid, complete_name, format, fdata, high_quality, upscale, FALSE, self, self_data, num, total) != 0)
{
fprintf(stderr, "[%s] could not export to file: `%s'!\n", self->name(self), complete_name);
g_free(complete_name);
g_free(filename);
return 1;
}
lua_storage_t *d = (lua_storage_t *)self_data;
dt_lua_lock();
lua_State *L = darktable.lua_state.state;
push_lua_data(L,d);
dt_lua_goto_subtable(L,"files");
luaA_push(L, dt_lua_image_t, &(imgid));
lua_pushstring(L, complete_name);
lua_settable(L, -3);
lua_pop(L,1);
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_getfield(L, -1, self->plugin_name);
lua_getfield(L, -1, "store");
if(lua_isnil(L, -1))
{
lua_pop(L, 3);
dt_lua_unlock();
g_free(filename);
return 0;
}
luaA_push_type(L, self->parameter_lua_type, self_data);
luaA_push(L, dt_lua_image_t, &imgid);
luaA_push_type(L, format->parameter_lua_type, fdata);
lua_pushstring(L, complete_name);
lua_pushnumber(L, num);
lua_pushnumber(L, total);
lua_pushboolean(L, high_quality);
push_lua_data(L,d);
dt_lua_goto_subtable(L,"extra");
dt_lua_treated_pcall(L,8,0);
lua_pop(L, 2);
dt_lua_unlock();
g_free(filename);
return false;
}
static int register_storage(lua_State *L)
{
lua_settop(L, 7);
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_newtable(L);
dt_imageio_module_storage_t *storage = malloc(sizeof(dt_imageio_module_storage_t));
memcpy(storage, &ref_storage, sizeof(dt_imageio_module_storage_t));
storage->gui_data = malloc(sizeof(lua_storage_gui_t));
lua_storage_gui_t *data = storage->gui_data;
const char *plugin_name = luaL_checkstring(L, 1);
lua_pushvalue(L, 1);
lua_setfield(L, -2, "plugin_name");
g_strlcpy(storage->plugin_name, plugin_name, sizeof(storage->plugin_name));
const char *name = luaL_checkstring(L, 2);
lua_pushvalue(L, 2);
lua_setfield(L, -2, "name");
data->name = strdup(name);
data->supported_formats = NULL;
data->widget = NULL;
if(!lua_isnoneornil(L, 3))
{
luaL_checktype(L, 3, LUA_TFUNCTION);
lua_pushvalue(L, 3);
lua_setfield(L, -2, "store");
}
if(lua_isnil(L, 4))
{
storage->finalize_store = NULL;
}
else
{
luaL_checktype(L, 4, LUA_TFUNCTION);
lua_pushvalue(L, 4);
lua_setfield(L, -2, "finalize_store");
}
if(!lua_isnoneornil(L, 5))
{
luaL_checktype(L, 5, LUA_TFUNCTION);
lua_pushvalue(L, 5);
lua_setfield(L, -2, "supported");
}
if(lua_isnil(L, 6))
{
storage->initialize_store = NULL;
}
else
{
luaL_checktype(L, 6, LUA_TFUNCTION);
lua_pushvalue(L, 6);
lua_setfield(L, -2, "initialize_store");
}
if(lua_isnil(L, 7))
{
storage->gui_init = empty_wrapper;
storage->gui_reset = empty_wrapper;
storage->gui_cleanup = empty_wrapper;
}
else
{
lua_widget widget;
luaA_to(L,lua_widget,&widget,7);
dt_lua_widget_bind(L,widget);
data->widget = widget;
}
lua_setfield(L, -2, plugin_name);
char tmp[1024];
snprintf(tmp, sizeof(tmp), "dt_imageio_module_data_pseudo_%s", storage->plugin_name);
luaA_Type type_id = luaA_type_add(L, tmp, storage->params_size(storage));
storage->parameter_lua_type = dt_lua_init_type_type(darktable.lua_state.state, type_id);
luaA_struct_type(darktable.lua_state.state, type_id);
dt_lua_register_storage_type(darktable.lua_state.state, storage, type_id);
GList *it = darktable.imageio->plugins_format;
if(!lua_isnoneornil(L, 5))
{
while(it)
{
lua_pushvalue(L, 5);
dt_imageio_module_format_t *format = (dt_imageio_module_format_t *)it->data;
dt_imageio_module_data_t *sdata = storage->get_params(storage);
dt_imageio_module_data_t *fdata = format->get_params(format);
luaA_push_type(L, storage->parameter_lua_type, sdata);
luaA_push_type(L, format->parameter_lua_type, fdata);
format->free_params(format, fdata);
storage->free_params(storage, sdata);
dt_lua_treated_pcall(L,2,1);
int result = lua_toboolean(L, -1);
lua_pop(L, 1);
if(result)
{
data->supported_formats = g_list_prepend(data->supported_formats, format);
}
it = g_list_next(it);
}
}
else
{
// all formats are supported
while(it)
{
dt_imageio_module_format_t *format = (dt_imageio_module_format_t *)it->data;
data->supported_formats = g_list_prepend(data->supported_formats, format);
it = g_list_next(it);
}
}
storage->gui_init(storage);
if(storage->widget) g_object_ref(storage->widget);
dt_imageio_insert_storage(storage);
return 0;
}
// FIXME: return 0 on success and 1 on error!
static int initialize_store_wrapper(struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data,
dt_imageio_module_format_t **format, dt_imageio_module_data_t **fdata,
GList **images, const gboolean high_quality, const gboolean upscale)
{
dt_lua_lock();
lua_State *L = darktable.lua_state.state;
lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
lua_getfield(L, -1, self->plugin_name);
lua_getfield(L, -1, "initialize_store");
if(lua_isnil(L, -1))
{
lua_pop(L, 3);
dt_lua_unlock();
return 1;
}
luaA_push_type(L, self->parameter_lua_type, data);
luaA_push_type(L, (*format)->parameter_lua_type, *fdata);
GList *imgids = *images;
lua_newtable(L);
while(imgids)
{
luaA_push(L, dt_lua_image_t, &(imgids->data));
luaL_ref(L, -2);
imgids = g_list_next(imgids);
}
lua_pushboolean(L, high_quality);
lua_storage_t *d = (lua_storage_t *)data;
push_lua_data(L,d);
dt_lua_goto_subtable(L,"extra");
dt_lua_treated_pcall(L,5,1);
if(!lua_isnoneornil(L, -1))
{
g_list_free(*images);
if(lua_type(L,-1) != LUA_TTABLE)
{
dt_print(DT_DEBUG_LUA, "LUA ERROR initialization function of storage did not return nil or table\n");
dt_lua_unlock();
return 1;
}
GList *new_images = NULL;
lua_pushnil(L);
while(lua_next(L, -2))
{
dt_lua_image_t imgid;
luaA_to(L, dt_lua_image_t, &imgid, -1);
new_images = g_list_prepend(new_images, GINT_TO_POINTER(imgid));
lua_pop(L, 1);
}
new_images = g_list_reverse(new_images);
*images = new_images;
}
lua_pop(L, 3);
dt_lua_unlock();
return 0;
}
