#include <assert.h>

#include <glib/gprintf.h>

#include <math.h>

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include "common/debug.h"

#include "common/image_cache.h"

#include "common/imageio.h"

#include "common/mipmap_cache.h"

#include "common/tags.h"

#include "control/conf.h"

#include "control/control.h"

#include "control/jobs.h"

#include "develop/blend.h"

#include "develop/develop.h"

#include "develop/imageop.h"

#include "develop/lightroom.h"

#include "develop/masks.h"

#include "gui/gtk.h"

#include "gui/presets.h"

#define DT_DEV_AVERAGE_DELAY_START 250

#define DT_DEV_PREVIEW_AVERAGE_DELAY_START 50

#define DT_DEV_AVERAGE_DELAY_COUNT 5

const gchar *dt_dev_histogram_type_names[DT_DEV_HISTOGRAM_N] = { "logarithmic", "linear", "waveform" };

void dt_dev_init(dt_develop_t *dev, int32_t gui_attached)

{

memset(dev, 0, sizeof(dt_develop_t));

dev->full_preview = FALSE;

dev->preview_downsampling = 1.0f;

dev->gui_module = NULL;

dev->timestamp = 0;

dev->average_delay = DT_DEV_AVERAGE_DELAY_START;

dev->preview_average_delay = DT_DEV_PREVIEW_AVERAGE_DELAY_START;

dev->gui_leaving = 0;

dev->gui_synch = 0;

dt_pthread_mutex_init(&dev->history_mutex, NULL);

dev->history_end = 0;

dev->history = NULL; // empty list

dev->gui_attached = gui_attached;

dev->width = -1;

dev->height = -1;

dt_image_init(&dev->image_storage);

dev->image_status = dev->preview_status = DT_DEV_PIXELPIPE_DIRTY;

dev->image_loading = dev->preview_loading = 0;

dev->image_force_reload = 0;

dev->preview_input_changed = 0;

dev->pipe = dev->preview_pipe = NULL;

dt_pthread_mutex_init(&dev->pipe_mutex, NULL);

dt_pthread_mutex_init(&dev->preview_pipe_mutex, NULL);

// dt_pthread_mutex_init(&dev->histogram_waveform_mutex, NULL);

dev->histogram = NULL;

dev->histogram_pre_tonecurve = NULL;

dev->histogram_pre_levels = NULL;

gchar *mode = dt_conf_get_string("plugins/darkroom/histogram/mode");

if(g_strcmp0(mode, "linear") == 0)

dev->histogram_type = DT_DEV_HISTOGRAM_LINEAR;

else if(g_strcmp0(mode, "logarithmic") == 0)

dev->histogram_type = DT_DEV_HISTOGRAM_LOGARITHMIC;

else if(g_strcmp0(mode, "waveform") == 0)

dev->histogram_type = DT_DEV_HISTOGRAM_WAVEFORM;

g_free(mode);

if(dev->gui_attached)

{

dev->pipe = (dt_dev_pixelpipe_t *)malloc(sizeof(dt_dev_pixelpipe_t));

dev->preview_pipe = (dt_dev_pixelpipe_t *)malloc(sizeof(dt_dev_pixelpipe_t));

dt_dev_pixelpipe_init(dev->pipe);

dt_dev_pixelpipe_init_preview(dev->preview_pipe);

dev->histogram = (uint32_t *)calloc(4 * 256, sizeof(uint32_t));

dev->histogram_pre_tonecurve = (uint32_t *)calloc(4 * 256, sizeof(uint32_t));

dev->histogram_pre_levels = (uint32_t *)calloc(4 * 256, sizeof(uint32_t));

dev->histogram_max = -1;

dev->histogram_pre_tonecurve_max = -1;

dev->histogram_pre_levels_max = -1;

}

dev->iop_instance = 0;

dev->iop = NULL;

dev->proxy.exposure = NULL;

dev->overexposed.enabled = FALSE;

dev->overexposed.colorscheme = dt_conf_get_int("darkroom/ui/overexposed/colorscheme");

dev->overexposed.lower = dt_conf_get_float("darkroom/ui/overexposed/lower");

dev->overexposed.upper = dt_conf_get_float("darkroom/ui/overexposed/upper");

}

void dt_dev_cleanup(dt_develop_t *dev)

{

if(!dev) return;

// image_cache does not have to be unref'd, this is done outside develop module.

dt_pthread_mutex_destroy(&dev->pipe_mutex);

dt_pthread_mutex_destroy(&dev->preview_pipe_mutex);

// dt_pthread_mutex_destroy(&dev->histogram_waveform_mutex);

if(dev->pipe)

{

dt_dev_pixelpipe_cleanup(dev->pipe);

free(dev->pipe);

}

if(dev->preview_pipe)

{

dt_dev_pixelpipe_cleanup(dev->preview_pipe);

free(dev->preview_pipe);

}

while(dev->history)

{

free(((dt_dev_history_item_t *)dev->history->data)->params);

free(((dt_dev_history_item_t *)dev->history->data)->blend_params);

free((dt_dev_history_item_t *)dev->history->data);

dev->history = g_list_delete_link(dev->history, dev->history);

}

while(dev->iop)

{

dt_iop_cleanup_module((dt_iop_module_t *)dev->iop->data);

free(dev->iop->data);

dev->iop = g_list_delete_link(dev->iop, dev->iop);

}

dt_pthread_mutex_destroy(&dev->history_mutex);

free(dev->histogram);

free(dev->histogram_pre_tonecurve);

free(dev->histogram_pre_levels);

g_list_free_full(dev->proxy.exposure, g_free);

dt_conf_set_int("darkroom/ui/overexposed/colorscheme", dev->overexposed.colorscheme);

dt_conf_set_float("darkroom/ui/overexposed/lower", dev->overexposed.lower);

dt_conf_set_float("darkroom/ui/overexposed/upper", dev->overexposed.upper);

}

void dt_dev_process_image(dt_develop_t *dev)

{

if(!dev->gui_attached || dev->pipe->processing) return;

int err

= dt_control_add_job_res(darktable.control, dt_dev_process_image_job_create(dev), DT_CTL_WORKER_ZOOM_1);

if(err) fprintf(stderr, "[dev_process_image] job queue exceeded!\n");

}

void dt_dev_process_preview(dt_develop_t *dev)

{

if(!dev->gui_attached) return;

int err = dt_control_add_job_res(darktable.control, dt_dev_process_preview_job_create(dev),

DT_CTL_WORKER_ZOOM_FILL);

if(err) fprintf(stderr, "[dev_process_preview] job queue exceeded!\n");

}

void dt_dev_invalidate(dt_develop_t *dev)

{

dev->image_status = DT_DEV_PIXELPIPE_DIRTY;

dev->timestamp++;

if(dev->preview_pipe) dev->preview_pipe->input_timestamp = dev->timestamp;

}

void dt_dev_invalidate_all(dt_develop_t *dev)

{

dev->image_status = dev->preview_status = DT_DEV_PIXELPIPE_DIRTY;

dev->timestamp++;

}

void dt_dev_process_preview_job(dt_develop_t *dev)

{

if(dev->image_loading)

{

// raw is already loading, no use starting another file access, we wait.

return;

}

dt_pthread_mutex_lock(&dev->preview_pipe_mutex);

if(dev->gui_leaving)

{

dt_pthread_mutex_unlock(&dev->preview_pipe_mutex);

return;

}

dt_control_log_busy_enter();

dev->preview_pipe->input_timestamp = dev->timestamp;

dev->preview_status = DT_DEV_PIXELPIPE_RUNNING;

// lock if there, issue a background load, if not (best-effort for mip f).

dt_mipmap_buffer_t buf;

dt_mipmap_cache_get(darktable.mipmap_cache, &buf, dev->image_storage.id, DT_MIPMAP_F, DT_MIPMAP_BEST_EFFORT,

'r');

if(!buf.buf)

{

dt_control_log_busy_leave();

dev->preview_status = DT_DEV_PIXELPIPE_DIRTY;

dt_pthread_mutex_unlock(&dev->preview_pipe_mutex);

return; // not loaded yet. load will issue a gtk redraw on completion, which in turn will trigger us again

// later.

}

// init pixel pipeline for preview.

dt_dev_pixelpipe_set_input(dev->preview_pipe, dev, (float *)buf.buf, buf.width, buf.height,

dev->image_storage.width / (float)buf.width, buf.pre_monochrome_demosaiced);

if(dev->preview_loading)

{

dt_dev_pixelpipe_cleanup_nodes(dev->preview_pipe);

dt_dev_pixelpipe_create_nodes(dev->preview_pipe, dev);

dt_dev_pixelpipe_flush_caches(dev->preview_pipe);

dev->preview_loading = 0;

}

// if raw loaded, get new mipf

if(dev->preview_input_changed)

{

dt_dev_pixelpipe_flush_caches(dev->preview_pipe);

dev->preview_input_changed = 0;

}

restart:

if(dev->gui_leaving)

{

dt_control_log_busy_leave();

dev->preview_status = DT_DEV_PIXELPIPE_INVALID;

dt_pthread_mutex_unlock(&dev->preview_pipe_mutex);

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

return;

}

// adjust pipeline according to changed flag set by {add,pop}_history_item.

// this locks dev->history_mutex.

dt_times_t start;

dt_get_times(&start);

dt_dev_pixelpipe_change(dev->preview_pipe, dev);

if(dt_dev_pixelpipe_process(

dev->preview_pipe, dev, 0, 0, dev->preview_pipe->processed_width * dev->preview_downsampling,

dev->preview_pipe->processed_height * dev->preview_downsampling, dev->preview_downsampling))

{

if(dev->preview_loading || dev->preview_input_changed)

{

dt_control_log_busy_leave();

dev->preview_status = DT_DEV_PIXELPIPE_INVALID;

dt_pthread_mutex_unlock(&dev->preview_pipe_mutex);

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

return;

}

else

goto restart;

}

dev->preview_status = DT_DEV_PIXELPIPE_VALID;

dt_show_times(&start, "[dev_process_preview] pixel pipeline processing", NULL);

dt_dev_average_delay_update(&start, &dev->preview_average_delay);

// redraw the whole thing, to also update color picker values and histograms etc.

if(dev->gui_attached) dt_control_queue_redraw();

dt_control_log_busy_leave();

dt_pthread_mutex_unlock(&dev->preview_pipe_mutex);

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

}

void dt_dev_process_image_job(dt_develop_t *dev)

{

dt_pthread_mutex_lock(&dev->pipe_mutex);

if(dev->gui_leaving)

{

dt_pthread_mutex_unlock(&dev->pipe_mutex);

return;

}

dt_control_log_busy_enter();

// let gui know to draw preview instead of us, if it's there:

dev->image_status = DT_DEV_PIXELPIPE_RUNNING;

dt_mipmap_buffer_t buf;

dt_times_t start;

dt_get_times(&start);

dt_mipmap_cache_get(darktable.mipmap_cache, &buf, dev->image_storage.id, DT_MIPMAP_FULL,

DT_MIPMAP_BLOCKING, 'r');

dt_show_times(&start, "[dev]", "to load the image.");

// failed to load raw?

if(!buf.buf)

{

dt_control_log_busy_leave();

dev->image_status = DT_DEV_PIXELPIPE_DIRTY;

dt_pthread_mutex_unlock(&dev->pipe_mutex);

return;

}

dt_dev_pixelpipe_set_input(dev->pipe, dev, (float *)buf.buf, buf.width, buf.height, 1.0,

buf.pre_monochrome_demosaiced);

if(dev->image_loading)

{

// init pixel pipeline

dt_dev_pixelpipe_cleanup_nodes(dev->pipe);

dt_dev_pixelpipe_create_nodes(dev->pipe, dev);

if(dev->image_force_reload) dt_dev_pixelpipe_flush_caches(dev->pipe);

dev->image_force_reload = 0;

if(dev->gui_attached)

{

// during load, a mipf update could have been issued.

dev->preview_input_changed = 1;

dev->preview_status = DT_DEV_PIXELPIPE_DIRTY;

dev->gui_synch = 1; // notify gui thread we want to synch (call gui_update in the modules)

dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH;

}

dev->pipe->changed |= DT_DEV_PIPE_SYNCH;

}

dt_dev_zoom_t zoom;

float zoom_x, zoom_y, scale;

int window_width, window_height, x, y, closeup;

dt_dev_pixelpipe_change_t pipe_changed;

restart:

if(dev->gui_leaving)

{

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

dt_control_log_busy_leave();

dev->image_status = DT_DEV_PIXELPIPE_INVALID;

dt_pthread_mutex_unlock(&dev->pipe_mutex);

return;

}

dev->pipe->input_timestamp = dev->timestamp;

// dt_dev_pixelpipe_change() will clear the changed value

pipe_changed = dev->pipe->changed;

// this locks dev->history_mutex.

dt_dev_pixelpipe_change(dev->pipe, dev);

// determine scale according to new dimensions

zoom = dt_control_get_dev_zoom();

closeup = dt_control_get_dev_closeup();

zoom_x = dt_control_get_dev_zoom_x();

zoom_y = dt_control_get_dev_zoom_y();

// if just changed to an image with a different aspect ratio or

// altered image orientation, the prior zoom xy could now be beyond

// the image boundary

if(dev->image_loading || (pipe_changed != DT_DEV_PIPE_UNCHANGED))

{

dt_dev_check_zoom_bounds(dev, &zoom_x, &zoom_y, zoom, closeup, NULL, NULL);

dt_control_set_dev_zoom_x(zoom_x);

dt_control_set_dev_zoom_y(zoom_y);

}

scale = dt_dev_get_zoom_scale(dev, zoom, 1.0f, 0) * darktable.gui->ppd;

window_width = dev->width * darktable.gui->ppd;

window_height = dev->height * darktable.gui->ppd;

if(closeup)

{

window_width /= 2;

window_height /= 2;

}

const int wd = MIN(window_width, dev->pipe->processed_width * scale);

const int ht = MIN(window_height, dev->pipe->processed_height * scale);

x = MAX(0, scale * dev->pipe->processed_width * (.5 + zoom_x) - wd / 2);

y = MAX(0, scale * dev->pipe->processed_height * (.5 + zoom_y) - ht / 2);

dt_get_times(&start);

if(dt_dev_pixelpipe_process(dev->pipe, dev, x, y, wd, ht, scale))

{

// interrupted because image changed?

if(dev->image_force_reload)

{

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

dt_control_log_busy_leave();

dev->image_status = DT_DEV_PIXELPIPE_INVALID;

dt_pthread_mutex_unlock(&dev->pipe_mutex);

return;

}

// or because the pipeline changed?

else

goto restart;

}

dt_show_times(&start, "[dev_process_image] pixel pipeline processing", NULL);

dt_dev_average_delay_update(&start, &dev->average_delay);

// maybe we got zoomed/panned in the meantime?

if(dev->pipe->changed != DT_DEV_PIPE_UNCHANGED) goto restart;

// cool, we got a new image!

dev->image_status = DT_DEV_PIXELPIPE_VALID;

dev->image_loading = 0;

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

// redraw the whole thing, to also update color picker values and histograms etc.

if(dev->gui_attached) dt_control_queue_redraw();

dt_control_log_busy_leave();

dt_pthread_mutex_unlock(&dev->pipe_mutex);

}

static inline void _dt_dev_load_raw(dt_develop_t *dev, const uint32_t imgid)

{

// first load the raw, to make sure dt_image_t will contain all and correct data.

dt_mipmap_buffer_t buf;

dt_times_t start;

dt_get_times(&start);

dt_mipmap_cache_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING, 'r');

dt_mipmap_cache_release(darktable.mipmap_cache, &buf);

dt_show_times(&start, "[dev]", "to load the image.");

const dt_image_t *image = dt_image_cache_get(darktable.image_cache, imgid, 'r');

dev->image_storage = *image;

dt_image_cache_read_release(darktable.image_cache, image);

}

void dt_dev_reload_image(dt_develop_t *dev, const uint32_t imgid)

{

_dt_dev_load_raw(dev, imgid);

dev->image_force_reload = dev->image_loading = dev->preview_loading = 1;

dev->pipe->changed |= DT_DEV_PIPE_SYNCH;

dt_dev_invalidate(dev); // only invalidate image, preview will follow once it's loaded.

}

float dt_dev_get_zoom_scale(dt_develop_t *dev, dt_dev_zoom_t zoom, int closeup_factor, int preview)

{

float zoom_scale;

const float w = preview ? dev->preview_pipe->processed_width : dev->pipe->processed_width;

const float h = preview ? dev->preview_pipe->processed_height : dev->pipe->processed_height;

const float ps = dev->pipe->backbuf_width

? dev->pipe->processed_width / (float)dev->preview_pipe->processed_width

: dev->preview_pipe->iscale / dev->preview_downsampling;

switch(zoom)

{

case DT_ZOOM_FIT:

zoom_scale = fminf(dev->width / w, dev->height / h);

break;

case DT_ZOOM_FILL:

zoom_scale = fmaxf(dev->width / w, dev->height / h);

break;

case DT_ZOOM_1:

zoom_scale = closeup_factor;

if(preview) zoom_scale *= ps;

break;

default: // DT_ZOOM_FREE

zoom_scale = dt_control_get_dev_zoom_scale();

if(preview) zoom_scale *= ps;

break;

}

return zoom_scale;

}

void dt_dev_load_image(dt_develop_t *dev, const uint32_t imgid)

{

_dt_dev_load_raw(dev, imgid);

if(dev->pipe)

{

dev->pipe->processed_width = 0;

dev->pipe->processed_height = 0;

}

dev->image_loading = 1;

dev->preview_loading = 1;

dev->first_load = 1;

dev->image_status = dev->preview_status = DT_DEV_PIXELPIPE_DIRTY;

dev->iop = dt_iop_load_modules(dev);

dt_masks_read_forms(dev);

dt_dev_read_history(dev);

dev->first_load = 0;

}

void dt_dev_configure(dt_develop_t *dev, int wd, int ht)

{

// fixed border on every side

const int tb = DT_PIXEL_APPLY_DPI(dt_conf_get_int("plugins/darkroom/ui/border_size"));

wd -= 2*tb;

ht -= 2*tb;

if(dev->width != wd || dev->height != ht)

{

dev->width = wd;

dev->height = ht;

dev->preview_pipe->changed |= DT_DEV_PIPE_ZOOMED;

dev->pipe->changed |= DT_DEV_PIPE_ZOOMED;

dt_dev_invalidate(dev);

}

}

int dt_dev_write_history_item(const dt_image_t *image, dt_dev_history_item_t *h, int32_t num)

{

if(!image) return 1;

sqlite3_stmt *stmt;

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"select num from history where imgid = ?1 and num = ?2", -1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, image->id);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, num);

if(sqlite3_step(stmt) != SQLITE_ROW)

{

sqlite3_finalize(stmt);

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"insert into history (imgid, num) values (?1, ?2)", -1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, image->id);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, num);

sqlite3_step(stmt);

}

// printf("[dev write history item] writing %d - %s params %f %f\n", h->module->instance, h->module->op,

// *(float *)h->params, *(((float *)h->params)+1));

sqlite3_finalize(stmt);

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"update history set operation = ?1, op_params = ?2, module = ?3, enabled = ?4, "

"blendop_params = ?7, blendop_version = ?8, multi_priority = ?9, multi_name = "

"?10 where imgid = ?5 and num = ?6",

-1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, h->module->op, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 2, h->params, h->module->params_size, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, h->module->version());

DT_DEBUG_SQLITE3_BIND_INT(stmt, 4, h->enabled);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 5, image->id);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 6, num);

DT_DEBUG_SQLITE3_BIND_BLOB(stmt, 7, h->blend_params, sizeof(dt_develop_blend_params_t), SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 8, dt_develop_blend_version());

DT_DEBUG_SQLITE3_BIND_INT(stmt, 9, h->multi_priority);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 10, h->multi_name, -1, SQLITE_TRANSIENT);

sqlite3_step(stmt);

sqlite3_finalize(stmt);

return 0;

}

void dt_dev_add_history_item(dt_develop_t *dev, dt_iop_module_t *module, gboolean enable)

{

if(darktable.gui->reset) return;

dt_pthread_mutex_lock(&dev->history_mutex);

if(dev->gui_attached)

{

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);

// printf("removing obsoleted history item: %s\n", hist->module->op);

free(hist->params);

free(hist->blend_params);

free(history->data);

dev->history = g_list_delete_link(dev->history, history);

history = next;

}

history = g_list_nth(dev->history, dev->history_end - 1);

dt_dev_history_item_t *hist = history ? (dt_dev_history_item_t *)(history->data) : 0;

if(!history // if no history yet, push new item for sure.

|| module != hist->module

|| module->instance != hist->module->instance // add new item for different op

|| module->multi_priority != hist->module->multi_priority // or instance

|| ((dev->focus_hash != hist->focus_hash) // or if focused out and in

&& (// but only add item if there is a difference at all for the same module

(module->params_size != hist->module->params_size) ||

(module->params_size == hist->module->params_size && memcmp(hist->params, module->params, module->params_size)))))

{

// new operation, push new item

// printf("adding new history item %d - %s\n", dev->history_end, module->op);

// if(history) printf("because item %d - %s is different operation.\n", dev->history_end-1,

// ((dt_dev_history_item_t *)history->data)->module->op);

dev->history_end++;

hist = (dt_dev_history_item_t *)malloc(sizeof(dt_dev_history_item_t));

if(enable)

{

module->enabled = TRUE;

if(module->off)

{

darktable.gui->reset = 1;

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(module->off), module->enabled);

darktable.gui->reset = 0;

}

}

hist->focus_hash = dev->focus_hash;

hist->enabled = module->enabled;

hist->module = module;

hist->params = malloc(module->params_size);

hist->multi_priority = module->multi_priority;

snprintf(hist->multi_name, sizeof(hist->multi_name), "%s", module->multi_name);

/* allocate and set hist blend_params */

hist->blend_params = malloc(sizeof(dt_develop_blend_params_t));

memcpy(hist->params, module->params, module->params_size);

memcpy(hist->blend_params, module->blend_params, sizeof(dt_develop_blend_params_t));

dev->history = g_list_append(dev->history, hist);

dev->pipe->changed |= DT_DEV_PIPE_SYNCH;

dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH; // topology remains, as modules are fixed for now.

}

else

{

// same operation, change params

// printf("changing same history item %d - %s\n", dev->history_end-1, module->op);

hist = (dt_dev_history_item_t *)history->data;

memcpy(hist->params, module->params, module->params_size);

if(module->flags() & IOP_FLAGS_SUPPORTS_BLENDING)

memcpy(hist->blend_params, module->blend_params, sizeof(dt_develop_blend_params_t));

// if the user changed stuff and the module is still not enabled, do it:

if(!hist->enabled && !module->enabled)

{

module->enabled = 1;

if(module->off)

{

darktable.gui->reset = 1;

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(module->off), module->enabled);

darktable.gui->reset = 0;

}

}

hist->multi_priority = module->multi_priority;

memcpy(hist->multi_name, module->multi_name, sizeof(module->multi_name));

hist->enabled = module->enabled;

dev->pipe->changed |= DT_DEV_PIPE_TOP_CHANGED;

dev->preview_pipe->changed |= DT_DEV_PIPE_TOP_CHANGED;

}

}

#if 0

{

// debug:

printf("remaining %d history items:\n", dev->history_end);

GList *history = dev->history;

int i = 0;

while(history)

{

dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(history->data);

printf("%d %s\n", i, hist->module->op);

history = g_list_next(history);

i++;

}

}

// invalidate buffers and force redraw of darkroom

dt_dev_invalidate_all(dev);

dt_pthread_mutex_unlock(&dev->history_mutex);

if(dev->gui_attached)

{

/* signal that history has changed */

dt_control_signal_raise(darktable.signals, DT_SIGNAL_DEVELOP_HISTORY_CHANGE);

/* redraw */

dt_control_queue_redraw_center();

}

}

void dt_dev_reload_history_items(dt_develop_t *dev)

{

dev->focus_hash = 0;

dt_dev_pop_history_items(dev, 0);

// remove unused history items:

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;

}

dt_dev_read_history(dev);

// we have to add new module instances first

GList *modules = dev->iop;

while(modules)

{

dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);

if(module->multi_priority > 0)

{

if(!dt_iop_is_hidden(module) && !module->expander)

{

module->gui_init(module);

dt_iop_reload_defaults(module);

// we search the base iop corresponding

GList *mods = g_list_first(dev->iop);

dt_iop_module_t *base = NULL;

int pos_module = 0;

int pos_base = 0;

int pos = 0;

while(mods)

{

dt_iop_module_t *mod = (dt_iop_module_t *)(mods->data);

if(mod->multi_priority == 0 && mod->instance == module->instance)

{

base = mod;

pos_base = pos;

}

else if(mod == module)

pos_module = pos;

mods = g_list_next(mods);

pos++;

}

if(!base) continue;

/* add module to right panel */

GtkWidget *expander = dt_iop_gui_get_expander(module);

dt_ui_container_add_widget(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER, expander);

GValue gv = { 0, { { 0 } } };

g_value_init(&gv, G_TYPE_INT);

gtk_container_child_get_property(

GTK_CONTAINER(dt_ui_get_container(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER)),

base->expander, "position", &gv);

gtk_box_reorder_child(dt_ui_get_container(darktable.gui->ui, DT_UI_CONTAINER_PANEL_RIGHT_CENTER),

expander, g_value_get_int(&gv) + pos_base - pos_module);

dt_iop_gui_set_expanded(module, TRUE, FALSE);

dt_iop_gui_update_blending(module);

// the pipe need to be reconstruct

dev->pipe->changed |= DT_DEV_PIPE_REMOVE;

dev->preview_pipe->changed |= DT_DEV_PIPE_REMOVE;

}

}

else if(!dt_iop_is_hidden(module) && module->expander)

{

// we have to ensure that the name of the widget is correct

GtkWidget *wlabel;

GList *childs = gtk_container_get_children(GTK_CONTAINER(module->expander));

GtkWidget *header = gtk_bin_get_child(GTK_BIN(g_list_nth_data(childs, 0)));

g_list_free(childs);

/* get arrow icon widget */

childs = gtk_container_get_children(GTK_CONTAINER(header));

wlabel = g_list_nth(childs, 5)->data;

g_list_free(childs);

gchar *label = dt_history_item_get_name_html(module);

gtk_label_set_markup(GTK_LABEL(wlabel), label);

g_free(label);

}

modules = g_list_next(modules);

}

dt_dev_pop_history_items(dev, dev->history_end);

}

void dt_dev_pop_history_items(dt_develop_t *dev, int32_t cnt)

{

// printf("dev popping all history items >= %d\n", cnt);

dt_pthread_mutex_lock(&dev->history_mutex);

darktable.gui->reset = 1;

dev->history_end = cnt;

// reset gui params for all modules

GList *modules = dev->iop;

while(modules)

{

dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);

memcpy(module->params, module->default_params, module->params_size);

memcpy(module->blend_params, module->default_blendop_params, sizeof(dt_develop_blend_params_t));

module->enabled = module->default_enabled;

modules = g_list_next(modules);

}

// go through history and set gui params

GList *history = dev->history;

for(int i = 0; i < cnt && history; i++)

{

dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(history->data);

memcpy(hist->module->params, hist->params, hist->module->params_size);

memcpy(hist->module->blend_params, hist->blend_params, sizeof(dt_develop_blend_params_t));

hist->module->enabled = hist->enabled;

snprintf(hist->module->multi_name, sizeof(hist->module->multi_name), "%s", hist->multi_name);

history = g_list_next(history);

}

// update all gui modules

modules = dev->iop;

while(modules)

{

dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);

dt_iop_gui_update(module);

modules = g_list_next(modules);

}

dev->pipe->changed |= DT_DEV_PIPE_SYNCH;

dev->preview_pipe->changed |= DT_DEV_PIPE_SYNCH; // again, fixed topology for now.

darktable.gui->reset = 0;

dt_dev_invalidate_all(dev);

dt_pthread_mutex_unlock(&dev->history_mutex);

dt_control_queue_redraw_center();

}

void dt_dev_write_history(dt_develop_t *dev)

{

sqlite3_stmt *stmt;

gboolean changed = FALSE;

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, dev->image_storage.id);

sqlite3_step(stmt);

sqlite3_finalize(stmt);

GList *history = dev->history;

for(int i = 0; history; i++)

{

dt_dev_history_item_t *hist = (dt_dev_history_item_t *)(history->data);

(void)dt_dev_write_history_item(&dev->image_storage, hist, i);

history = g_list_next(history);

changed = TRUE;

}

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"UPDATE images SET history_end = ?1 where id = ?2", -1,

&stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, dev->history_end);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, dev->image_storage.id);

sqlite3_step(stmt);

sqlite3_finalize(stmt);

/* attach / detach changed tag reflecting actual change */

guint tagid = 0;

dt_tag_new("darktable|changed", &tagid);

if(changed)

dt_tag_attach(tagid, dev->image_storage.id);

else

dt_tag_detach(tagid, dev->image_storage.id);

}

static void auto_apply_presets(dt_develop_t *dev)

{

const int imgid = dev->image_storage.id;

if(imgid <= 0) return;

// be extra sure that we don't mess up history in separate threads:

dt_pthread_mutex_lock(&darktable.db_insert);

int run = 0;

dt_image_t *image = dt_image_cache_get(darktable.image_cache, imgid, 'w');

if(!(image->flags & DT_IMAGE_AUTO_PRESETS_APPLIED)) run = 1;

// flag was already set? only apply presets once in the lifetime of a history stack.

// (the flag will be cleared when removing it)

if(!run || image->id <= 0)

{

dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_RELAXED);

dt_pthread_mutex_unlock(&darktable.db_insert);

return;

}

// cleanup

DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "delete from memory.history", NULL, NULL, NULL);

const char *preset_table[2] = { "presets", "legacy_presets" };

const int legacy = (image->flags & DT_IMAGE_NO_LEGACY_PRESETS) ? 0 : 1;

char query[1024];

snprintf(query, sizeof(query), "insert into memory.history select ?1, 0, op_version, operation, op_params, "

"enabled, blendop_params, blendop_version, multi_priority, multi_name "

"from %s where autoapply=1 and "

"((?2 like model and ?3 like maker) or (?4 like model and ?5 like maker)) and"

"?6 like lens and ?7 between iso_min and iso_max and "

"?8 between exposure_min and exposure_max and "

"?9 between aperture_min and aperture_max and "

"?10 between focal_length_min and focal_length_max and "

"(format = 0 or format&?9!=0) order by writeprotect desc, "

"length(model), length(maker), length(lens)",

preset_table[legacy]);

// query for all modules at once:

sqlite3_stmt *stmt;

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, image->exif_model, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 3, image->exif_maker, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 4, image->camera_alias, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 5, image->camera_maker, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 6, image->exif_lens, -1, SQLITE_TRANSIENT);

DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 7, fmaxf(0.0f, fminf(1000000, image->exif_iso)));

DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 8, fmaxf(0.0f, fminf(1000000, image->exif_exposure)));

DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 9, fmaxf(0.0f, fminf(1000000, image->exif_aperture)));

DT_DEBUG_SQLITE3_BIND_DOUBLE(stmt, 10, fmaxf(0.0f, fminf(1000000, image->exif_focal_length)));

// 0: dontcare, 1: ldr, 2: raw

DT_DEBUG_SQLITE3_BIND_DOUBLE(

stmt, 9, dt_image_is_ldr(image) ? FOR_LDR : (dt_image_is_raw(image) ? FOR_RAW : FOR_HDR));

if(sqlite3_step(stmt) == SQLITE_DONE)

{

sqlite3_finalize(stmt);

int cnt = 0;

// count what we found:

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select count(*) from memory.history", -1,

&stmt, NULL);

if(sqlite3_step(stmt) == SQLITE_ROW)

{

// if there is anything..

cnt = sqlite3_column_int(stmt, 0);

sqlite3_finalize(stmt);

// workaround a sqlite3 "feature". The above statement to insert items into memory.history is complex and in

// this case sqlite does not give rowid a linear increment. But the following code really expect that the rowid in

// this table starts from 0 and increment one by one. So in the following code we rewrite the num values.

if(cnt > 0)

{

// get all rowids

GList *rowids = NULL;

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"SELECT rowid FROM memory.history ORDER BY rowid ASC", -1, &stmt, NULL);

while(sqlite3_step(stmt) == SQLITE_ROW)

rowids = g_list_append(rowids, GINT_TO_POINTER(sqlite3_column_int(stmt, 0)));

sqlite3_finalize(stmt);

// update num accordingly

int v = 0;

GList *r = rowids;

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"UPDATE memory.history SET num=?1 WHERE rowid=?2", -1, &stmt, NULL);

// let's wrap this into a transaction, it might make it a little faster.

sqlite3_exec(dt_database_get(darktable.db), "BEGIN TRANSACTION", NULL, NULL, NULL);

do

{

DT_DEBUG_SQLITE3_CLEAR_BINDINGS(stmt);

DT_DEBUG_SQLITE3_RESET(stmt);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, v);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, GPOINTER_TO_INT(r->data));

sqlite3_step(stmt);

v++;

r = g_list_next(r);

} while((sqlite3_step(stmt) == SQLITE_DONE) && r);

sqlite3_exec(dt_database_get(darktable.db), "COMMIT", NULL, NULL, NULL);

g_list_free(rowids);

sqlite3_finalize(stmt);

}

// fprintf(stderr, "[auto_apply_presets] imageid %d found %d matching presets (legacy %d)\n", imgid,

// cnt, legacy);

// advance the current history by that amount:

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"update history set num=num+?1 where imgid=?2", -1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, cnt);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);

if(sqlite3_step(stmt) == SQLITE_DONE)

{

sqlite3_finalize(stmt);

DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),

"UPDATE images SET history_end=history_end+?1 where id=?2",

-1, &stmt, NULL);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, cnt);

DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, imgid);

if(sqlite3_step(stmt) == SQLITE_DONE)

{

// and finally prepend the rest with increasing numbers (starting at 0)

sqlite3_finalize(stmt);

DT_DEBUG_SQLITE3_PREPARE_V2(

dt_database_get(darktable.db),

"INSERT INTO history SELECT imgid, num, module, operation, op_params, enabled, "

"blendop_params, blendop_version, multi_priority, multi_name FROM memory.history",

-1, &stmt, NULL);

sqlite3_step(stmt);

}

}

}

}

sqlite3_finalize(stmt);

// first time we are loading the image, try to import lightroom .xmp if any

if(dev->image_loading) dt_lightroom_import(dev->image_storage.id, dev, TRUE);

image->flags |= DT_IMAGE_AUTO_PRESETS_APPLIED | DT_IMAGE_NO_LEGACY_PRESETS;

dt_pthread_mutex_unlock(&darktable.db_insert);

// make sure these end up in the image_cache + xmp (sync through here if we set the flag)

dt_image_cache_write_release(darktable.image_cache, image, DT_IMAGE_CACHE_SAFE);

}

void dt_dev_read_history(dt_develop_t *dev)

{

if(dev->image_storage.id <= 0) return;

if(!dev->iop) return;

// maybe prepend auto-presets to history before loading it: