int32_t dt_camera_capture_job_run(dt_job_t *job)
{
dt_camera_capture_t *t=(dt_camera_capture_t*)job->param;
int total = t->brackets ? t->count * t->brackets : t->count;
char message[512]= {0};
double fraction=0;
snprintf(message, 512, ngettext ("capturing %d image", "capturing %d images", total), total );
/* try to get exp program mode for nikon */
char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram");
/* if fail, lets try fetching mode for cannon */
if(!expprogram)
expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode");
/* Fetch all values for shutterspeed and initialize current value */
GList *values=NULL;
gconstpointer orginal_value=NULL;
const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed");
const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed");
/* get values for bracketing */
if (t->brackets && expprogram && expprogram[0]=='M' && value && cvalue)
{
do
{
// Add value to list
values = g_list_append(values, g_strdup(value));
// Check if current values is the same as orginal value, then lets store item ptr
if (strcmp(value,cvalue) == 0)
orginal_value = g_list_last(values)->data;
}
while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL);
}
else
{
/* if this was an itended bracket capture bail out */
if(t->brackets)
{
dt_control_log(_("please set your camera to manual mode first!"));
return 1;
}
}
/* create the bgjob plate */
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message);
GList *current_value = g_list_find(values,orginal_value);
for(int i=0; i<t->count; i++)
{
for(int b=0; b<(t->brackets*2)+1; b++)
{
// If bracket capture, lets set change shutterspeed
if (t->brackets)
{
if (b == 0)
{
// First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode
for(int s=0; s<(t->steps*t->brackets); s++)
if (g_list_next(current_value) && g_list_next(g_list_next(current_value)))
current_value = g_list_next(current_value);
}
else
{
// Step up with (steps)
for(int s=0; s<t->steps; s++)
if(g_list_previous(current_value))
current_value = g_list_previous(current_value);
}
}
// set the time property for bracked capture
if (t->brackets && current_value)
dt_camctl_camera_set_property(darktable.camctl, NULL, "shutterspeed", current_value->data);
// Capture image
dt_camctl_camera_capture(darktable.camctl,NULL);
fraction += 1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
// lets reset to orginal value before continue
if (t->brackets)
{
current_value = g_list_find(values,orginal_value);
dt_camctl_camera_set_property(darktable.camctl, NULL, "shutterspeed", current_value->data);
}
// Delay if active
if(t->delay)
g_usleep(t->delay*G_USEC_PER_SEC);
}
dt_control_backgroundjobs_destroy(darktable.control, jid);
// free values
if(values)
{
for(int i=0; i<g_list_length(values); i++)
g_free(g_list_nth_data(values,i));
g_list_free(values);
}
return 0;
}
static void
_init_f(
float *out,
uint32_t *width,
uint32_t *height,
const uint32_t imgid)
{
const uint32_t wd = *width, ht = *height;
/* do not even try to process file if it isnt available */
char filename[2048] = {0};
dt_image_full_path(imgid, filename, 2048);
if (strlen(filename) == 0 || !g_file_test(filename, G_FILE_TEST_EXISTS))
{
*width = *height = 0;
return;
}
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
// lock image after we have the buffer, we might need to lock the image struct for
// writing during raw loading, to write to width/height.
const dt_image_t *image = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_iop_roi_t roi_in, roi_out;
roi_in.x = roi_in.y = 0;
roi_in.width = image->width;
roi_in.height = image->height;
roi_in.scale = 1.0f;
roi_out.x = roi_out.y = 0;
roi_out.scale = fminf(wd/(float)image->width, ht/(float)image->height);
roi_out.width = roi_out.scale * roi_in.width;
roi_out.height = roi_out.scale * roi_in.height;
if(!buf.buf)
{
dt_control_log(_("image `%s' is not available!"), image->filename);
dt_image_cache_read_release(darktable.image_cache, image);
*width = *height = 0;
return;
}
assert(!buffer_is_broken(&buf));
if(image->filters)
{
// demosaic during downsample
if(image->bpp == sizeof(float))
dt_iop_clip_and_zoom_demosaic_half_size_f(
out, (const float *)buf.buf,
&roi_out, &roi_in, roi_out.width, roi_in.width,
dt_image_flipped_filter(image), 1.0f);
else
dt_iop_clip_and_zoom_demosaic_half_size(
out, (const uint16_t *)buf.buf,
&roi_out, &roi_in, roi_out.width, roi_in.width,
dt_image_flipped_filter(image));
}
else
{
// downsample
dt_iop_clip_and_zoom(out, (const float *)buf.buf,
&roi_out, &roi_in, roi_out.width, roi_in.width);
}
dt_image_cache_read_release(darktable.image_cache, image);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
*width = roi_out.width;
*height = roi_out.height;
}
int32_t dt_camera_import_job_run(dt_job_t *job)
{
dt_camera_import_t *t = (dt_camera_import_t *)job->param;
dt_control_log(_("starting to import images from camera"));
// Setup a new filmroll to import images to....
t->film=(dt_film_t*)g_malloc(sizeof(dt_film_t));
dt_film_init(t->film);
gchar* fixed_path = dt_util_fix_path(t->path);
g_free(t->path);
t->path = fixed_path;
dt_variables_expand( t->vp, t->path, FALSE );
sprintf(t->film->dirname,"%s",dt_variables_get_result(t->vp));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref++;
dt_pthread_mutex_unlock(&t->film->images_mutex);
// Create recursive directories, abort if no access
if( g_mkdir_with_parents(t->film->dirname,0755) == -1 )
{
dt_control_log(_("failed to create import path `%s', import aborted."), t->film->dirname);
return 1;
}
// Import path is ok, lets actually create the filmroll in database..
if(dt_film_new(t->film,t->film->dirname) > 0)
{
int total = g_list_length( t->images );
char message[512]= {0};
sprintf(message, ngettext ("importing %d image from camera", "importing %d images from camera", total), total );
t->bgj = dt_control_backgroundjobs_create(darktable.control, 0, message);
// Switch to new filmroll
dt_film_open(t->film->id);
dt_ctl_switch_mode_to(DT_LIBRARY);
// register listener
dt_camctl_listener_t listener= {0};
listener.data=t;
listener.image_downloaded=_camera_image_downloaded;
listener.request_image_path=_camera_import_request_image_path;
listener.request_image_filename=_camera_import_request_image_filename;
// start download of images
dt_camctl_register_listener(darktable.camctl,&listener);
dt_camctl_import(darktable.camctl,t->camera,t->images,dt_conf_get_bool("plugins/capture/camera/import/delete_originals"));
dt_camctl_unregister_listener(darktable.camctl,&listener);
dt_control_backgroundjobs_destroy(darktable.control, t->bgj);
dt_variables_params_destroy(t->vp);
}
else
dt_control_log(_("failed to create filmroll for camera import, import aborted."));
dt_pthread_mutex_lock(&t->film->images_mutex);
t->film->ref--;
dt_pthread_mutex_unlock(&t->film->images_mutex);
return 0;
}
// This is basically the same as dt_image_remove() from common/image.c.
// It just does the iteration over all images in the SQL statement
void dt_film_remove(const int id)
{
// only allowed if local copies have their original accessible
sqlite3_stmt *stmt;
gboolean remove_ok = TRUE;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT id FROM main.images WHERE film_id = ?1", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
int imgid = sqlite3_column_int(stmt, 0);
if(!dt_image_safe_remove(imgid))
{
remove_ok = FALSE;
break;
}
}
sqlite3_finalize(stmt);
if(!remove_ok)
{
dt_control_log(_("cannot remove film roll having local copies with non accessible originals"));
return;
}
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.tagged_images WHERE imgid IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.history WHERE imgid IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.color_labels WHERE imgid IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.meta_data WHERE id IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.selected_images WHERE imgid IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT id FROM main.images WHERE film_id = ?1", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
const uint32_t imgid = sqlite3_column_int(stmt, 0);
dt_image_local_copy_reset(imgid);
dt_mipmap_cache_remove(darktable.mipmap_cache, imgid);
dt_image_cache_remove(darktable.image_cache, imgid);
}
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.images WHERE id IN "
"(SELECT id FROM main.images WHERE film_id = ?1)",
-1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "DELETE FROM main.film_rolls WHERE id = ?1", -1,
&stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
sqlite3_step(stmt);
sqlite3_finalize(stmt);
// dt_control_update_recent_films();
dt_control_signal_raise(darktable.signals, DT_SIGNAL_FILMROLLS_CHANGED);
}
int dt_gui_hist_dialog_new(dt_gui_hist_dialog_t *d, int imgid, gboolean iscopy)
{
int res;
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(
_("select parts"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, _("_cancel"),
GTK_RESPONSE_CANCEL, _("select _all"), GTK_RESPONSE_YES, _("select _none"), GTK_RESPONSE_NONE, _("_ok"),
GTK_RESPONSE_OK, NULL));
#ifdef GDK_WINDOWING_QUARTZ
dt_osx_disallow_fullscreen(GTK_WIDGET(dialog));
#endif
GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 3));
gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_container_add(content_area, GTK_WIDGET(box));
/* create the list of items */
d->items = GTK_TREE_VIEW(gtk_tree_view_new());
GtkListStore *liststore
= gtk_list_store_new(DT_HIST_ITEMS_NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT);
/* enabled */
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_ENABLED);
g_signal_connect(renderer, "toggled", G_CALLBACK(_gui_hist_item_toggled), d);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("include"), renderer, "active",
DT_HIST_ITEMS_COL_ENABLED, NULL);
/* name */
renderer = gtk_cell_renderer_text_new();
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_NAME);
g_object_set(renderer, "xalign", 0.0, (gchar *)0);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("item"), renderer, "text",
DT_HIST_ITEMS_COL_NAME, NULL);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->items)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(d->items), GTK_TREE_MODEL(liststore));
gtk_box_pack_start(box, GTK_WIDGET(d->items), TRUE, TRUE, 0);
/* fill list with history items */
GtkTreeIter iter;
GList *items = dt_history_get_items(imgid, FALSE);
if(items)
{
do
{
dt_history_item_t *item = (dt_history_item_t *)items->data;
gtk_list_store_append(GTK_LIST_STORE(liststore), &iter);
gtk_list_store_set(GTK_LIST_STORE(liststore), &iter, DT_HIST_ITEMS_COL_ENABLED,
iscopy ? TRUE : _gui_is_set(d->selops, item->num), DT_HIST_ITEMS_COL_NAME,
item->name, DT_HIST_ITEMS_COL_NUM, (guint)item->num, -1);
} while((items = g_list_next(items)));
g_list_free_full(items, dt_history_item_free);
}
else
{
dt_control_log(_("can't copy history out of unaltered image"));
return GTK_RESPONSE_CANCEL;
}
g_object_unref(liststore);
g_signal_connect(dialog, "response", G_CALLBACK(_gui_hist_copy_response), d);
gtk_widget_show_all(GTK_WIDGET(dialog));
while(1)
{
res = gtk_dialog_run(GTK_DIALOG(dialog));
if(res == GTK_RESPONSE_CANCEL || res == GTK_RESPONSE_DELETE_EVENT || res == GTK_RESPONSE_OK) break;
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return res;
}
int
store (dt_imageio_module_storage_t *self, dt_imageio_module_data_t *sdata, 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)
{
gint result = 0;
dt_storage_flickr_params_t *p=(dt_storage_flickr_params_t *)sdata;
flickcurl_upload_status *photo_status;
gint tags=0;
const char *ext = format->extension(fdata);
// Let's upload image...
/* construct a temporary file name */
char fname[PATH_MAX]= {0};
dt_loc_get_tmp_dir (fname, sizeof(fname));
g_strlcat (fname,"/darktable.XXXXXX.", sizeof(fname));
g_strlcat(fname, ext, sizeof(fname));
char *caption = NULL;
char *description = NULL;
gint fd=g_mkstemp(fname);
fprintf(stderr,"tempfile: %s\n",fname);
if(fd==-1)
{
dt_control_log("failed to create temporary image for flickr export");
return 1;
}
close(fd);
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, imgid);
// If title is not existing, then use the filename without extension. If not, then use title instead
GList *title = dt_metadata_get(img->id, "Xmp.dc.title", NULL);
if(title != NULL)
{
caption = g_strdup(title->data);
g_list_free_full(title, &g_free);
}
else
{
caption = g_path_get_basename(img->filename);
(g_strrstr(caption,"."))[0]='\0'; // chop extension...
}
GList *desc = dt_metadata_get(img->id, "Xmp.dc.description", NULL);
if(desc != NULL)
{
description = desc->data;
}
dt_image_cache_read_release(darktable.image_cache, img);
if(dt_imageio_export(imgid, fname, format, fdata, high_quality,FALSE,self,sdata) != 0)
{
fprintf(stderr, "[imageio_storage_flickr] could not export to file: `%s'!\n", fname);
dt_control_log(_("could not export to file `%s'!"), fname);
result = 1;
goto cleanup;
}
#ifdef _OPENMP
#pragma omp critical
#endif
{
//TODO: Check if this could be done in threads, so we enhance export time by using
// upload time for one image to export another image to disk.
// Upload image
// Do we export tags?
if( p->export_tags == TRUE )
tags = imgid;
photo_status = _flickr_api_upload_photo( p, fname, caption, description, tags );
}
if( !photo_status )
{
fprintf(stderr, "[imageio_storage_flickr] could not upload to flickr!\n");
dt_control_log(_("could not upload to flickr!"));
result = 1;
goto cleanup;
}
// int fail = 0;
// A photoset is only created if we have an album title set
if( p->flickr_api->current_album == NULL && p->flickr_api->new_album == TRUE)
{
char *photoset_id;
photoset_id = _flickr_api_create_photoset(p->flickr_api, photo_status->photoid);
if( photoset_id == NULL)
{
dt_control_log("failed to create flickr album");
// fail = 1;
}
else
{
// p->flickr_api->new_album = FALSE;
p->flickr_api->current_album = flickcurl_photosets_getInfo(p->flickr_api->fc,photoset_id);
}
}
// if(fail) return 1;
// TODO: What to do if photoset creation fails?
// Add to gallery, if needed
if (p->flickr_api->current_album != NULL && p->flickr_api->new_album != TRUE)
{
flickcurl_photosets_addPhoto (p->flickr_api->fc, p->flickr_api->current_album->id, photo_status->photoid);
// TODO: Check for errors adding photo to gallery
}
else
{
if (p->flickr_api->current_album != NULL && p->flickr_api->new_album == TRUE)
{
p->flickr_api->new_album = FALSE;
}
}
cleanup:
// And remove from filesystem..
unlink( fname );
g_free( caption );
if(desc)
g_list_free_full(desc, &g_free);
if (!result)
{
//this makes sense only if the export was successful
dt_control_log(_("%d/%d exported to flickr webalbum"), num, total );
}
return result;
}
void
dt_styles_create_from_style (const char *name, const char *newname, const char *description, GList *filter)
{
sqlite3_stmt *stmt;
int id=0;
int oldid=0;
oldid = dt_styles_get_id_by_name(name);
if(oldid == 0) return;
/* create the style header */
if (!dt_styles_create_style_header(newname, description)) return;
if ((id=dt_styles_get_id_by_name(newname)) != 0)
{
if (filter)
{
GList *list=filter;
char tmp[64];
char include[2048]= {0};
g_strlcat(include,"num in (", 2048);
do
{
if(list!=g_list_first(list))
g_strlcat(include,",", 2048);
sprintf(tmp,"%ld",(long int)list->data);
g_strlcat(include,tmp, 2048);
}
while ((list=g_list_next(list)));
g_strlcat(include,")", 2048);
char query[4096]= {0};
sprintf(query,"insert into style_items (styleid,num,module,operation,op_params,enabled,blendop_params,blendop_version) select ?1, num,module,operation,op_params,enabled,blendop_params,blendop_version from style_items where styleid=?2 and %s",include);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);
}
else
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "insert into style_items (styleid,num,module,operation,op_params,enabled,blendop_params,blendop_version) select ?1, num,module,operation,op_params,enabled,blendop_params,blendop_version from style_items where style_id=?2", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, oldid);
sqlite3_step (stmt);
sqlite3_finalize (stmt);
/* backup style to disk */
char stylesdir[1024];
dt_loc_get_user_config_dir(stylesdir, 1024);
g_strlcat(stylesdir,"/styles",1024);
g_mkdir_with_parents(stylesdir,00755);
dt_styles_save_to_file(newname,stylesdir,FALSE);
char tmp_accel[1024];
gchar* tmp_name = g_strdup(newname); // freed by _destro_style_shortcut_callback
snprintf(tmp_accel,1024,"styles/Apply %s",newname);
dt_accel_register_global( tmp_accel, 0, 0);
GClosure *closure;
closure = g_cclosure_new(
G_CALLBACK(_apply_style_shortcut_callback),
tmp_name, _destroy_style_shortcut_callback);
dt_accel_connect_global(tmp_accel, closure);
dt_control_log(_("style named '%s' successfully created"),newname);
}
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log(darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log(darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
int
dt_history_copy_and_paste_on_image (int32_t imgid, int32_t dest_imgid, gboolean merge, GList *ops)
{
sqlite3_stmt *stmt;
if(imgid==dest_imgid) return 1;
if(imgid==-1)
{
dt_control_log(_("you need to copy history from an image before you paste it onto another"));
return 1;
}
/* if merge onto history stack, lets find history offest in destination image */
int32_t offs = 0;
if (merge)
{
/* apply on top of history stack */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "SELECT MAX(num)+1 FROM history WHERE imgid = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dest_imgid);
if (sqlite3_step (stmt) == SQLITE_ROW) offs = sqlite3_column_int (stmt, 0);
}
else
{
/* replace history stack */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "delete from history where imgid = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dest_imgid);
sqlite3_step (stmt);
}
sqlite3_finalize (stmt);
// prepare SQL request
char req[2048];
strcpy (req, "insert into history (imgid, num, module, operation, op_params, enabled, blendop_params, blendop_version, multi_name, multi_priority) select ?1, num+?2, module, operation, op_params, enabled, blendop_params, blendop_version, multi_name, multi_priority from history where imgid = ?3");
// Add ops selection if any format: ... and num in (val1, val2)
if (ops)
{
GList *l = ops;
int first = 1;
strcat (req, " and num in (");
while (l)
{
long unsigned int value = (long unsigned int)l->data;
char v[30];
if (!first) strcat (req, ",");
snprintf (v, 30, "%lu", value);
strcat (req, v);
first=0;
l = g_list_next(l);
}
strcat (req, ")");
}
/* add the history items to stack offest */
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), req, -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dest_imgid);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, offs);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, imgid);
sqlite3_step (stmt);
sqlite3_finalize (stmt);
if (merge && ops)
_dt_history_cleanup_multi_instance(dest_imgid, offs);
//we have to copy masks too
//what to do with existing masks ?
if (merge)
{
//there's very little chance that we will have same shapes id.
//but we may want to handle this case anyway
//and it's not trivial at all !
}
else
{
//let's remove all existing shapes
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "delete from mask where imgid = ?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dest_imgid);
sqlite3_step (stmt);
sqlite3_finalize (stmt);
}
//let's copy now
strcpy (req, "insert into mask (imgid, formid, form, name, version, points, points_count, source) select ?1, formid, form, name, version, points, points_count, source from mask where imgid = ?2");
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), req, -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dest_imgid);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);
sqlite3_step (stmt);
sqlite3_finalize (stmt);
/* if current image in develop reload history */
if (dt_dev_is_current_image(darktable.develop, dest_imgid))
{
dt_dev_reload_history_items (darktable.develop);
dt_dev_modulegroups_set(darktable.develop, dt_dev_modulegroups_get(darktable.develop));
}
/* update xmp file */
dt_image_synch_xmp(dest_imgid);
dt_mipmap_cache_remove(darktable.mipmap_cache, dest_imgid);
return 0;
}
int32_t dt_camera_capture_job_run(dt_job_t *job)
{
dt_camera_capture_t *t=(dt_camera_capture_t*)job->param;
int total;
char message[512]= {0};
double fraction=0;
total = t->total = t->brackets ? t->count * t->brackets : t->count;
snprintf(message, 512, ngettext ("capturing %d image", "capturing %d images", total), total );
pthread_mutex_init(&t->mutex, NULL);
pthread_cond_init(&t->done, NULL);
// register listener
dt_camctl_listener_t *listener;
listener = g_malloc(sizeof(dt_camctl_listener_t));
memset(listener, 0, sizeof(dt_camctl_listener_t));
listener->data=t;
listener->image_downloaded=_camera_capture_image_downloaded;
listener->request_image_path=_camera_request_image_path;
listener->request_image_filename=_camera_request_image_filename;
dt_camctl_register_listener(darktable.camctl, listener);
/* try to get exp program mode for nikon */
char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram");
/* if fail, lets try fetching mode for cannon */
if(!expprogram)
expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode");
/* Fetch all values for shutterspeed and initialize current value */
GList *values=NULL;
gconstpointer original_value=NULL;
const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed");
const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed");
/* get values for bracketing */
if (t->brackets && expprogram && expprogram[0]=='M' && value && cvalue)
{
do
{
// Add value to list
values = g_list_append(values, g_strdup(value));
// Check if current values is the same as original value, then lets store item ptr
if (strcmp(value,cvalue) == 0)
original_value = g_list_last(values)->data;
}
while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL);
}
else
{
/* if this was an intended bracket capture bail out */
if(t->brackets)
{
dt_control_log(_("please set your camera to manual mode first!"));
return 1;
}
}
/* create the bgjob plate */
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message);
GList *current_value = g_list_find(values,original_value);
for(uint32_t i=0; i<t->count; i++)
{
// Delay if active
if(t->delay)
g_usleep(t->delay*G_USEC_PER_SEC);
for(uint32_t b=0; b<(t->brackets*2)+1; b++)
{
// If bracket capture, lets set change shutterspeed
if (t->brackets)
{
if (b == 0)
{
// First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode
for(uint32_t s=0; s<(t->steps*t->brackets); s++)
if (g_list_next(current_value) && g_list_next(g_list_next(current_value)))
current_value = g_list_next(current_value);
}
else
{
// Step up with (steps)
for(uint32_t s=0; s<t->steps; s++)
if(g_list_previous(current_value))
current_value = g_list_previous(current_value);
}
}
// set the time property for bracket capture
if (t->brackets && current_value)
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
// Capture image
dt_camctl_camera_capture(darktable.camctl,NULL);
fraction += 1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
// lets reset to original value before continue
if (t->brackets)
{
current_value = g_list_find(values,original_value);
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
}
}
/* wait for last image capture before exiting job */
pthread_mutex_lock(&t->mutex);
pthread_cond_wait(&t->done, &t->mutex);
pthread_mutex_unlock(&t->mutex);
pthread_mutex_destroy(&t->mutex);
pthread_cond_destroy(&t->done);
/* cleanup */
dt_control_backgroundjobs_destroy(darktable.control, jid);
dt_import_session_destroy(t->shared.session);
dt_camctl_unregister_listener(darktable.camctl, listener);
g_free(listener);
// free values
if(values)
{
g_list_free_full(values, g_free);
}
return 0;
}
static void _lib_import_single_image_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import image"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);
char *cp, **extensions, ext[1024];
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
extensions = g_strsplit(dt_supported_extensions, ",", 100);
for(char **i=extensions; *i!=NULL; i++)
{
snprintf(ext, 1024, "*.%s", *i);
gtk_file_filter_add_pattern(filter, ext);
gtk_file_filter_add_pattern(filter, cp=g_ascii_strup(ext, -1));
g_free(cp);
}
g_strfreev(extensions);
gtk_file_filter_set_name(filter, _("supported images"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
GtkWidget *preview = gtk_image_new();
gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(filechooser), preview);
g_signal_connect(filechooser, "update-preview", G_CALLBACK (_lib_import_update_preview), preview);
dt_lib_import_metadata_t metadata;
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), _lib_import_get_extra_widget(&metadata, FALSE));
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
_lib_import_evaluate_extra_widget(&metadata, FALSE);
char *filename = NULL;
dt_film_t film;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
int id = 0;
int filmid = 0;
/* reset filter so that view isn't empty */
dt_view_filter_reset(darktable.view_manager, TRUE);
while(it)
{
filename = (char *)it->data;
gchar *directory = g_path_get_dirname((const gchar *)filename);
filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
if(!id) dt_control_log(_("error loading file `%s'"), filename);
g_free (filename);
g_free (directory);
it = g_slist_next(it);
}
if(id)
{
dt_film_open(filmid);
// make sure buffers are loaded (load full for testing)
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
if(!buf.buf)
{
dt_control_log(_("file has unknown format!"));
}
else
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_set_mouse_over_id(id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
gtk_widget_destroy(metadata.frame);
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
int store(dt_imageio_module_storage_t *self, dt_imageio_module_data_t *sdata, 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, dt_colorspaces_color_profile_type_t icc_type,
const gchar *icc_filename, dt_iop_color_intent_t icc_intent)
{
dt_storage_piwigo_gui_data_t *ui = self->gui_data;
gint result = 0;
const char *ext = format->extension(fdata);
// Let's upload image...
/* construct a temporary file name */
char fname[PATH_MAX] = { 0 };
dt_loc_get_tmp_dir(fname, sizeof(fname));
g_strlcat(fname, "/darktable.XXXXXX.", sizeof(fname));
g_strlcat(fname, ext, sizeof(fname));
char *caption = NULL;
char *description = NULL;
char *author = NULL;
gint fd = g_mkstemp(fname);
if(fd == -1)
{
dt_control_log("failed to create temporary image for piwigo export");
fprintf(stderr, "failed to create tempfile: %s\n", fname);
return 1;
}
close(fd);
const dt_image_t *img = dt_image_cache_get(darktable.image_cache, imgid, 'r');
// If title is not existing, then use the filename without extension. If not, then use title instead
GList *title = dt_metadata_get(img->id, "Xmp.dc.title", NULL);
if(title != NULL)
{
caption = g_strdup(title->data);
g_list_free_full(title, &g_free);
}
else
{
caption = g_path_get_basename(img->filename);
(g_strrstr(caption, "."))[0] = '\0'; // chop extension...
}
GList *desc = dt_metadata_get(img->id, "Xmp.dc.description", NULL);
if(desc != NULL)
{
description = g_strdup(desc->data);
g_list_free_full(desc, &g_free);
}
dt_image_cache_read_release(darktable.image_cache, img);
GList *auth = dt_metadata_get(img->id, "Xmp.dc.creator", NULL);
if(auth != NULL)
{
author = g_strdup(auth->data);
g_list_free_full(auth, &g_free);
}
if(dt_imageio_export(imgid, fname, format, fdata, high_quality, upscale, FALSE, icc_type, icc_filename, icc_intent,
self, sdata, num, total) != 0)
{
fprintf(stderr, "[imageio_storage_piwigo] could not export to file: `%s'!\n", fname);
dt_control_log(_("could not export to file `%s'!"), fname);
result = 1;
goto cleanup;
}
dt_pthread_mutex_lock(&darktable.plugin_threadsafe);
{
gboolean status = TRUE;
dt_storage_piwigo_params_t *p = (dt_storage_piwigo_params_t *)sdata;
if(p->export_tags)
{
GList *tags_list = dt_tag_get_list(imgid);
if(p->tags) g_free(p->tags);
p->tags = dt_util_glist_to_str(",", tags_list);
g_list_free_full(tags_list, g_free);
}
if(p->new_album)
{
status = _piwigo_api_create_new_album(p);
if(!status) dt_control_log(_("cannot create a new piwigo album!"));
}
if(status)
{
status = _piwigo_api_upload_photo(p, fname, author, caption, description);
if(!status)
{
fprintf(stderr, "[imageio_storage_piwigo] could not upload to piwigo!\n");
dt_control_log(_("could not upload to piwigo!"));
result = 1;
}
else if (p->new_album)
{
// we do not want to create more albums when multiple upload
p->new_album = FALSE;
_piwigo_refresh_albums(ui, p->album);
}
}
}
dt_pthread_mutex_unlock(&darktable.plugin_threadsafe);
cleanup:
// And remove from filesystem..
g_unlink(fname);
g_free(caption);
g_free(description);
g_free(author);
if(!result)
{
// this makes sense only if the export was successful
dt_control_log(ngettext("%d/%d exported to piwigo webalbum", "%d/%d exported to piwigo webalbum", num),
num, total);
}
return result;
}
/** Refresh albums */
static void _piwigo_refresh_albums(dt_storage_piwigo_gui_data_t *ui, const gchar *select_album)
{
gtk_widget_set_sensitive(GTK_WIDGET(ui->album_list), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(ui->parent_album_list), FALSE);
if(ui->api == NULL || ui->api->authenticated == FALSE)
{
_piwigo_authenticate(ui);
if(ui->api == NULL || !ui->api->authenticated) return;
}
gchar *to_select;
int index = 0;
// get the new album name, it will be checked in the
if(select_album == NULL)
{
to_select = g_strdup(dt_bauhaus_combobox_get_text(ui->album_list));
if(to_select)
{
// cut the count of picture in album to get the name only
gchar *p = to_select;
while(*p)
{
if(*p == ' ' && *(p+1) == '(')
{
*p = '\0';
break;
}
p++;
}
}
}
else
to_select = g_strdup(select_album);
// First clear the combobox except first 2 items (none / create new album)
dt_bauhaus_combobox_clear(ui->album_list);
dt_bauhaus_combobox_clear(ui->parent_album_list);
g_list_free(ui->albums);
ui->albums = NULL;
GList *args = NULL;
args = _piwigo_query_add_arguments(args, "method", "pwg.categories.getList");
args = _piwigo_query_add_arguments(args, "cat_id", "0");
args = _piwigo_query_add_arguments(args, "recursive", "true");
_piwigo_api_post(ui->api, args, NULL, FALSE);
g_list_free(args);
if(ui->api->response && !ui->api->error_occured)
{
dt_bauhaus_combobox_add(ui->album_list, _("create new album"));
dt_bauhaus_combobox_add(ui->parent_album_list, _("---"));
JsonObject *result = json_node_get_object(json_object_get_member(ui->api->response, "result"));
JsonArray *albums = json_object_get_array_member(result, "categories");
if(json_array_get_length(albums)>0 && index==0) index = 1;
if(index > json_array_get_length(albums) - 1) index = json_array_get_length(albums) - 1;
for(int i = 0; i < json_array_get_length(albums); i++)
{
char data[MAX_ALBUM_NAME_SIZE] = { 0 };
JsonObject *album = json_array_get_object_element(albums, i);
_piwigo_album_t *new_album = g_malloc0(sizeof(struct _piwigo_album_t));
g_strlcpy(new_album->name, json_object_get_string_member(album, "name"), sizeof(new_album->name));
new_album->id = json_object_get_int_member(album, "id");
new_album->size = json_object_get_int_member(album, "nb_images");
const int isroot = json_object_get_null_member(album, "id_uppercat");
int indent = 0;
if(!isroot)
{
const char *hierarchy = json_object_get_string_member(album, "uppercats");
char const *p = hierarchy;
while(*p++) if(*p == ',') indent++;
}
snprintf(data, sizeof(data), "%*c%s (%"PRId64")", indent * 3, ' ', new_album->name, new_album->size);
if(to_select && !strcmp(new_album->name, to_select)) index = i + 1;
g_strlcpy(new_album->label, data, sizeof(new_album->label));
ui->albums = g_list_append(ui->albums, new_album);
dt_bauhaus_combobox_add_aligned(ui->album_list, data, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
dt_bauhaus_combobox_add_aligned(ui->parent_album_list, data, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
}
}
else
dt_control_log(_("cannot refresh albums"));
g_free(to_select);
gtk_widget_set_sensitive(GTK_WIDGET(ui->album_list), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(ui->parent_album_list), TRUE);
dt_bauhaus_combobox_set(ui->album_list, index);
}
void
dt_styles_save_to_file(const char *style_name,const char *filedir,gboolean overwrite)
{
int rc = 0;
char stylename[520];
sqlite3_stmt *stmt;
snprintf(stylename,512,"%s/%s.dtstyle",filedir,style_name);
// check if file exists
if( g_file_test(stylename, G_FILE_TEST_EXISTS) == TRUE )
{
if(overwrite)
{
if(unlink(stylename))
{
dt_control_log(_("failed to overwrite style file for %s"),style_name);
return;
}
}
else
{
dt_control_log(_("style file for %s exists"),style_name);
return;
}
}
if ( !dt_styles_exists (style_name) ) return;
xmlTextWriterPtr writer = xmlNewTextWriterFilename(stylename, 0);
if (writer == NULL)
{
fprintf(stderr,"[dt_styles_save_to_file] Error creating the xml writer\n, path: %s", stylename);
return;
}
rc = xmlTextWriterStartDocument(writer, NULL, "ISO-8859-1", NULL);
if (rc < 0)
{
fprintf(stderr,"[dt_styles_save_to_file]: Error on encoding setting");
return;
}
xmlTextWriterStartElement(writer, BAD_CAST "darktable_style");
xmlTextWriterWriteAttribute(writer, BAD_CAST "version", BAD_CAST "1.0");
xmlTextWriterStartElement(writer, BAD_CAST "info");
xmlTextWriterWriteFormatElement(writer, BAD_CAST "name", "%s", style_name);
xmlTextWriterWriteFormatElement(writer, BAD_CAST "description", "%s", dt_styles_get_description(style_name));
xmlTextWriterEndElement(writer);
xmlTextWriterStartElement(writer, BAD_CAST "style");
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select num,module,operation,op_params,enabled,blendop_params,blendop_version from style_items where styleid =?1",-1, &stmt,NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt,1,dt_styles_get_id_by_name(style_name));
while (sqlite3_step (stmt) == SQLITE_ROW)
{
xmlTextWriterStartElement(writer, BAD_CAST "plugin");
xmlTextWriterWriteFormatElement(writer, BAD_CAST "num", "%d", sqlite3_column_int(stmt,0));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "module", "%d", sqlite3_column_int(stmt,1));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "operation", "%s", sqlite3_column_text(stmt,2));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "op_params", "%s", dt_style_encode(stmt,3));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "enabled", "%d", sqlite3_column_int(stmt,4));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "blendop_params", "%s", dt_style_encode(stmt,5));
xmlTextWriterWriteFormatElement(writer, BAD_CAST "blendop_version", "%d", sqlite3_column_int(stmt,6));
xmlTextWriterEndElement(writer);
}
sqlite3_finalize(stmt);
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
dt_control_log(_("style %s was sucessfully saved"),style_name);
}
/** Invoked when camera error appear */
static void _camera_error_callback(const dt_camera_t *camera, dt_camera_error_t error, void *user_data)
{
dt_control_log(_("connection with camera lost, exiting tethering mode"));
g_idle_add(_bailout_of_tethering, user_data);
}
/** Initializes a new pwstorage context. */
const dt_pwstorage_t *dt_pwstorage_new()
{
/* add password storage capabilities */
#ifdef HAVE_LIBSECRET
dt_capabilities_add("libsecret");
#endif
#ifdef HAVE_KWALLET
dt_capabilities_add("kwallet");
#endif
dt_pwstorage_t *pwstorage = g_malloc(sizeof(dt_pwstorage_t));
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] Creating new context %p\n", pwstorage);
if(pwstorage == NULL) return NULL;
gchar *_backend_str = dt_conf_get_string("plugins/pwstorage/pwstorage_backend");
gint _backend = PW_STORAGE_BACKEND_NONE;
if(strcmp(_backend_str, "auto") == 0)
{
const gchar *desktop = getenv("XDG_CURRENT_DESKTOP");
if(g_strcmp0(desktop, "KDE") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
else if(g_strcmp0(desktop, "GNOME") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
else if(g_strcmp0(desktop, "Unity") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
else if(g_strcmp0(desktop, "XFCE") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] autodetected storage backend.\n");
}
else if(strcmp(_backend_str, "none") == 0)
_backend = PW_STORAGE_BACKEND_NONE;
#ifdef HAVE_LIBSECRET
else if(strcmp(_backend_str, "libsecret") == 0)
_backend = PW_STORAGE_BACKEND_LIBSECRET;
#endif
#ifdef HAVE_KWALLET
else if(strcmp(_backend_str, "kwallet") == 0)
_backend = PW_STORAGE_BACKEND_KWALLET;
#endif
else if(strcmp(_backend_str, "gnome keyring") == 0)
{
fprintf(stderr, "[pwstorage_new] GNOME Keyring backend is no longer supported.\n");
dt_control_log(_("GNOME Keyring backend is no longer supported. configure a different one"));
_backend = PW_STORAGE_BACKEND_NONE;
}
g_free(_backend_str);
switch(_backend)
{
default:
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] unknown storage backend. Using none.\n");
case PW_STORAGE_BACKEND_NONE:
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
pwstorage->backend_context = NULL;
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] no storage backend. not storing username/password. "
"please change in preferences, core tab.\n");
break;
case PW_STORAGE_BACKEND_LIBSECRET:
#ifdef HAVE_LIBSECRET
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] using libsecret backend for username/password storage");
pwstorage->backend_context = (void *)dt_pwstorage_libsecret_new();
if(pwstorage->backend_context == NULL)
{
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] error starting libsecret. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
{
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_LIBSECRET;
}
break;
#else
dt_print(DT_DEBUG_PWSTORAGE,
"[pwstorage_new] libsecret backend not available. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
#endif
case PW_STORAGE_BACKEND_KWALLET:
#ifdef HAVE_KWALLET
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] using kwallet backend for username/password storage");
pwstorage->backend_context = (void *)dt_pwstorage_kwallet_new();
if(pwstorage->backend_context == NULL)
{
dt_print(DT_DEBUG_PWSTORAGE, "[pwstorage_new] error starting kwallet. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
}
else
{
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_KWALLET;
}
dt_print(DT_DEBUG_PWSTORAGE, " done.\n");
break;
#else
dt_print(DT_DEBUG_PWSTORAGE,
"[pwstorage_new] kwallet backend not available. using no storage backend.\n");
pwstorage->backend_context = NULL;
pwstorage->pw_storage_backend = PW_STORAGE_BACKEND_NONE;
#endif
}
switch(pwstorage->pw_storage_backend)
{
case PW_STORAGE_BACKEND_NONE:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "none");
break;
case PW_STORAGE_BACKEND_LIBSECRET:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "libsecret");
break;
case PW_STORAGE_BACKEND_KWALLET:
dt_conf_set_string("plugins/pwstorage/pwstorage_backend", "kwallet");
break;
}
return pwstorage;
}
void dt_dev_read_history(dt_develop_t *dev)
{
if(!dev->image_storage.id) return;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid, num, module, operation, op_params, enabled, blendop_params, blendop_version from history where imgid = ?1 order by num", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dev->image_storage.id);
dev->history_end = 0;
while(sqlite3_step(stmt) == SQLITE_ROW)
{
// db record:
// 0-img, 1-num, 2-module_instance, 3-operation char, 4-params blob, 5-enabled, 6-blend_params, 7-blendop_version
dt_dev_history_item_t *hist = (dt_dev_history_item_t *)malloc(sizeof(dt_dev_history_item_t));
hist->enabled = sqlite3_column_int(stmt, 5);
GList *modules = dev->iop;
const char *opname = (const char *)sqlite3_column_text(stmt, 3);
if(!opname)
{
fprintf(stderr, "[dev_read_history] database history for image `%s' seems to be corrupted!\n", dev->image_storage.filename);
free(hist);
continue;
}
hist->module = NULL;
while(opname && modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)modules->data;
if(!strcmp(module->op, opname))
{
hist->module = module;
break;
}
modules = g_list_next(modules);
}
if(!hist->module)
{
fprintf(stderr, "[dev_read_history] the module `%s' requested by image `%s' is not installed on this computer!\n", opname, dev->image_storage.filename);
free(hist);
continue;
}
int modversion = sqlite3_column_int(stmt, 2);
assert(strcmp((char *)sqlite3_column_text(stmt, 3), hist->module->op) == 0);
hist->params = malloc(hist->module->params_size);
hist->blend_params = malloc(sizeof(dt_develop_blend_params_t));
if(hist->module->version() != modversion || hist->module->params_size != sqlite3_column_bytes(stmt, 4) ||
strcmp((char *)sqlite3_column_text(stmt, 3), hist->module->op))
{
if(!hist->module->legacy_params ||
hist->module->legacy_params(hist->module, sqlite3_column_blob(stmt, 4), labs(modversion), hist->params, labs(hist->module->version())))
{
free(hist->params);
free(hist->blend_params);
fprintf(stderr, "[dev_read_history] module `%s' version mismatch: history is %d, dt %d.\n", hist->module->op, modversion, hist->module->version());
const char *fname = dev->image_storage.filename + strlen(dev->image_storage.filename);
while(fname > dev->image_storage.filename && *fname != '/') fname --;
if(fname > dev->image_storage.filename) fname++;
dt_control_log(_("%s: module `%s' version mismatch: %d != %d"), fname, hist->module->op, hist->module->version(), modversion);
free(hist);
continue;
}
}
else
{
memcpy(hist->params, sqlite3_column_blob(stmt, 4), hist->module->params_size);
}
const void *blendop_params = sqlite3_column_blob(stmt, 6);
int bl_length = sqlite3_column_bytes(stmt, 6);
int blendop_version = sqlite3_column_int(stmt, 7);
if (blendop_params && (blendop_version == dt_develop_blend_version()) && (bl_length == sizeof(dt_develop_blend_params_t)))
{
memcpy(hist->blend_params, blendop_params, sizeof(dt_develop_blend_params_t));
}
else if (blendop_params && dt_develop_blend_legacy_params(hist->module, blendop_params, blendop_version, hist->blend_params, dt_develop_blend_version(), bl_length) == 0)
{
// do nothing
}
else
{
memcpy(hist->blend_params, hist->module->default_blendop_params, sizeof(dt_develop_blend_params_t));
}
// memcpy(hist->module->params, hist->params, hist->module->params_size);
// hist->module->enabled = hist->enabled;
// printf("[dev read history] img %d number %d for operation %d - %s params %f %f\n", sqlite3_column_int(stmt, 0), sqlite3_column_int(stmt, 1), instance, hist->module->op, *(float *)hist->params, *(((float*)hist->params)+1));
dev->history = g_list_append(dev->history, hist);
dev->history_end ++;
}
if(dev->gui_attached)
{
dev->pipe->changed |= DT_DEV_PIPE_SYNCH;
dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH; // again, fixed topology for now.
dt_dev_invalidate_all(dev);
/* signal history changed */
dt_control_signal_raise(darktable.signals,DT_SIGNAL_DEVELOP_HISTORY_CHANGE);
}
sqlite3_finalize (stmt);
}
void dt_lightroom_import(int imgid, dt_develop_t *dev, gboolean iauto)
{
gboolean refresh_needed = FALSE;
char imported[256] = { 0 };
// Get full pathname
char *pathname = dt_get_lightroom_xmp(imgid);
if(!pathname)
{
if(!iauto) dt_control_log(_("cannot find lightroom XMP!"));
return;
}
// Load LR xmp
xmlDocPtr doc;
xmlNodePtr entryNode;
// Parse xml document
doc = xmlParseEntity(pathname);
if(doc == NULL)
{
g_free(pathname);
return;
}
// Enter first node, xmpmeta
entryNode = xmlDocGetRootElement(doc);
if(entryNode == NULL)
{
g_free(pathname);
xmlFreeDoc(doc);
return;
}
if(xmlStrcmp(entryNode->name, (const xmlChar *)"xmpmeta"))
{
if(!iauto) dt_control_log(_("`%s' not a lightroom XMP!"), pathname);
g_free(pathname);
return;
}
// Check that this is really a Lightroom document
xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
if(xpathCtx == NULL)
{
g_free(pathname);
xmlFreeDoc(doc);
return;
}
xmlXPathRegisterNs(xpathCtx, BAD_CAST "stEvt", BAD_CAST "http://ns.adobe.com/xap/1.0/sType/ResourceEvent#");
xmlXPathObjectPtr xpathObj = xmlXPathEvalExpression((const xmlChar *)"//@stEvt:softwareAgent", xpathCtx);
if(xpathObj == NULL)
{
if(!iauto) dt_control_log(_("`%s' not a lightroom XMP!"), pathname);
xmlXPathFreeContext(xpathCtx);
g_free(pathname);
xmlFreeDoc(doc);
return;
}
xmlNodeSetPtr xnodes = xpathObj->nodesetval;
if(xnodes != NULL && xnodes->nodeNr > 0)
{
xmlNodePtr xnode = xnodes->nodeTab[0];
xmlChar *value = xmlNodeListGetString(doc, xnode->xmlChildrenNode, 1);
if(!strstr((char *)value, "Lightroom"))
{
xmlXPathFreeContext(xpathCtx);
xmlXPathFreeObject(xpathObj);
xmlFreeDoc(doc);
xmlFree(value);
if(!iauto) dt_control_log(_("`%s' not a lightroom XMP!"), pathname);
g_free(pathname);
return;
}
xmlFree(value);
}
else
{
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
if(!iauto) dt_control_log(_("`%s' not a lightroom XMP!"), pathname);
g_free(pathname);
return;
}
xmlXPathFreeObject(xpathObj);
xmlXPathFreeContext(xpathCtx);
// Go safely to Description node
if(entryNode) entryNode = entryNode->xmlChildrenNode;
if(entryNode) entryNode = entryNode->next;
if(entryNode) entryNode = entryNode->xmlChildrenNode;
if(entryNode) entryNode = entryNode->next;
if(!entryNode || xmlStrcmp(entryNode->name, (const xmlChar *)"Description"))
{
if(!iauto) dt_control_log(_("`%s' not a lightroom XMP!"), pathname);
g_free(pathname);
return;
}
g_free(pathname);
// Look for attributes in the Description
dt_iop_clipping_params_t pc;
memset(&pc, 0, sizeof(pc));
gboolean has_crop = FALSE;
dt_iop_flip_params_t pf;
memset(&pf, 0, sizeof(pf));
gboolean has_flip = FALSE;
dt_iop_exposure_params_t pe;
memset(&pe, 0, sizeof(pe));
gboolean has_exposure = FALSE;
dt_iop_vignette_params_t pv;
memset(&pv, 0, sizeof(pv));
gboolean has_vignette = FALSE;
dt_iop_grain_params_t pg;
memset(&pg, 0, sizeof(pg));
gboolean has_grain = FALSE;
dt_iop_spots_params_t ps;
memset(&ps, 0, sizeof(ps));
gboolean has_spots = FALSE;
typedef enum lr_curve_kind_t
{
linear = 0,
medium_contrast = 1,
string_contrast = 2,
custom = 3
} lr_curve_kind_t;
#define MAX_PTS 20
dt_iop_tonecurve_params_t ptc;
memset(&ptc, 0, sizeof(ptc));
int ptc_value[4] = { 0, 0, 0, 0 };
float ptc_split[3] = { 0.0, 0.0, 0.0 };
lr_curve_kind_t curve_kind = linear;
int curve_pts[MAX_PTS][2];
int n_pts = 0;
dt_iop_colorzones_params_t pcz;
memset(&pcz, 0, sizeof(pcz));
gboolean has_colorzones = FALSE;
dt_iop_splittoning_params_t pst;
memset(&pst, 0, sizeof(pst));
gboolean has_splittoning = FALSE;
dt_iop_bilat_params_t pbl;
memset(&pbl, 0, sizeof(pbl));
gboolean has_bilat = FALSE;
gboolean has_tags = FALSE;
int rating = 0;
gboolean has_rating = FALSE;
gdouble lat = 0, lon = 0;
gboolean has_gps = FALSE;
int color = 0;
gboolean has_colorlabel = FALSE;
float fratio = 0; // factor ratio image
float crop_roundness = 0; // from lightroom
int n_import = 0; // number of iop imported
const float hfactor = 3.0 / 9.0; // hue factor adjustment (use 3 out of 9 boxes in colorzones)
const float lfactor = 4.0 / 9.0; // lightness factor adjustment (use 4 out of 9 boxes in colorzones)
int iwidth = 0, iheight = 0; // image width / height
int orientation = 1;
xmlAttr *attribute = entryNode->properties;
while(attribute && attribute->name && attribute->children)
{
xmlChar *value = xmlNodeListGetString(entryNode->doc, attribute->children, 1);
if(!xmlStrcmp(attribute->name, (const xmlChar *)"CropTop"))
pc.cy = g_ascii_strtod((char *)value, NULL);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"CropRight"))
pc.cw = g_ascii_strtod((char *)value, NULL);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"CropLeft"))
pc.cx = g_ascii_strtod((char *)value, NULL);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"CropBottom"))
pc.ch = g_ascii_strtod((char *)value, NULL);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"CropAngle"))
pc.angle = -g_ascii_strtod((char *)value, NULL);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ImageWidth"))
iwidth = atoi((char *)value);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ImageLength"))
iheight = atoi((char *)value);
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Orientation"))
{
orientation = atoi((char *)value);
if(dev != NULL && ((dev->image_storage.orientation == 6 && orientation != 6)
|| (dev->image_storage.orientation == 5 && orientation != 8)
|| (dev->image_storage.orientation == 0 && orientation != 1)))
has_flip = TRUE;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HasCrop"))
{
if(!xmlStrcmp(value, (const xmlChar *)"True")) has_crop = TRUE;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Blacks2012"))
{
int v = atoi((char *)value);
if(v != 0)
{
has_exposure = TRUE;
pe.black = lr2dt_blacks((float)v);
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Exposure2012"))
{
float v = g_ascii_strtod((char *)value, NULL);
if(v != 0.0)
{
has_exposure = TRUE;
pe.exposure = lr2dt_exposure(v);
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"PostCropVignetteAmount"))
{
int v = atoi((char *)value);
if(v != 0)
{
has_vignette = TRUE;
pv.brightness = lr2dt_vignette_gain((float)v);
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"PostCropVignetteMidpoint"))
{
int v = atoi((char *)value);
pv.scale = lr2dt_vignette_midpoint((float)v);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"PostCropVignetteStyle"))
{
int v = atoi((char *)value);
if(v == 1) // Highlight Priority
pv.saturation = -0.300;
else // Color Priority & Paint Overlay
pv.saturation = -0.200;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"PostCropVignetteFeather"))
{
int v = atoi((char *)value);
if(v != 0) pv.falloff_scale = (float)v;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"PostCropVignetteRoundness"))
{
int v = atoi((char *)value);
crop_roundness = (float)v;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"GrainAmount"))
{
int v = atoi((char *)value);
if(v != 0)
{
has_grain = TRUE;
pg.strength = lr2dt_grain_amount((float)v);
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"GrainFrequency"))
{
int v = atoi((char *)value);
if(v != 0) pg.scale = lr2dt_grain_frequency((float)v);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricShadows"))
{
ptc_value[0] = atoi((char *)value);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricDarks"))
{
ptc_value[1] = atoi((char *)value);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricLights"))
{
ptc_value[2] = atoi((char *)value);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricHighlights"))
{
ptc_value[3] = atoi((char *)value);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricShadowSplit"))
{
ptc_split[0] = g_ascii_strtod((char *)value, NULL) / 100.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricMidtoneSplit"))
{
ptc_split[1] = g_ascii_strtod((char *)value, NULL) / 100.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ParametricHighlightSplit"))
{
ptc_split[2] = g_ascii_strtod((char *)value, NULL) / 100.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"ToneCurveName2012"))
{
if(!xmlStrcmp(value, (const xmlChar *)"Linear"))
curve_kind = linear;
else if(!xmlStrcmp(value, (const xmlChar *)"Medium Contrast"))
curve_kind = medium_contrast;
else if(!xmlStrcmp(value, (const xmlChar *)"Strong Contrast"))
curve_kind = medium_contrast;
else if(!xmlStrcmp(value, (const xmlChar *)"Custom"))
curve_kind = custom;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentRed"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][0] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentOrange"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][1] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentYellow"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][2] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentGreen"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][3] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentAqua"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][4] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentBlue"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][5] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentPurple"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][6] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SaturationAdjustmentMagenta"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[1][7] = 0.5 + (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentRed"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][0] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentOrange"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][1] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentYellow"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][2] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentGreen"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][3] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentAqua"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][4] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentBlue"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][5] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentPurple"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][6] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"LuminanceAdjustmentMagenta"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[0][7] = 0.5 + lfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentRed"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][0] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentOrange"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][1] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentYellow"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][2] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentGreen"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][3] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentAqua"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][4] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentBlue"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][5] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentPurple"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][6] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"HueAdjustmentMagenta"))
{
int v = atoi((char *)value);
if(v != 0) has_colorzones = TRUE;
pcz.equalizer_y[2][7] = 0.5 + hfactor * (float)v / 200.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SplitToningShadowHue"))
{
int v = atoi((char *)value);
if(v != 0) has_splittoning = TRUE;
pst.shadow_hue = (float)v / 255.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SplitToningShadowSaturation"))
{
int v = atoi((char *)value);
if(v != 0) has_splittoning = TRUE;
pst.shadow_saturation = (float)v / 100.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SplitToningHighlightHue"))
{
int v = atoi((char *)value);
if(v != 0) has_splittoning = TRUE;
pst.highlight_hue = (float)v / 255.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SplitToningHighlightSaturation"))
{
int v = atoi((char *)value);
if(v != 0) has_splittoning = TRUE;
pst.highlight_saturation = (float)v / 100.0;
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"SplitToningBalance"))
{
float v = g_ascii_strtod((char *)value, NULL);
pst.balance = lr2dt_splittoning_balance(v);
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Clarity2012"))
{
int v = atoi((char *)value);
if(v != 0)
{
has_bilat = TRUE;
pbl.detail = lr2dt_clarity((float)v);
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Rating"))
{
int v = atoi((char *)value);
if(v != 0)
{
rating = v;
has_rating = TRUE;
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"GPSLatitude"))
{
int deg;
double msec;
char d;
if(sscanf((const char *)value, "%d,%lf%c", °, &msec, &d))
{
lat = deg + msec / 60.0;
if(d == 'S') lat = -lat;
has_gps = TRUE;
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"GPSLongitude"))
{
int deg;
double msec;
char d;
if(sscanf((const char *)value, "%d,%lf%c", °, &msec, &d))
{
lon = deg + msec / 60.0;
if(d == 'W') lon = -lon;
has_gps = TRUE;
}
}
else if(!xmlStrcmp(attribute->name, (const xmlChar *)"Label"))
{
for(int i = 0; value[i]; i++) value[i] = tolower(value[i]);
if(!strcmp((char *)value, _("red")))
color = 0;
else if(!strcmp((char *)value, _("yellow")))
color = 1;
else if(!strcmp((char *)value, _("green")))
color = 2;
else if(!strcmp((char *)value, _("blue")))
color = 3;
else
// just an else here to catch all other cases as on lightroom one can
// change the names of labels. So purple and the user's defined labels
// will be mapped to purple on darktable.
color = 4;
has_colorlabel = TRUE;
}
xmlFree(value);
attribute = attribute->next;
}
// Look for tags (subject/Bag/* and RetouchInfo/seq/*)
entryNode = entryNode->xmlChildrenNode;
if(entryNode) entryNode = entryNode->next;
while(entryNode)
{
if(dev == NULL && (!xmlStrcmp(entryNode->name, (const xmlChar *)"subject")
|| !xmlStrcmp(entryNode->name, (const xmlChar *)"hierarchicalSubject")))
{
xmlNodePtr tagNode = entryNode;
tagNode = tagNode->xmlChildrenNode;
tagNode = tagNode->next;
tagNode = tagNode->xmlChildrenNode;
tagNode = tagNode->next;
while(tagNode)
{
if(!xmlStrcmp(tagNode->name, (const xmlChar *)"li"))
{
xmlChar *value = xmlNodeListGetString(doc, tagNode->xmlChildrenNode, 1);
guint tagid = 0;
if(!dt_tag_exists((char *)value, &tagid)) dt_tag_new((char *)value, &tagid);
dt_tag_attach(tagid, imgid);
has_tags = TRUE;
xmlFree(value);
}
tagNode = tagNode->next;
}
}
else if(dev != NULL && !xmlStrcmp(entryNode->name, (const xmlChar *)"RetouchInfo"))
{
xmlNodePtr riNode = entryNode;
riNode = riNode->xmlChildrenNode;
riNode = riNode->next;
riNode = riNode->xmlChildrenNode;
riNode = riNode->next;
while(riNode)
{
if(!xmlStrcmp(riNode->name, (const xmlChar *)"li"))
{
xmlChar *value = xmlNodeListGetString(doc, riNode->xmlChildrenNode, 1);
spot_t *p = &ps.spot[ps.num_spots];
if(sscanf((const char *)value, "centerX = %f, centerY = %f, radius = %f, sourceState = %*[a-zA-Z], "
"sourceX = %f, sourceY = %f",
&(p->x), &(p->y), &(p->radius), &(p->xc), &(p->yc)))
{
ps.num_spots++;
has_spots = TRUE;
}
xmlFree(value);
}
if(ps.num_spots == MAX_SPOTS) break;
riNode = riNode->next;
}
}
else if(dev != NULL && !xmlStrcmp(entryNode->name, (const xmlChar *)"ToneCurvePV2012"))
{
xmlNodePtr tcNode = entryNode;
tcNode = tcNode->xmlChildrenNode;
tcNode = tcNode->next;
tcNode = tcNode->xmlChildrenNode;
tcNode = tcNode->next;
while(tcNode)
{
if(!xmlStrcmp(tcNode->name, (const xmlChar *)"li"))
{
xmlChar *value = xmlNodeListGetString(doc, tcNode->xmlChildrenNode, 1);
if(sscanf((const char *)value, "%d, %d", &(curve_pts[n_pts][0]), &(curve_pts[n_pts][1]))) n_pts++;
xmlFree(value);
}
if(n_pts == MAX_PTS) break;
tcNode = tcNode->next;
}
}
entryNode = entryNode->next;
}
xmlFreeDoc(doc);
// Integrates into the history all the imported iop
if(dev != NULL && dt_image_is_raw(&dev->image_storage))
{
// set colorin to cmatrix which is the default from Adobe (so closer to what Lightroom does)
dt_iop_colorin_params_t pci = (dt_iop_colorin_params_t){ "cmatrix", DT_INTENT_PERCEPTUAL };
dt_add_hist(imgid, "colorin", (dt_iop_params_t *)&pci, sizeof(dt_iop_colorin_params_t), imported,
sizeof(imported), LRDT_COLORIN_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_crop)
{
pc.k_sym = 0;
pc.k_apply = 0;
pc.crop_auto = 0;
pc.k_h = pc.k_v = 0;
pc.k_type = 0;
pc.kxa = pc.kxd = 0.2f;
pc.kxc = pc.kxb = 0.8f;
pc.kya = pc.kyb = 0.2f;
pc.kyc = pc.kyd = 0.8f;
float tmp;
if(has_crop)
{
// adjust crop data according to the rotation
switch(dev->image_storage.orientation)
{
case 5: // portrait - counter-clockwise
tmp = pc.ch;
pc.ch = 1.0 - pc.cx;
pc.cx = pc.cy;
pc.cy = 1.0 - pc.cw;
pc.cw = tmp;
break;
case 6: // portrait - clockwise
tmp = pc.ch;
pc.ch = pc.cw;
pc.cw = 1.0 - pc.cy;
pc.cy = pc.cx;
pc.cx = 1.0 - tmp;
break;
default:
break;
}
if(pc.angle != 0)
{
const float rangle = -pc.angle * (3.141592 / 180);
float x, y;
// do the rotation (rangle) using center of image (0.5, 0.5)
x = pc.cx - 0.5;
y = 0.5 - pc.cy;
pc.cx = 0.5 + x * cos(rangle) - y * sin(rangle);
pc.cy = 0.5 - (x * sin(rangle) + y * cos(rangle));
x = pc.cw - 0.5;
y = 0.5 - pc.ch;
pc.cw = 0.5 + x * cos(rangle) - y * sin(rangle);
pc.ch = 0.5 - (x * sin(rangle) + y * cos(rangle));
}
}
else
{
pc.angle = 0;
pc.cx = 0;
pc.cy = 0;
pc.cw = 1;
pc.ch = 1;
}
fratio = (pc.cw - pc.cx) / (pc.ch - pc.cy);
dt_add_hist(imgid, "clipping", (dt_iop_params_t *)&pc, sizeof(dt_iop_clipping_params_t), imported,
sizeof(imported), LRDT_CLIPPING_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_flip)
{
pf.orientation = 0;
if(dev->image_storage.orientation == 5)
// portrait
switch(orientation)
{
case 8:
pf.orientation = 0;
break;
case 3:
pf.orientation = 5;
break;
case 6:
pf.orientation = 3;
break;
case 1:
pf.orientation = 6;
break;
// with horizontal flip
case 7:
pf.orientation = 1;
break;
case 2:
pf.orientation = 4;
break;
case 5:
pf.orientation = 2;
break;
case 4:
pf.orientation = 7;
break;
}
else if(dev->image_storage.orientation == 6)
// portrait
switch(orientation)
{
case 8:
pf.orientation = 3;
break;
case 3:
pf.orientation = 6;
break;
case 6:
pf.orientation = 0;
break;
case 1:
pf.orientation = 5;
break;
// with horizontal flip
case 7:
pf.orientation = 2;
break;
case 2:
pf.orientation = 7;
break;
case 5:
pf.orientation = 1;
break;
case 4:
pf.orientation = 4;
break;
}
else
// landscape
switch(orientation)
{
case 8:
pf.orientation = 5;
break;
case 3:
pf.orientation = 3;
break;
case 6:
pf.orientation = 6;
break;
case 1:
pf.orientation = 0;
break;
// with horizontal flip
case 7:
pf.orientation = 7;
break;
case 2:
pf.orientation = 1;
break;
case 5:
pf.orientation = 4;
break;
case 4:
pf.orientation = 2;
break;
}
dt_add_hist(imgid, "flip", (dt_iop_params_t *)&pf, sizeof(dt_iop_flip_params_t), imported,
sizeof(imported), LRDT_FLIP_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_exposure)
{
dt_add_hist(imgid, "exposure", (dt_iop_params_t *)&pe, sizeof(dt_iop_exposure_params_t), imported,
sizeof(imported), LRDT_EXPOSURE_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_grain)
{
pg.channel = 0;
dt_add_hist(imgid, "grain", (dt_iop_params_t *)&pg, sizeof(dt_iop_grain_params_t), imported,
sizeof(imported), LRDT_GRAIN_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_vignette)
{
const float base_ratio = 1.325 / 1.5;
pv.autoratio = FALSE;
pv.dithering = DITHER_8BIT;
pv.center.x = 0.0;
pv.center.y = 0.0;
pv.shape = 1.0;
// defensive code, should not happen, but just in case future Lr version
// has not ImageWidth/ImageLength XML tag.
if(iwidth == 0 || iheight == 0)
pv.whratio = base_ratio;
else
pv.whratio = base_ratio * ((float)iwidth / (float)iheight);
if(has_crop) pv.whratio = pv.whratio * fratio;
// Adjust scale and ratio based on the roundness. On Lightroom changing
// the roundness change the width and the height of the vignette.
if(crop_roundness > 0)
{
float newratio = pv.whratio - (pv.whratio - 1) * (crop_roundness / 100.0);
float dscale = (1 - (newratio / pv.whratio)) / 2.0;
pv.scale -= dscale * 100.0;
pv.whratio = newratio;
}
dt_add_hist(imgid, "vignette", (dt_iop_params_t *)&pv, sizeof(dt_iop_vignette_params_t), imported,
sizeof(imported), LRDT_VIGNETTE_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_spots)
{
// Check for orientation, rotate when in portrait mode
if(orientation > 4)
for(int k = 0; k < ps.num_spots; k++)
{
float tmp = ps.spot[k].y;
ps.spot[k].y = 1.0 - ps.spot[k].x;
ps.spot[k].x = tmp;
tmp = ps.spot[k].yc;
ps.spot[k].yc = 1.0 - ps.spot[k].xc;
ps.spot[k].xc = tmp;
}
dt_add_hist(imgid, "spots", (dt_iop_params_t *)&ps, sizeof(dt_iop_spots_params_t), imported,
sizeof(imported), LRDT_SPOTS_VERSION, &n_import);
refresh_needed = TRUE;
}
if(curve_kind != linear || ptc_value[0] != 0 || ptc_value[1] != 0 || ptc_value[2] != 0 || ptc_value[3] != 0)
{
ptc.tonecurve_nodes[ch_L] = 6;
ptc.tonecurve_nodes[ch_a] = 7;
ptc.tonecurve_nodes[ch_b] = 7;
ptc.tonecurve_type[ch_L] = CUBIC_SPLINE;
ptc.tonecurve_type[ch_a] = CUBIC_SPLINE;
ptc.tonecurve_type[ch_b] = CUBIC_SPLINE;
ptc.tonecurve_autoscale_ab = 1;
ptc.tonecurve_preset = 0;
float linear_ab[7] = { 0.0, 0.08, 0.3, 0.5, 0.7, 0.92, 1.0 };
// linear a, b curves
for(int k = 0; k < 7; k++) ptc.tonecurve[ch_a][k].x = linear_ab[k];
for(int k = 0; k < 7; k++) ptc.tonecurve[ch_a][k].y = linear_ab[k];
for(int k = 0; k < 7; k++) ptc.tonecurve[ch_b][k].x = linear_ab[k];
for(int k = 0; k < 7; k++) ptc.tonecurve[ch_b][k].y = linear_ab[k];
// Set the base tonecurve
if(curve_kind == linear)
{
ptc.tonecurve[ch_L][0].x = 0.0;
ptc.tonecurve[ch_L][0].y = 0.0;
ptc.tonecurve[ch_L][1].x = ptc_split[0] / 2.0;
ptc.tonecurve[ch_L][1].y = ptc_split[0] / 2.0;
ptc.tonecurve[ch_L][2].x = ptc_split[1] - (ptc_split[1] - ptc_split[0]) / 2.0;
ptc.tonecurve[ch_L][2].y = ptc_split[1] - (ptc_split[1] - ptc_split[0]) / 2.0;
ptc.tonecurve[ch_L][3].x = ptc_split[1] + (ptc_split[2] - ptc_split[1]) / 2.0;
ptc.tonecurve[ch_L][3].y = ptc_split[1] + (ptc_split[2] - ptc_split[1]) / 2.0;
ptc.tonecurve[ch_L][4].x = ptc_split[2] + (1.0 - ptc_split[2]) / 2.0;
ptc.tonecurve[ch_L][4].y = ptc_split[2] + (1.0 - ptc_split[2]) / 2.0;
ptc.tonecurve[ch_L][5].x = 1.0;
ptc.tonecurve[ch_L][5].y = 1.0;
}
else
{
for(int k = 0; k < 6; k++)
{
ptc.tonecurve[ch_L][k].x = curve_pts[k][0] / 255.0;
ptc.tonecurve[ch_L][k].y = curve_pts[k][1] / 255.0;
}
}
if(curve_kind != custom)
{
// set shadows/darks/lights/highlight adjustments
ptc.tonecurve[ch_L][1].y += ptc.tonecurve[ch_L][1].y * ((float)ptc_value[0] / 100.0);
ptc.tonecurve[ch_L][2].y += ptc.tonecurve[ch_L][1].y * ((float)ptc_value[1] / 100.0);
ptc.tonecurve[ch_L][3].y += ptc.tonecurve[ch_L][1].y * ((float)ptc_value[2] / 100.0);
ptc.tonecurve[ch_L][4].y += ptc.tonecurve[ch_L][1].y * ((float)ptc_value[3] / 100.0);
if(ptc.tonecurve[ch_L][1].y > ptc.tonecurve[ch_L][2].y)
ptc.tonecurve[ch_L][1].y = ptc.tonecurve[ch_L][2].y;
if(ptc.tonecurve[ch_L][3].y > ptc.tonecurve[ch_L][4].y)
ptc.tonecurve[ch_L][4].y = ptc.tonecurve[ch_L][3].y;
}
dt_add_hist(imgid, "tonecurve", (dt_iop_params_t *)&ptc, sizeof(dt_iop_tonecurve_params_t), imported,
sizeof(imported), LRDT_TONECURVE_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_colorzones)
{
pcz.channel = DT_IOP_COLORZONES_h;
for(int i = 0; i < 3; i++)
for(int k = 0; k < 8; k++) pcz.equalizer_x[i][k] = k / (DT_IOP_COLORZONES_BANDS - 1.0);
dt_add_hist(imgid, "colorzones", (dt_iop_params_t *)&pcz, sizeof(dt_iop_colorzones_params_t), imported,
sizeof(imported), LRDT_COLORZONES_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_splittoning)
{
pst.compress = 50.0;
dt_add_hist(imgid, "splittoning", (dt_iop_params_t *)&pst, sizeof(dt_iop_splittoning_params_t), imported,
sizeof(imported), LRDT_SPLITTONING_VERSION, &n_import);
refresh_needed = TRUE;
}
if(dev != NULL && has_bilat)
{
pbl.sigma_r = 100.0;
pbl.sigma_s = 100.0;
dt_add_hist(imgid, "bilat", (dt_iop_params_t *)&pbl, sizeof(dt_iop_bilat_params_t), imported,
sizeof(imported), LRDT_BILAT_VERSION, &n_import);
refresh_needed = TRUE;
}
if(has_tags)
{
if(imported[0]) g_strlcat(imported, ", ", sizeof(imported));
g_strlcat(imported, _("tags"), sizeof(imported));
n_import++;
}
if(dev == NULL && has_rating)
{
dt_ratings_apply_to_image(imgid, rating);
if(imported[0]) g_strlcat(imported, ", ", sizeof(imported));
g_strlcat(imported, _("rating"), sizeof(imported));
n_import++;
}
if(dev == NULL && has_gps)
{
dt_image_set_location(imgid, lon, lat);
if(imported[0]) g_strlcat(imported, ", ", sizeof(imported));
g_strlcat(imported, _("geotagging"), sizeof(imported));
n_import++;
}
if(dev == NULL && has_colorlabel)
{
dt_colorlabels_set_label(imgid, color);
if(imported[0]) g_strlcat(imported, ", ", sizeof(imported));
g_strlcat(imported, _("color label"), sizeof(imported));
n_import++;
}
if(dev != NULL && refresh_needed && dev->gui_attached)
{
dt_control_log(ngettext("%s has been imported", "%s have been imported", n_import), imported);
if(!iauto)
{
/* signal history changed */
dt_dev_reload_history_items(dev);
dt_dev_modulegroups_set(darktable.develop, dt_dev_modulegroups_get(darktable.develop));
/* update xmp file */
dt_image_synch_xmp(imgid);
dt_control_signal_raise(darktable.signals, DT_SIGNAL_DEVELOP_HISTORY_CHANGE);
}
}
}
// internal function: to avoid exif blob reading + 8-bit byteorder flag + high-quality override
int dt_imageio_export_with_flags(const uint32_t imgid, const char *filename,
dt_imageio_module_format_t *format, dt_imageio_module_data_t *format_params,
const int32_t ignore_exif, const int32_t display_byteorder,
const gboolean high_quality, const gboolean upscale, const int32_t thumbnail_export,
const char *filter, const gboolean copy_metadata,
dt_imageio_module_storage_t *storage,
dt_imageio_module_data_t *storage_params, int num, int total)
{
dt_develop_t dev;
dt_dev_init(&dev, 0);
dt_dev_load_image(&dev, imgid);
const int buf_is_downscaled
= (thumbnail_export && dt_conf_get_bool("plugins/lighttable/low_quality_thumbnails"));
dt_mipmap_buffer_t buf;
if(buf_is_downscaled)
dt_mipmap_cache_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_F, DT_MIPMAP_BLOCKING, 'r');
else
dt_mipmap_cache_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');
const dt_image_t *img = &dev.image_storage;
if(!buf.buf || !buf.width || !buf.height)
{
fprintf(stderr, "allocation failed???\n");
dt_control_log(_("image `%s' is not available!"), img->filename);
goto error_early;
}
const int wd = img->width;
const int ht = img->height;
const float max_scale = upscale ? 100.0 : 1.0;
int res = 0;
dt_times_t start;
dt_get_times(&start);
dt_dev_pixelpipe_t pipe;
res = thumbnail_export ? dt_dev_pixelpipe_init_thumbnail(&pipe, wd, ht)
: dt_dev_pixelpipe_init_export(&pipe, wd, ht, format->levels(format_params));
if(!res)
{
dt_control_log(
_("failed to allocate memory for %s, please lower the threads used for export or buy more memory."),
thumbnail_export ? C_("noun", "thumbnail export") : C_("noun", "export"));
goto error;
}
// If a style is to be applied during export, add the iop params into the history
if(!thumbnail_export && format_params->style[0] != '\0')
{
GList *stls;
GList *modules = dev.iop;
dt_iop_module_t *m = NULL;
if((stls = dt_styles_get_item_list(format_params->style, TRUE, -1)) == 0)
{
dt_control_log(_("cannot find the style '%s' to apply during export."), format_params->style);
goto error;
}
// remove everything above history_end
GList *history = g_list_nth(dev.history, dev.history_end);
while(history)
{
GList *next = g_list_next(history);
dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(history->data);
free(hist->params);
free(hist->blend_params);
free(history->data);
dev.history = g_list_delete_link(dev.history, history);
history = next;
}
// Add each params
while(stls)
{
dt_style_item_t *s = (dt_style_item_t *)stls->data;
gboolean module_found = FALSE;
modules = dev.iop;
while(modules)
{
m = (dt_iop_module_t *)modules->data;
// since the name in the style is returned with a possible multi-name, just check the start of the
// name
if(strncmp(m->op, s->name, strlen(m->op)) == 0)
{
dt_dev_history_item_t *h = malloc(sizeof(dt_dev_history_item_t));
dt_iop_module_t *sty_module = m;
if(format_params->style_append && !(m->flags() & IOP_FLAGS_ONE_INSTANCE))
{
sty_module = dt_dev_module_duplicate(m->dev, m, 0);
if(!sty_module)
{
free(h);
goto error;
}
}
h->params = s->params;
h->blend_params = s->blendop_params;
h->enabled = s->enabled;
h->module = sty_module;
h->multi_priority = 1;
g_strlcpy(h->multi_name, "<style>", sizeof(h->multi_name));
if(m->legacy_params && (s->module_version != m->version()))
{
void *new_params = malloc(m->params_size);
m->legacy_params(m, h->params, s->module_version, new_params, labs(m->version()));
free(h->params);
h->params = new_params;
}
dev.history_end++;
dev.history = g_list_append(dev.history, h);
module_found = TRUE;
g_free(s->name);
break;
}
modules = g_list_next(modules);
}
if(!module_found) dt_style_item_free(s);
stls = g_list_next(stls);
}
g_list_free(stls);
}
dt_dev_pixelpipe_set_input(&pipe, &dev, (float *)buf.buf, buf.width, buf.height,
buf_is_downscaled ? dev.image_storage.width / (float)buf.width : 1.0f,
buf.pre_monochrome_demosaiced);
dt_dev_pixelpipe_create_nodes(&pipe, &dev);
dt_dev_pixelpipe_synch_all(&pipe, &dev);
if(filter)
{
if(!strncmp(filter, "pre:", 4)) dt_dev_pixelpipe_disable_after(&pipe, filter + 4);
if(!strncmp(filter, "post:", 5)) dt_dev_pixelpipe_disable_before(&pipe, filter + 5);
}
dt_dev_pixelpipe_get_dimensions(&pipe, &dev, pipe.iwidth, pipe.iheight, &pipe.processed_width,
&pipe.processed_height);
dt_show_times(&start, "[export] creating pixelpipe", NULL);
// find output color profile for this image:
int sRGB = 1;
int icctype = dt_conf_get_int("plugins/lighttable/export/icctype");
if(icctype == DT_COLORSPACE_SRGB)
{
sRGB = 1;
}
else if(icctype == DT_COLORSPACE_NONE)
{
GList *modules = dev.iop;
dt_iop_module_t *colorout = NULL;
while(modules)
{
colorout = (dt_iop_module_t *)modules->data;
if(colorout->get_p && strcmp(colorout->op, "colorout") == 0)
{
const dt_colorspaces_color_profile_type_t *type = colorout->get_p(colorout->params, "type");
sRGB = (!type || *type == DT_COLORSPACE_SRGB);
break; // colorout can't have > 1 instance
}
modules = g_list_next(modules);
}
}
else
{
sRGB = 0;
}
// get only once at the beginning, in case the user changes it on the way:
const gboolean high_quality_processing
= ((format_params->max_width == 0 || format_params->max_width >= pipe.processed_width)
&& (format_params->max_height == 0 || format_params->max_height >= pipe.processed_height))
? FALSE
: high_quality;
const int width = high_quality_processing ? 0 : format_params->max_width;
const int height = high_quality_processing ? 0 : format_params->max_height;
const double scalex = width > 0 ? fminf(width / (double)pipe.processed_width, max_scale) : 1.0;
const double scaley = height > 0 ? fminf(height / (double)pipe.processed_height, max_scale) : 1.0;
const double scale = fminf(scalex, scaley);
int processed_width = scale * pipe.processed_width + .5f;
int processed_height = scale * pipe.processed_height + .5f;
const int bpp = format->bpp(format_params);
dt_get_times(&start);
if(high_quality_processing)
{
/*
* if high quality processing was requested, downsampling will be done
* at the very end of the pipe (just before border and watermark)
*/
const double scalex = format_params->max_width > 0
? fminf(format_params->max_width / (double)pipe.processed_width, max_scale)
: 1.0;
const double scaley = format_params->max_height > 0
? fminf(format_params->max_height / (double)pipe.processed_height, max_scale)
: 1.0;
const double scale = fminf(scalex, scaley);
processed_width = scale * pipe.processed_width + .5f;
processed_height = scale * pipe.processed_height + .5f;
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
}
else
{
// else, downsampling will be right after demosaic
// so we need to turn temporarily disable in-pipe late downsampling iop.
GList *finalscalep = g_list_last(pipe.nodes);
dt_dev_pixelpipe_iop_t *finalscale = (dt_dev_pixelpipe_iop_t *)finalscalep->data;
while(strcmp(finalscale->module->op, "finalscale"))
{
finalscale = NULL;
finalscalep = g_list_previous(finalscalep);
if(!finalscalep) break;
finalscale = (dt_dev_pixelpipe_iop_t *)finalscalep->data;
}
if(finalscale) finalscale->enabled = 0;
// do the processing (8-bit with special treatment, to make sure we can use openmp further down):
if(bpp == 8)
dt_dev_pixelpipe_process(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
else
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
if(finalscale) finalscale->enabled = 1;
}
dt_show_times(&start, thumbnail_export ? "[dev_process_thumbnail] pixel pipeline processing"
: "[dev_process_export] pixel pipeline processing",
NULL);
uint8_t *outbuf = pipe.backbuf;
// downconversion to low-precision formats:
if(bpp == 8)
{
if(display_byteorder)
{
if(high_quality_processing)
{
const float *const inbuf = (float *)outbuf;
for(size_t k = 0; k < (size_t)processed_width * processed_height; k++)
{
// convert in place, this is unfortunately very serial..
const uint8_t r = CLAMP(inbuf[4 * k + 2] * 0xff, 0, 0xff);
const uint8_t g = CLAMP(inbuf[4 * k + 1] * 0xff, 0, 0xff);
const uint8_t b = CLAMP(inbuf[4 * k + 0] * 0xff, 0, 0xff);
outbuf[4 * k + 0] = r;
outbuf[4 * k + 1] = g;
outbuf[4 * k + 2] = b;
}
}
// else processing output was 8-bit already, and no need to swap order
}
else // need to flip
{
// ldr output: char
if(high_quality_processing)
{
const float *const inbuf = (float *)outbuf;
for(size_t k = 0; k < (size_t)processed_width * processed_height; k++)
{
// convert in place, this is unfortunately very serial..
const uint8_t r = CLAMP(inbuf[4 * k + 0] * 0xff, 0, 0xff);
const uint8_t g = CLAMP(inbuf[4 * k + 1] * 0xff, 0, 0xff);
const uint8_t b = CLAMP(inbuf[4 * k + 2] * 0xff, 0, 0xff);
outbuf[4 * k + 0] = r;
outbuf[4 * k + 1] = g;
outbuf[4 * k + 2] = b;
}
}
else
{ // !display_byteorder, need to swap:
uint8_t *const buf8 = pipe.backbuf;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(processed_width, processed_height) schedule(static)
#endif
// just flip byte order
for(size_t k = 0; k < (size_t)processed_width * processed_height; k++)
{
uint8_t tmp = buf8[4 * k + 0];
buf8[4 * k + 0] = buf8[4 * k + 2];
buf8[4 * k + 2] = tmp;
}
}
}
}
else if(bpp == 16)
{
// uint16_t per color channel
float *buff = (float *)outbuf;
uint16_t *buf16 = (uint16_t *)outbuf;
for(int y = 0; y < processed_height; y++)
for(int x = 0; x < processed_width; x++)
{
// convert in place
const size_t k = (size_t)processed_width * y + x;
for(int i = 0; i < 3; i++) buf16[4 * k + i] = CLAMP(buff[4 * k + i] * 0x10000, 0, 0xffff);
}
}
// else output float, no further harm done to the pixels :)
format_params->width = processed_width;
format_params->height = processed_height;
if(!ignore_exif)
{
int length;
uint8_t exif_profile[65535]; // C++ alloc'ed buffer is uncool, so we waste some bits here.
char pathname[PATH_MAX] = { 0 };
gboolean from_cache = TRUE;
dt_image_full_path(imgid, pathname, sizeof(pathname), &from_cache);
// last param is dng mode, it's false here
length = dt_exif_read_blob(exif_profile, pathname, imgid, sRGB, processed_width, processed_height, 0);
res = format->write_image(format_params, filename, outbuf, exif_profile, length, imgid, num, total);
}
else
{
res = format->write_image(format_params, filename, outbuf, NULL, 0, imgid, num, total);
}
dt_dev_pixelpipe_cleanup(&pipe);
dt_dev_cleanup(&dev);
dt_mipmap_cache_release(darktable.mipmap_cache, &buf);
/* now write xmp into that container, if possible */
if(copy_metadata && (format->flags(format_params) & FORMAT_FLAGS_SUPPORT_XMP))
{
dt_exif_xmp_attach(imgid, filename);
// no need to cancel the export if this fail
}
if(!thumbnail_export && strcmp(format->mime(format_params), "memory")
&& !(format->flags(format_params) & FORMAT_FLAGS_NO_TMPFILE))
{
dt_control_signal_raise(darktable.signals, DT_SIGNAL_IMAGE_EXPORT_TMPFILE, imgid, filename, format,
format_params, storage, storage_params);
}
return res;
error:
dt_dev_pixelpipe_cleanup(&pipe);
error_early:
dt_dev_cleanup(&dev);
dt_mipmap_cache_release(darktable.mipmap_cache, &buf);
return 1;
}
int store(dt_imageio_module_storage_t *self, dt_imageio_module_data_t *sdata, 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)
{
dt_imageio_disk_t *d = (dt_imageio_disk_t *)sdata;
char filename[PATH_MAX] = { 0 };
char dirname[PATH_MAX] = { 0 };
gboolean from_cache = FALSE;
dt_image_full_path(imgid, dirname, sizeof(dirname), &from_cache);
int fail = 0;
// we're potentially called in parallel. have sequence number synchronized:
dt_pthread_mutex_lock(&darktable.plugin_threadsafe);
{
// if filenamepattern is a directory just let att ${FILE_NAME} as default..
if(g_file_test(d->filename, G_FILE_TEST_IS_DIR)
|| ((d->filename + strlen(d->filename))[0] == '/' || (d->filename + strlen(d->filename))[0] == '\\'))
snprintf(d->filename + strlen(d->filename), sizeof(d->filename) - strlen(d->filename), "$(FILE_NAME)");
// avoid braindead export which is bound to overwrite at random:
if(total > 1 && !g_strrstr(d->filename, "$"))
{
snprintf(d->filename + strlen(d->filename), sizeof(d->filename) - strlen(d->filename), "_$(SEQUENCE)");
}
gchar *fixed_path = dt_util_fix_path(d->filename);
g_strlcpy(d->filename, fixed_path, sizeof(d->filename));
g_free(fixed_path);
d->vp->filename = dirname;
d->vp->jobcode = "export";
d->vp->imgid = imgid;
d->vp->sequence = num;
dt_variables_expand(d->vp, d->filename, TRUE);
gchar *result_filename = dt_variables_get_result(d->vp);
g_strlcpy(filename, result_filename, sizeof(filename));
g_free(result_filename);
g_strlcpy(dirname, filename, sizeof(dirname));
const char *ext = format->extension(fdata);
char *c = dirname + strlen(dirname);
for(; c > dirname && *c != '/'; c--)
;
if(*c == '/')
{
if(c > dirname) // /.../.../foo
c[0] = '\0';
else // /foo
c[1] = '\0';
}
else if(c == dirname) // foo
{
c[0] = '.';
c[1] = '\0';
}
if(g_mkdir_with_parents(dirname, 0755))
{
fprintf(stderr, "[imageio_storage_disk] could not create directory: `%s'!\n", dirname);
dt_control_log(_("could not create directory `%s'!"), dirname);
fail = 1;
goto failed;
}
if(g_access(dirname, W_OK | X_OK) != 0)
{
fprintf(stderr, "[imageio_storage_disk] could not write to directory: `%s'!\n", dirname);
dt_control_log(_("could not write to directory `%s'!"), dirname);
fail = 1;
goto failed;
}
c = filename + strlen(filename);
// remove everything after the last '.'. this destroys any file name with dots in it since $(FILE_NAME)
// already comes without the original extension.
// for(; c>filename && *c != '.' && *c != '/' ; c--);
// if(c <= filename || *c=='/') c = filename + strlen(filename);
sprintf(c, ".%s", ext);
/* prevent overwrite of files */
failed:
if(!d->overwrite)
{
int seq = 1;
if(!fail && g_file_test(filename, G_FILE_TEST_EXISTS))
{
do
{
sprintf(c, "_%.2d.%s", seq, ext);
seq++;
} while(g_file_test(filename, G_FILE_TEST_EXISTS));
}
}
} // end of critical block
dt_pthread_mutex_unlock(&darktable.plugin_threadsafe);
if(fail) return 1;
/* export image to file */
if(dt_imageio_export(imgid, filename, format, fdata, high_quality, upscale, TRUE, self, sdata, num, total) != 0)
{
fprintf(stderr, "[imageio_storage_disk] could not export to file: `%s'!\n", filename);
dt_control_log(_("could not export to file `%s'!"), filename);
return 1;
}
printf("[export_job] exported to `%s'\n", filename);
char *trunc = filename + strlen(filename) - 32;
if(trunc < filename) trunc = filename;
dt_control_log(ngettext("%d/%d exported to `%s%s'", "%d/%d exported to `%s%s'", num),
num, total, trunc != filename ? ".." : "", trunc);
return 0;
}
