static void
deflicker_prepare_histogram(dt_iop_module_t *self, uint32_t **histogram,
dt_dev_histogram_stats_t *histogram_stats)
{
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, self->dev->image_storage.id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, self->dev->image_storage.id);
dt_image_t image = *img;
dt_image_cache_read_release(darktable.image_cache, img);
if(buf.size != DT_MIPMAP_FULL)
{
dt_control_log(_("failed to get raw buffer from image `%s'"), image.filename);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return;
}
dt_dev_histogram_collection_params_t histogram_params;
memcpy(&histogram_params, &self->histogram_params, sizeof(dt_dev_histogram_collection_params_t));
dt_iop_roi_t roi = {0, 0, image.width, image.height, 1.0f};
histogram_params.roi = &roi;
dt_histogram_worker(&histogram_params, histogram_stats, buf.buf, histogram, dt_histogram_helper_cs_RAW_uint16);
histogram_stats->ch = 1u;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
static gboolean _view_map_motion_notify_callback(GtkWidget *w, GdkEventMotion *e, dt_view_t *self)
{
dt_map_t *lib = (dt_map_t*)self->data;
const int ts = 64;
if(lib->start_drag && lib->selected_image > 0)
{
for(GSList *iter = lib->images; iter != NULL; iter = iter->next)
{
dt_map_image_t *entry = (dt_map_image_t*)iter->data;
OsmGpsMapImage *image = entry->image;
if(entry->imgid == lib->selected_image)
{
osm_gps_map_image_remove(lib->map, image);
break;
}
}
lib->start_drag = FALSE;
GtkTargetList *targets = gtk_target_list_new(target_list_all, n_targets_all);
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, lib->selected_image, mip, DT_MIPMAP_BLOCKING);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
GdkDragContext * context = gtk_drag_begin(GTK_WIDGET(lib->map), targets, GDK_ACTION_COPY, 1, (GdkEvent*)e);
gtk_drag_set_icon_pixbuf(context, scaled, 0, 0);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
g_free(rgbbuf);
}
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
gtk_target_list_unref(targets);
return TRUE;
}
return FALSE;
}
int32_t dt_image_load_job_run(dt_job_t *job)
{
dt_image_load_t *t = (dt_image_load_t *)job->param;
// hook back into mipmap_cache:
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
t->imgid,
t->mip,
DT_MIPMAP_BLOCKING);
// drop read lock, as this is only speculative async loading.
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 0;
}
static int32_t dt_image_load_job_run(dt_job_t *job)
{
dt_image_load_t *params = dt_control_job_get_params(job);
// hook back into mipmap_cache:
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
params->imgid,
params->mip,
DT_MIPMAP_BLOCKING);
// drop read lock, as this is only speculative async loading.
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(params);
return 0;
}
void dt_view_filmstrip_prefetch()
{
const gchar *qin = dt_collection_get_query (darktable.collection);
if(!qin) return;
char query[1024];
int offset = 0;
if(qin)
{
int imgid = -1;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from selected_images", -1, &stmt, NULL);
if(sqlite3_step(stmt) == SQLITE_ROW)
imgid = sqlite3_column_int(stmt, 0);
sqlite3_finalize(stmt);
snprintf(query, 1024, "select rowid from (%s) where id=?3", qin);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, 0);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, -1);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, imgid);
if(sqlite3_step(stmt) == SQLITE_ROW)
offset = sqlite3_column_int(stmt, 0) - 1;
sqlite3_finalize(stmt);
}
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), qin, -1, &stmt, NULL);
// only get one more image:
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, offset+1);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, offset+2);
if(sqlite3_step(stmt) == SQLITE_ROW)
{
const uint32_t prefetchid = sqlite3_column_int(stmt, 0);
// dt_control_log("prefetching image %u", prefetchid);
dt_mipmap_cache_read_get(darktable.mipmap_cache, NULL, prefetchid, DT_MIPMAP_FULL, DT_MIPMAP_PREFETCH);
}
sqlite3_finalize(stmt);
}
int dt_load_from_string(const gchar* input, gboolean open_image_in_dr)
{
int id = 0;
if(input == NULL || input[0] == '\0')
return 0;
char* filename = dt_make_path_absolute(input);
if(filename == NULL)
{
dt_control_log(_("found strange path `%s'"), input);
return 0;
}
if(g_file_test(filename, G_FILE_TEST_IS_DIR))
{
// import a directory into a film roll
unsigned int last_char = strlen(filename)-1;
if(filename[last_char] == '/')
filename[last_char] = '\0';
id = dt_film_import(filename);
if(id)
{
dt_film_open(id);
dt_ctl_switch_mode_to(DT_LIBRARY);
}
else
{
dt_control_log(_("error loading directory `%s'"), filename);
}
}
else
{
// import a single image
gchar *directory = g_path_get_dirname((const gchar *)filename);
dt_film_t film;
const int filmid = dt_film_new(&film, directory);
id = dt_image_import(filmid, filename, TRUE);
g_free (directory);
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)
{
id = 0;
dt_control_log(_("file `%s' has unknown format!"), filename);
}
else
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
if(open_image_in_dr)
{
dt_control_set_mouse_over_id(id);
dt_ctl_switch_mode_to(DT_DEVELOP);
}
}
}
else
{
dt_control_log(_("error loading file `%s'"), filename);
}
}
g_free(filename);
return id;
}
void
dt_mipmap_cache_read_get(
dt_mipmap_cache_t *cache,
dt_mipmap_buffer_t *buf,
const uint32_t imgid,
const dt_mipmap_size_t mip,
const dt_mipmap_get_flags_t flags)
{
const uint32_t key = get_key(imgid, mip);
if(flags == DT_MIPMAP_TESTLOCK)
{
// simple case: only get and lock if it's there.
struct dt_mipmap_buffer_dsc* dsc = (struct dt_mipmap_buffer_dsc*)dt_cache_read_testget(&cache->mip[mip].cache, key);
if(dsc)
{
buf->width = dsc->width;
buf->height = dsc->height;
buf->imgid = imgid;
buf->size = mip;
// skip to next 8-byte alignment, for sse buffers.
buf->buf = (uint8_t *)(dsc+1);
}
else
{
// set to NULL if failed.
buf->width = buf->height = 0;
buf->imgid = 0;
buf->size = DT_MIPMAP_NONE;
buf->buf = NULL;
}
}
else if(flags == DT_MIPMAP_PREFETCH)
{
// and opposite: prefetch without locking
if(mip > DT_MIPMAP_FULL || mip < DT_MIPMAP_0) return;
dt_job_t j;
dt_image_load_job_init(&j, imgid, mip);
// if the job already exists, make it high-priority, if not, add it:
if(dt_control_revive_job(darktable.control, &j) < 0)
dt_control_add_job(darktable.control, &j);
}
else if(flags == DT_MIPMAP_BLOCKING)
{
// simple case: blocking get
struct dt_mipmap_buffer_dsc* dsc = (struct dt_mipmap_buffer_dsc*)dt_cache_read_get(&cache->mip[mip].cache, key);
if(!dsc)
{
// should never happen for anything but full images which have been moved.
assert(mip == DT_MIPMAP_FULL || mip == DT_MIPMAP_F);
// fprintf(stderr, "[mipmap cache get] no data in cache for imgid %u size %d!\n", imgid, mip);
// sorry guys, no image for you :(
buf->width = buf->height = 0;
buf->imgid = 0;
buf->size = DT_MIPMAP_NONE;
buf->buf = NULL;
}
else
{
// fprintf(stderr, "[mipmap cache get] found data in cache for imgid %u size %d\n", imgid, mip);
// uninitialized?
//assert(dsc->flags & DT_MIPMAP_BUFFER_DSC_FLAG_GENERATE || dsc->size == 0);
if(dsc->flags & DT_MIPMAP_BUFFER_DSC_FLAG_GENERATE)
{
__sync_fetch_and_add (&(cache->mip[mip].stats_fetches), 1);
// fprintf(stderr, "[mipmap cache get] now initializing buffer for img %u mip %d!\n", imgid, mip);
// we're write locked here, as requested by the alloc callback.
// now fill it with data:
if(mip == DT_MIPMAP_FULL)
{
// load the image:
// make sure we access the r/w lock as shortly as possible!
dt_image_t buffered_image;
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
buffered_image = *cimg;
// dt_image_t *img = dt_image_cache_write_get(darktable.image_cache, cimg);
// dt_image_cache_write_release(darktable.image_cache, img, DT_IMAGE_CACHE_RELAXED);
dt_image_cache_read_release(darktable.image_cache, cimg);
char filename[DT_MAX_PATH_LEN];
gboolean from_cache = TRUE;
dt_image_full_path(buffered_image.id, filename, DT_MAX_PATH_LEN, &from_cache);
dt_mipmap_cache_allocator_t a = (dt_mipmap_cache_allocator_t)&dsc;
struct dt_mipmap_buffer_dsc* prvdsc = dsc;
dt_imageio_retval_t ret = dt_imageio_open(&buffered_image, filename, a);
if(dsc != prvdsc)
{
// fprintf(stderr, "[mipmap cache] realloc %p\n", data);
// write back to cache, too.
// in case something went wrong, still keep the buffer and return it to the hashtable
// so we don't produce mem leaks or unnecessary mem fragmentation.
dt_cache_realloc(&cache->mip[mip].cache, key, 1, (void*)dsc);
}
if(ret != DT_IMAGEIO_OK)
{
// fprintf(stderr, "[mipmap read get] error loading image: %d\n", ret);
//
// we can only return a zero dimension buffer if the buffer has been allocated.
// in case dsc couldn't be allocated and points to the static buffer, it contains
// a dead image already.
if((void *)dsc != (void *)dt_mipmap_cache_static_dead_image) dsc->width = dsc->height = 0;
}
else
{
// swap back new image data:
cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_image_t *img = dt_image_cache_write_get(darktable.image_cache, cimg);
*img = buffered_image;
// fprintf(stderr, "[mipmap read get] initializing full buffer img %u with %u %u -> %d %d (%p)\n", imgid, data[0], data[1], img->width, img->height, data);
// don't write xmp for this (we only changed db stuff):
dt_image_cache_write_release(darktable.image_cache, img, DT_IMAGE_CACHE_RELAXED);
dt_image_cache_read_release(darktable.image_cache, img);
}
}
else if(mip == DT_MIPMAP_F)
{
_init_f((float *)(dsc+1), &dsc->width, &dsc->height, imgid);
}
else
{
// 8-bit thumbs, possibly need to be compressed:
if(cache->compression_type)
{
// get per-thread temporary storage without malloc from a separate cache:
const int key = dt_control_get_threadid();
// const void *cbuf =
dt_cache_read_get(&cache->scratchmem.cache, key);
uint8_t *scratchmem = (uint8_t *)dt_cache_write_get(&cache->scratchmem.cache, key);
_init_8(scratchmem, &dsc->width, &dsc->height, imgid, mip);
buf->width = dsc->width;
buf->height = dsc->height;
buf->imgid = imgid;
buf->size = mip;
buf->buf = (uint8_t *)(dsc+1);
dt_mipmap_cache_compress(buf, scratchmem);
dt_cache_write_release(&cache->scratchmem.cache, key);
dt_cache_read_release(&cache->scratchmem.cache, key);
}
else
{
_init_8((uint8_t *)(dsc+1), &dsc->width, &dsc->height, imgid, mip);
}
}
dsc->flags &= ~DT_MIPMAP_BUFFER_DSC_FLAG_GENERATE;
// drop the write lock
dt_cache_write_release(&cache->mip[mip].cache, key);
/* raise signal that mipmaps has been flushed to cache */
dt_control_signal_raise(darktable.signals, DT_SIGNAL_DEVELOP_MIPMAP_UPDATED);
}
buf->width = dsc->width;
buf->height = dsc->height;
buf->imgid = imgid;
buf->size = mip;
buf->buf = (uint8_t *)(dsc+1);
if(dsc->width == 0 || dsc->height == 0)
{
// fprintf(stderr, "[mipmap cache get] got a zero-sized image for img %u mip %d!\n", imgid, mip);
if(mip < DT_MIPMAP_F) dead_image_8(buf);
else if(mip == DT_MIPMAP_F) dead_image_f(buf);
else buf->buf = NULL; // full images with NULL buffer have to be handled, indicates `missing image'
}
}
}
else if(flags == DT_MIPMAP_BEST_EFFORT)
{
__sync_fetch_and_add (&(cache->mip[mip].stats_requests), 1);
// best-effort, might also return NULL.
// never decrease mip level for float buffer or full image:
dt_mipmap_size_t min_mip = (mip >= DT_MIPMAP_F) ? mip : DT_MIPMAP_0;
for(int k=mip; k>=min_mip && k>=0; k--)
{
// already loaded?
dt_mipmap_cache_read_get(cache, buf, imgid, k, DT_MIPMAP_TESTLOCK);
if(buf->buf && buf->width > 0 && buf->height > 0)
{
if(mip != k) __sync_fetch_and_add (&(cache->mip[k].stats_standin), 1);
return;
}
// didn't succeed the first time? prefetch for later!
if(mip == k)
{
__sync_fetch_and_add (&(cache->mip[mip].stats_near_match), 1);
dt_mipmap_cache_read_get(cache, buf, imgid, mip, DT_MIPMAP_PREFETCH);
}
}
__sync_fetch_and_add (&(cache->mip[mip].stats_misses), 1);
// fprintf(stderr, "[mipmap cache get] image not found in cache: imgid %u mip %d!\n", imgid, mip);
// nothing found :(
buf->buf = NULL;
buf->imgid = 0;
buf->size = DT_MIPMAP_NONE;
buf->width = buf->height = 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 isn't available */
char filename[2048] = {0};
gboolean from_cache = TRUE;
dt_image_full_path(imgid, filename, 2048, &from_cache);
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_control_merge_hdr_job_run(dt_job_t *job)
{
long int imgid = -1;
dt_control_image_enumerator_t *t1 = (dt_control_image_enumerator_t *)job->param;
GList *t = t1->index;
int total = g_list_length(t);
char message[512]= {0};
double fraction=0;
snprintf(message, 512, ngettext ("merging %d image", "merging %d images", total), total );
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 1, message);
float *pixels = NULL;
float *weight = NULL;
int wd = 0, ht = 0, first_imgid = -1;
uint32_t filter = 0;
float whitelevel = 0.0f;
total ++;
while(t)
{
imgid = (long int)t->data;
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
// just take a copy. also do it after blocking read, so filters and bpp will make sense.
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_image_t image = *img;
dt_image_cache_read_release(darktable.image_cache, img);
if(image.filters == 0 || image.bpp != sizeof(uint16_t))
{
dt_control_log(_("exposure bracketing only works on raw images"));
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(pixels);
free(weight);
goto error;
}
filter = dt_image_flipped_filter(img);
if(buf.size != DT_MIPMAP_FULL)
{
dt_control_log(_("failed to get raw buffer from image `%s'"), image.filename);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(pixels);
free(weight);
goto error;
}
if(!pixels)
{
first_imgid = imgid;
pixels = (float *)malloc(sizeof(float)*image.width*image.height);
weight = (float *)malloc(sizeof(float)*image.width*image.height);
memset(pixels, 0x0, sizeof(float)*image.width*image.height);
memset(weight, 0x0, sizeof(float)*image.width*image.height);
wd = image.width;
ht = image.height;
}
else if(image.width != wd || image.height != ht)
{
dt_control_log(_("images have to be of same size!"));
free(pixels);
free(weight);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
goto error;
}
// if no valid exif data can be found, assume peleng fisheye at f/16, 8mm, with half of the light lost in the system => f/22
const float eap = image.exif_aperture > 0.0f ? image.exif_aperture : 22.0f;
const float efl = image.exif_focal_length > 0.0f ? image.exif_focal_length : 8.0f;
const float rad = .5f * efl/eap;
const float aperture = M_PI * rad * rad;
const float iso = image.exif_iso > 0.0f ? image.exif_iso : 100.0f;
const float exp = image.exif_exposure > 0.0f ? image.exif_exposure : 1.0f;
const float cal = 100.0f/(aperture*exp*iso);
whitelevel = fmaxf(whitelevel, cal);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(buf, pixels, weight, wd, ht)
#endif
for(int k=0; k<wd*ht; k++)
{
const uint16_t in = ((uint16_t *)buf.buf)[k];
const float w = .001f + (in >= 1000 ? (in < 65000 ? in/65000.0f : 0.0f) : exp * 0.01f);
pixels[k] += w * in * cal;
weight[k] += w;
}
t = g_list_delete_link(t, t);
/* update backgroundjob ui plate */
fraction+=1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
// normalize by white level to make clipping at 1.0 work as expected (to be sure, scale down one more stop, thus the 0.5):
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(pixels, wd, ht, weight, whitelevel)
#endif
for(int k=0; k<wd*ht; k++) pixels[k] = fmaxf(0.0f, fminf(2.0f, pixels[k]/((.5f*whitelevel*65535.0f)*weight[k])));
// output hdr as digital negative with exif data.
uint8_t exif[65535];
char pathname[1024];
dt_image_full_path(first_imgid, pathname, 1024);
const int exif_len = dt_exif_read_blob(exif, pathname, 0, first_imgid);
char *c = pathname + strlen(pathname);
while(*c != '.' && c > pathname) c--;
g_strlcpy(c, "-hdr.dng", sizeof(pathname)-(c-pathname));
dt_imageio_write_dng(pathname, pixels, wd, ht, exif, exif_len, filter, whitelevel);
dt_control_backgroundjobs_progress(darktable.control, jid, 1.0f);
while(*c != '/' && c > pathname) c--;
dt_control_log(_("wrote merged hdr `%s'"), c+1);
// import new image
gchar *directory = g_path_get_dirname((const gchar *)pathname);
dt_film_t film;
const int filmid = dt_film_new(&film, directory);
dt_image_import(filmid, pathname, TRUE);
g_free (directory);
free(pixels);
free(weight);
error:
dt_control_backgroundjobs_destroy(darktable.control, jid);
return 0;
}
int32_t dt_control_merge_hdr_job_run(dt_job_t *job)
{
long int imgid = -1;
dt_control_image_enumerator_t *t1 = (dt_control_image_enumerator_t *)job->param;
GList *t = t1->index;
int total = g_list_length(t);
char message[512]= {0};
double fraction=0;
snprintf(message, 512, ngettext ("merging %d image", "merging %d images", total), total );
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 1, message);
float *pixels = NULL;
float *weight = NULL;
int wd = 0, ht = 0, first_imgid = -1;
uint32_t filter = 0;
float whitelevel = 0.0f;
total ++;
while(t)
{
imgid = (long int)t->data;
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
// just take a copy. also do it after blocking read, so filters and bpp will make sense.
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_image_t image = *img;
dt_image_cache_read_release(darktable.image_cache, img);
if(image.filters == 0 || image.bpp != sizeof(uint16_t))
{
dt_control_log(_("exposure bracketing only works on raw images"));
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(pixels);
free(weight);
goto error;
}
filter = dt_image_flipped_filter(img);
if(buf.size != DT_MIPMAP_FULL)
{
dt_control_log(_("failed to get raw buffer from image `%s'"), image.filename);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(pixels);
free(weight);
goto error;
}
if(!pixels)
{
first_imgid = imgid;
pixels = (float *)malloc(sizeof(float)*image.width*image.height);
weight = (float *)malloc(sizeof(float)*image.width*image.height);
memset(pixels, 0x0, sizeof(float)*image.width*image.height);
memset(weight, 0x0, sizeof(float)*image.width*image.height);
wd = image.width;
ht = image.height;
}
else if(image.width != wd || image.height != ht)
{
dt_control_log(_("images have to be of same size!"));
free(pixels);
free(weight);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
goto error;
}
// if no valid exif data can be found, assume peleng fisheye at f/16, 8mm, with half of the light lost in the system => f/22
const float eap = image.exif_aperture > 0.0f ? image.exif_aperture : 22.0f;
const float efl = image.exif_focal_length > 0.0f ? image.exif_focal_length : 8.0f;
const float rad = .5f * efl/eap;
const float aperture = M_PI * rad * rad;
const float iso = image.exif_iso > 0.0f ? image.exif_iso : 100.0f;
const float exp = image.exif_exposure > 0.0f ? image.exif_exposure : 1.0f;
const float cal = 100.0f/(aperture*exp*iso);
// about proportional to how many photons we can expect from this shot:
const float photoncnt = 100.0f*aperture*exp/iso;
// stupid, but we don't know the real sensor saturation level:
uint16_t saturation = 0;
for(int k=0; k<wd*ht; k++)
saturation = MAX(saturation, ((uint16_t *)buf.buf)[k]);
// seems to be around 64500--64700 for 5dm2
// fprintf(stderr, "saturation: %u\n", saturation);
whitelevel = fmaxf(whitelevel, saturation*cal);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(buf, pixels, weight, wd, ht, saturation)
#endif
for(int k=0; k<wd*ht; k++)
{
const uint16_t in = ((uint16_t *)buf.buf)[k];
// weights based on siggraph 12 poster
// zijian zhu, zhengguo li, susanto rahardja, pasi fraenti
// 2d denoising factor for high dynamic range imaging
float w = envelope(in/(float)saturation) * photoncnt;
// in case we are black and drop to zero weight, give it something
// just so numerics don't collapse. blown out whites are handled below.
if(w < 1e-3f && in < saturation/3) w = 1e-3f;
pixels[k] += w * in * cal;
weight[k] += w;
}
t = g_list_delete_link(t, t);
/* update backgroundjob ui plate */
fraction+=1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
// normalize by white level to make clipping at 1.0 work as expected (to be sure, scale down one more stop, thus the 0.5):
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(pixels, wd, ht, weight, whitelevel)
#endif
for(int k=0; k<wd*ht; k++)
{
// in case w == 0, all pixels were overexposed (too dark would have been clamped to w >= eps above)
if(weight[k] < 1e-3f)
pixels[k] = 1.f; // mark as blown out.
else // normalize:
pixels[k] = fmaxf(0.0f, pixels[k]/(whitelevel*weight[k]));
}
// output hdr as digital negative with exif data.
uint8_t exif[65535];
char pathname[DT_MAX_PATH_LEN];
dt_image_full_path(first_imgid, pathname, DT_MAX_PATH_LEN);
// last param is dng mode
const int exif_len = dt_exif_read_blob(exif, pathname, first_imgid, 0, wd, ht, 1);
char *c = pathname + strlen(pathname);
while(*c != '.' && c > pathname) c--;
g_strlcpy(c, "-hdr.dng", sizeof(pathname)-(c-pathname));
dt_imageio_write_dng(pathname, pixels, wd, ht, exif, exif_len, filter, 1.0f);
dt_control_backgroundjobs_progress(darktable.control, jid, 1.0f);
while(*c != '/' && c > pathname) c--;
dt_control_log(_("wrote merged hdr `%s'"), c+1);
// import new image
gchar *directory = g_path_get_dirname((const gchar *)pathname);
dt_film_t film;
const int filmid = dt_film_new(&film, directory);
dt_image_import(filmid, pathname, TRUE);
g_free (directory);
free(pixels);
free(weight);
error:
dt_control_backgroundjobs_destroy(darktable.control, jid);
dt_control_queue_redraw_center();
return 0;
}
void dt_dev_process_image_job(dt_develop_t *dev)
{
dt_control_log_busy_enter();
// let gui know to draw preview instead of us, if it's there:
dev->image_dirty = 1;
dt_mipmap_buffer_t buf;
dt_times_t start;
dt_get_times(&start);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, dev->image_storage.id, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
dt_show_times(&start, "[dev]", "to load the image.");
// copy over image now that width and height are sure to be correct:
const dt_image_t *img = dt_image_cache_read_get(darktable.image_cache, dev->image_storage.id);
dev->image_storage = *img;
// but don't lock the real thing, as that would avoid any writers to change stuff.
// (such as raw loading or star rating changes)
dt_image_cache_read_release(darktable.image_cache, img);
// failed to load raw?
if(!buf.buf) return;
dt_dev_pixelpipe_set_input(dev->pipe, dev, (float *)buf.buf, buf.width, buf.height, 1.0);
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_dirty = 1;
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_dirty = 1;
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 x, y;
// adjust pipeline according to changed flag set by {add,pop}_history_item.
restart:
if(dev->gui_leaving)
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_log_busy_leave();
return;
}
dev->pipe->input_timestamp = dev->timestamp;
// this locks dev->history_mutex.
dt_dev_pixelpipe_change(dev->pipe, dev);
// determine scale according to new dimensions
DT_CTL_GET_GLOBAL(zoom, dev_zoom);
DT_CTL_GET_GLOBAL(zoom_x, dev_zoom_x);
DT_CTL_GET_GLOBAL(zoom_y, dev_zoom_y);
scale = dt_dev_get_zoom_scale(dev, zoom, 1.0f, 0);
dev->capwidth = MIN(MIN(dev->width, dev->pipe->processed_width *scale), darktable.thumbnail_width);
dev->capheight = MIN(MIN(dev->height, dev->pipe->processed_height*scale), darktable.thumbnail_height);
x = MAX(0, scale*dev->pipe->processed_width *(.5+zoom_x)-dev->capwidth/2);
y = MAX(0, scale*dev->pipe->processed_height*(.5+zoom_y)-dev->capheight/2);
dt_get_times(&start);
if(dt_dev_pixelpipe_process(dev->pipe, dev, x, y, dev->capwidth, dev->capheight, scale))
{
// interrupted because image changed?
if(dev->image_force_reload)
{
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_log_busy_leave();
return;
}
// or because the pipeline changed?
else goto restart;
}
dt_show_times(&start, "[dev_process_image] pixel pipeline processing", NULL);
// 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_dirty = 0;
dev->image_loading = 0;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_control_queue_redraw_center();
dt_control_log_busy_leave();
}
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 to display all images, otherwise view may remain empty */
dt_view_filter_reset_to_show_all(darktable.view_manager);
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_CTL_SET_GLOBAL(lib_image_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));
}
int32_t dt_control_indexer_job_run(dt_job_t *job)
{
// if no indexing was requested, bail out:
if(!dt_conf_get_bool("run_similarity_indexer")) return 0;
/*
* First pass run thru ALL images and collect the ones who needs to update
* \TODO in the future lets have a indexer table with ids filed with images
* thats need some kind of reindexing.. all mark dirty functions adds image
* to this table--
*/
// temp memory for uncompressed images:
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
GList *images=NULL;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select images.id,film_rolls.folder||'/'||images.filename,images.histogram,images.lightmap from images,film_rolls where film_rolls.id = images.film_id", -1, &stmt, NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
_control_indexer_img_t *idximg=g_malloc(sizeof( _control_indexer_img_t));
memset(idximg,0,sizeof(_control_indexer_img_t));
idximg->id = sqlite3_column_int(stmt,0);
/* first check if image file exists on disk */
const char *filename = (const char *)sqlite3_column_text(stmt, 1);
if (filename && !g_file_test(filename, G_FILE_TEST_IS_REGULAR))
idximg->flags |= _INDEXER_IMAGE_FILE_REMOVED;
/* check if histogram should be updated */
if (sqlite3_column_bytes(stmt, 2) != sizeof(dt_similarity_histogram_t))
idximg->flags |= _INDEXER_UPDATE_HISTOGRAM;
/* check if lightmap should be updated */
if (sqlite3_column_bytes(stmt, 3) != sizeof(dt_similarity_lightmap_t))
idximg->flags |= _INDEXER_UPDATE_LIGHTMAP;
/* if image is flagged add to collection */
if (idximg->flags != 0)
images = g_list_append(images, idximg);
else
g_free(idximg);
}
sqlite3_finalize(stmt);
/*
* Second pass, run thru collected images thats
* need reindexing...
*/
GList *imgitem = g_list_first(images);
if(imgitem)
{
char message[512]= {0};
double fraction=0;
int total = g_list_length(images);
guint *jid = NULL;
/* background job plate only if more then one image is reindexed */
if (total > 1)
{
snprintf(message, 512, ngettext ("re-indexing %d image", "re-indexing %d images", total), total );
jid = (guint *)dt_control_backgroundjobs_create(darktable.control, 0, message);
}
do
{
// bail out if we're shutting down:
if(!dt_control_running()) break;
// if indexer was switched off during runtime, respect that as soon as we can:
if(!dt_conf_get_bool("run_similarity_indexer")) break;
/* get the _control_indexer_img_t pointer */
_control_indexer_img_t *idximg = imgitem->data;
/*
* Check if image has been delete from disk
*/
if ((idximg->flags&_INDEXER_IMAGE_FILE_REMOVED))
{
/* file does not exist on disk lets delete image reference from database */
//char query[512]={0};
// \TODO dont delete move to an temp table and let user to revalidate
/*sprintf(query,"delete from history where imgid=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);
sprintf(query,"delete from tagged_images where imgid=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);
sprintf(query,"delete from images where id=%d",idximg->id);
DT_DEBUG_SQLITE3_EXEC(darktable.db, query, NULL, NULL, NULL);*/
/* no need to additional work */
continue;
}
/*
* Check if image histogram or lightmap should be updated.
* those indexing that involves a image pipe should fall into this
*/
if ( (idximg->flags&_INDEXER_UPDATE_HISTOGRAM) || (idximg->flags&_INDEXER_UPDATE_LIGHTMAP) )
{
/* get a mipmap of image to analyse */
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, idximg->id, DT_MIPMAP_2, DT_MIPMAP_BLOCKING);
// pointer owned by the cache or == scratchmem, no need to free this one:
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
if (!(buf.width * buf.height))
continue;
/*
* Generate similarity histogram data if requested
*/
if ( (idximg->flags&_INDEXER_UPDATE_HISTOGRAM) )
{
dt_similarity_histogram_t histogram;
float bucketscale = (float)DT_SIMILARITY_HISTOGRAM_BUCKETS/(float)0xff;
for(int j=0; j<(4*buf.width*buf.height); j+=4)
{
/* swap rgb and scale to bucket index */
uint8_t rgb[3];
for(int k=0; k<3; k++)
rgb[k] = (int)((buf_decompressed[j+2-k]/(float)0xff) * bucketscale);
/* distribute rgb into buckets */
for(int k=0; k<3; k++)
histogram.rgbl[rgb[k]][k]++;
/* distribute lum into buckets */
uint8_t lum = MAX(MAX(rgb[0], rgb[1]), rgb[2]);
histogram.rgbl[lum][3]++;
}
for(int k=0; k<DT_SIMILARITY_HISTOGRAM_BUCKETS; k++)
for (int j=0; j<4; j++)
histogram.rgbl[k][j] /= (buf.width*buf.height);
/* store the histogram data */
dt_similarity_histogram_store(idximg->id, &histogram);
}
/*
* Generate scaledowned similarity lightness map if requested
*/
if ( (idximg->flags&_INDEXER_UPDATE_LIGHTMAP) )
{
dt_similarity_lightmap_t lightmap;
memset(&lightmap,0,sizeof(dt_similarity_lightmap_t));
/*
* create a pixbuf out of the image for downscaling
*/
/* first of setup a standard rgb buffer, swap bgr in same routine */
uint8_t *rgbbuf = g_malloc(buf.width*buf.height*3);
for(int j=0; j<(buf.width*buf.height); j++)
for(int k=0; k<3; k++)
rgbbuf[3*j+k] = buf_decompressed[4*j+2-k];
/* then create pixbuf and scale down to lightmap size */
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf,GDK_COLORSPACE_RGB,FALSE,8,buf.width,buf.height,(buf.width*3),NULL,NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source,DT_SIMILARITY_LIGHTMAP_SIZE,DT_SIMILARITY_LIGHTMAP_SIZE,GDK_INTERP_HYPER);
/* copy scaled data into lightmap */
uint8_t min=0xff,max=0;
uint8_t *spixels = gdk_pixbuf_get_pixels(scaled);
for(int j=0; j<(DT_SIMILARITY_LIGHTMAP_SIZE*DT_SIMILARITY_LIGHTMAP_SIZE); j++)
{
/* copy rgb */
for(int k=0; k<3; k++)
lightmap.pixels[4*j+k] = spixels[3*j+k];
/* average intensity into 4th channel */
lightmap.pixels[4*j+3] = (lightmap.pixels[4*j+0]+ lightmap.pixels[4*j+1]+ lightmap.pixels[4*j+2])/3.0;
min = MIN(min, lightmap.pixels[4*j+3]);
max = MAX(max, lightmap.pixels[4*j+3]);
}
/* contrast stretch each channel in lightmap
* TODO: do we want this...
*/
float scale=0;
int range = max-min;
if(range==0)
scale = 1.0;
else
scale = 0xff/range;
for(int j=0; j<(DT_SIMILARITY_LIGHTMAP_SIZE*DT_SIMILARITY_LIGHTMAP_SIZE); j++)
{
for(int k=0; k<4; k++)
lightmap.pixels[4*j+k] = (lightmap.pixels[4*j+k]-min)*scale;
}
/* free some resources */
g_object_unref(scaled);
g_object_unref(source);
g_free(rgbbuf);
/* store the lightmap */
dt_similarity_lightmap_store(idximg->id, &lightmap);
}
/* no use for buffer anymore release the mipmap */
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
/* update background progress */
if (jid)
{
fraction+=1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
}
while ((imgitem=g_list_next(imgitem)) && dt_control_job_get_state(job) != DT_JOB_STATE_CANCELLED);
/* cleanup */
if (jid)
dt_control_backgroundjobs_destroy(darktable.control, jid);
}
free(scratchmem);
/*
* Indexing opertions finished, lets reschedule the indexer
* unless control is shutting down...
*/
if(dt_control_running())
dt_control_start_indexer();
return 0;
}
static void _view_map_changed_callback(OsmGpsMap *map, dt_view_t *self)
{
dt_map_t *lib = (dt_map_t *)self->data;
const int ts = 64;
OsmGpsMapPoint bb[2];
/* get bounding box coords */
osm_gps_map_get_bbox(map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom;
float center_lat, center_lon;
g_object_get(G_OBJECT(map), "zoom", &zoom, "latitude", ¢er_lat, "longitude", ¢er_lon, NULL);
dt_conf_set_float("plugins/map/longitude", center_lon);
dt_conf_set_float("plugins/map/latitude", center_lat);
dt_conf_set_int("plugins/map/zoom", zoom);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 5, center_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 6, center_lon);
/* remove the old images */
osm_gps_map_image_remove_all(map);
if(lib->images)
{
g_slist_foreach(lib->images, (GFunc) g_free, NULL);
g_slist_free(lib->images);
lib->images = NULL;
}
/* add all images to the map */
gboolean needs_redraw = FALSE;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int imgid = sqlite3_column_int(lib->statements.main_query, 0);
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, DT_MIPMAP_BEST_EFFORT);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
//TODO: add back the arrow on the left lower corner of the image, pointing to the location
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
dt_map_image_t *entry = (dt_map_image_t*)g_malloc(sizeof(dt_map_image_t));
entry->imgid = imgid;
entry->image = osm_gps_map_image_add_with_alignment(map, cimg->latitude, cimg->longitude, scaled, 0, 1);
entry->width = w;
entry->height = h;
lib->images = g_slist_prepend(lib->images, entry);
dt_image_cache_read_release(darktable.image_cache, cimg);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
g_free(rgbbuf);
}
else
needs_redraw = TRUE;
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
// not exactly thread safe, but should be good enough for updating the display
static int timeout_event_source = 0;
if(needs_redraw && timeout_event_source == 0)
timeout_event_source = g_timeout_add_seconds(1, _view_map_redraw, self); // try again in a second, maybe some pictures have loaded by then
else
timeout_event_source = 0;
}
void
dt_view_image_expose(
dt_view_image_over_t *image_over,
uint32_t imgid,
cairo_t *cr,
int32_t width,
int32_t height,
int32_t zoom,
int32_t px,
int32_t py)
{
cairo_save (cr);
float bgcol = 0.4, fontcol = 0.425, bordercol = 0.1, outlinecol = 0.2;
int selected = 0, altered = 0, imgsel;
DT_CTL_GET_GLOBAL(imgsel, lib_image_mouse_over_id);
// if(img->flags & DT_IMAGE_SELECTED) selected = 1;
/* clear and reset statements */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.have_history);
/* bind imgid to prepared statments */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.is_selected, 1, imgid);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.have_history, 1, imgid);
/* lets check if imgid is selected */
if(sqlite3_step(darktable.view_manager->statements.is_selected) == SQLITE_ROW)
selected = 1;
/* lets check if imgid has history */
if(sqlite3_step(darktable.view_manager->statements.have_history) == SQLITE_ROW)
altered = 1;
const dt_image_t *img = dt_image_cache_read_testget(darktable.image_cache, imgid);
if(selected == 1)
{
outlinecol = 0.4;
bgcol = 0.6;
fontcol = 0.5;
}
if(imgsel == imgid)
{
bgcol = 0.8; // mouse over
fontcol = 0.7;
outlinecol = 0.6;
// if the user points at this image, we really want it:
if(!img)
img = dt_image_cache_read_get(darktable.image_cache, imgid);
}
float imgwd = 0.90f;
if(zoom == 1)
{
imgwd = .97f;
// cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
}
else
{
double x0 = 1, y0 = 1, rect_width = width-2, rect_height = height-2, radius = 5;
double x1, y1, off, off1;
x1=x0+rect_width;
y1=y0+rect_height;
off=radius*0.666;
off1 = radius-off;
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0, y0+off1, x0+off1 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1-off1, y0, x1, y0+off1, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1-off1, x1-off1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0+off1, y1, x0, y1-off1, x0, y1- radius);
cairo_close_path (cr);
cairo_set_source_rgb(cr, bgcol, bgcol, bgcol);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 0.005*width);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_stroke(cr);
if(img)
{
const char *ext = img->filename + strlen(img->filename);
while(ext > img->filename && *ext != '.') ext--;
ext++;
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .25*width);
cairo_move_to (cr, .01*width, .24*height);
cairo_show_text (cr, ext);
}
}
float scale = 1.0;
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip =
dt_mipmap_cache_get_matching_size(
darktable.mipmap_cache,
imgwd*width, imgwd*height);
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
imgid,
mip,
0);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf.buf, CAIRO_FORMAT_RGB24, buf.width, buf.height, stride);
if(zoom == 1)
{
scale = fminf(
fminf(darktable.thumbnail_width, width) / (float)buf.width,
fminf(darktable.thumbnail_height, height) / (float)buf.height
);
}
else scale = fminf(width*imgwd/(float)buf.width, height*imgwd/(float)buf.height);
}
// draw centered and fitted:
cairo_save(cr);
cairo_translate(cr, width/2.0, height/2.0f);
cairo_scale(cr, scale, scale);
if(buf.buf)
{
cairo_translate(cr, -.5f*buf.width, -.5f*buf.height);
cairo_set_source_surface (cr, surface, 0, 0);
if(buf.width <= 8 && buf.height <= 8)
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_fill(cr);
cairo_surface_destroy (surface);
if(zoom == 1) cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_BEST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
}
// border around image
const float border = zoom == 1 ? 16/scale : 2/scale;
cairo_set_source_rgb(cr, bordercol, bordercol, bordercol);
if(buf.buf && selected)
{
cairo_set_line_width(cr, 1./scale);
if(zoom == 1)
{
// draw shadow around border
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_stroke(cr);
// cairo_new_path(cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
float alpha = 1.0f;
for(int k=0; k<16; k++)
{
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -k/scale, -k/scale, buf.width+2.*k/scale, buf.height+2.*k/scale);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
}
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -border, -border, buf.width+2.*border, buf.height+2.*border);
cairo_stroke_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_fill(cr);
}
}
else if(buf.buf)
{
cairo_set_line_width(cr, 1);
cairo_stroke(cr);
}
cairo_restore(cr);
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
const float fscale = fminf(width, height);
if(imgsel == imgid)
{
// draw mouseover hover effects, set event hook for mouse button down!
*image_over = DT_VIEW_DESERT;
cairo_set_line_width(cr, 1.5);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
float r1, r2;
if(zoom != 1)
{
r1 = 0.05*width;
r2 = 0.022*width;
}
else
{
r1 = 0.015*fscale;
r2 = 0.007*fscale;
}
float x, y;
if(zoom != 1) y = 0.90*height;
else y = .12*fscale;
if(img) for(int k=0; k<5; k++)
{
if(zoom != 1) x = (0.41+k*0.12)*width;
else x = (.08+k*0.04)*fscale;
if((img->flags & 0x7) != 6) //if rejected: draw no stars
{
dt_view_star(cr, x, y, r1, r2);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_STAR_1 + k;
cairo_fill(cr);
}
else if((img->flags & 0x7) > k)
{
cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
}
else cairo_stroke(cr);
}
}
//Image rejected?
if(zoom !=1) x = 0.11*width;
else x = .04*fscale;
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_REJECT; //mouse sensitive
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
}
else if (img && ((img->flags & 0x7) == 6))
{
cairo_set_source_rgb(cr, 1., 0., 0.);
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
cairo_set_line_width(cr, 2.5);
}
//reject cross:
cairo_move_to(cr, x-r2, y-r2);
cairo_line_to(cr, x+r2, y+r2);
cairo_move_to(cr, x+r2, y-r2);
cairo_line_to(cr, x-r2, y+r2);
cairo_close_path(cr);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_width(cr, 1.5);
// image altered?
if(altered)
{
// align to right
float s = (r1+r2)*.5;
if(zoom != 1)
{
x = width*0.9;
y = height*0.1;
}
else x = (.04+7*0.04)*fscale;
dt_view_draw_altered(cr, x, y, s);
//g_print("px = %d, x = %.4f, py = %d, y = %.4f\n", px, x, py, y);
if(img && abs(px-x) <= 1.2*s && abs(py-y) <= 1.2*s) // mouse hovers over the altered-icon -> history tooltip!
{
darktable.gui->center_tooltip = 1;
}
}
}
// kill all paths, in case img was not loaded yet, or is blocked:
cairo_new_path(cr);
// TODO: make mouse sensitive, just as stars!
// TODO: cache in image struct!
{
// color labels:
const float x = zoom == 1 ? (0.07)*fscale : .21*width;
const float y = zoom == 1 ? 0.17*fscale: 0.1*height;
const float r = zoom == 1 ? 0.01*fscale : 0.03*width;
/* clear and reset prepared statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_color);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_color);
/* setup statement and iterate rows */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_color, 1, imgid);
while(sqlite3_step(darktable.view_manager->statements.get_color) == SQLITE_ROW)
{
cairo_save(cr);
int col = sqlite3_column_int(darktable.view_manager->statements.get_color, 0);
// see src/dtgtk/paint.c
dtgtk_cairo_paint_label(cr, x+(3*r*col)-5*r, y-r, r*2, r*2, col);
cairo_restore(cr);
}
}
if(img && (zoom == 1))
{
// some exif data
cairo_set_source_rgb(cr, .7, .7, .7);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .025*fscale);
cairo_move_to (cr, .02*fscale, .04*fscale);
// cairo_show_text(cr, img->filename);
cairo_text_path(cr, img->filename);
char exifline[50];
cairo_move_to (cr, .02*fscale, .08*fscale);
dt_image_print_exif(img, exifline, 50);
cairo_text_path(cr, exifline);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 1.0);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_stroke(cr);
}
if(img) dt_image_cache_read_release(darktable.image_cache, img);
cairo_restore(cr);
// if(zoom == 1) cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
}
static void
_lib_filmstrip_dnd_begin_callback(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
const int ts = 64;
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *strip = (dt_lib_filmstrip_t *)self->data;
int imgid = strip->mouse_over_id;
// imgid part of selection -> do nothing
// otherwise -> select the current image
strip->select = DT_LIB_FILMSTRIP_SELECT_NONE;
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select imgid from selected_images where imgid=?1", -1, &stmt, NULL);
DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, imgid);
if(sqlite3_step(stmt) != SQLITE_ROW)
{
dt_selection_select_single(darktable.selection, imgid);
/* redraw filmstrip */
if(darktable.view_manager->proxy.filmstrip.module)
gtk_widget_queue_draw(darktable.view_manager->proxy.filmstrip.module->widget);
}
sqlite3_finalize(stmt);
// if we are dragging a single image -> use the thumbnail of that image
// otherwise use the generic d&d icon
// TODO: have something pretty in the 2nd case, too.
if(dt_collection_get_selected_count(NULL) == 1)
{
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, DT_MIPMAP_BLOCKING);
if(buf.buf)
{
uint8_t *scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
uint8_t *rgbbuf = g_malloc((buf.width+2)*(buf.height+2)*3);
memset(rgbbuf, 64, (buf.width+2)*(buf.height+2)*3);
for(int i=1; i<=buf.height; i++)
for(int j=1; j<=buf.width; j++)
for(int k=0; k<3; k++)
rgbbuf[(i*(buf.width+2)+j)*3+k] = buf_decompressed[((i-1)*buf.width+j-1)*4+2-k];
int w=ts, h=ts;
if(buf.width < buf.height) w = (buf.width*ts)/buf.height; // portrait
else h = (buf.height*ts)/buf.width; // landscape
GdkPixbuf *source = gdk_pixbuf_new_from_data(rgbbuf, GDK_COLORSPACE_RGB, FALSE, 8, (buf.width+2), (buf.height+2), (buf.width+2)*3, NULL, NULL);
GdkPixbuf *scaled = gdk_pixbuf_scale_simple(source, w, h, GDK_INTERP_HYPER);
gtk_drag_set_icon_pixbuf(context, scaled, 0, 0);
if(source)
g_object_unref(source);
if(scaled)
g_object_unref(scaled);
free(scratchmem);
g_free(rgbbuf);
}
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
}
void dt_dev_process_preview_job(dt_develop_t *dev)
{
dt_mipmap_buffer_t buf;
if(dev->image_loading)
{
// raw is already loading, no use starting another file access, we wait.
return;
}
dt_control_log_busy_enter();
dev->preview_pipe->input_timestamp = dev->timestamp;
dev->preview_dirty = 1;
// lock if there, issue a background load, if not (best-effort for mip f).
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, dev->image_storage.id, DT_MIPMAP_F, 0);
if(!buf.buf)
{
dt_control_log_busy_leave();
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);
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;
}
// always process the whole downsampled mipf buffer, to allow for fast scrolling and mip4 write-through.
restart:
if(dev->gui_leaving)
{
dt_control_log_busy_leave();
dt_mipmap_cache_read_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();
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return;
}
else goto restart;
}
dt_show_times(&start, "[dev_process_preview] pixel pipeline processing", NULL);
dev->preview_dirty = 0;
dt_control_log_busy_leave();
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
}
static void _view_map_post_expose(cairo_t *cri, int32_t width_i, int32_t height_i,
int32_t pointerx, int32_t pointery, gpointer user_data)
{
const int ts = 64;
OsmGpsMapPoint bb[2], *l=NULL, *center=NULL;
int px,py;
dt_map_t *lib = (dt_map_t *)user_data;
/* get bounding box coords */
osm_gps_map_get_bbox(lib->map, &bb[0], &bb[1]);
float bb_0_lat = 0.0, bb_0_lon = 0.0, bb_1_lat = 0.0, bb_1_lon = 0.0;
osm_gps_map_point_get_degrees(&bb[0], &bb_0_lat, &bb_0_lon);
osm_gps_map_point_get_degrees(&bb[1], &bb_1_lat, &bb_1_lon);
/* make the bounding box a little bigger to the west and south */
float lat0 = 0.0, lon0 = 0.0, lat1 = 0.0, lon1 = 0.0;
OsmGpsMapPoint *pt0 = osm_gps_map_point_new_degrees(0.0, 0.0), *pt1 = osm_gps_map_point_new_degrees(0.0, 0.0);
osm_gps_map_convert_screen_to_geographic(lib->map, 0, 0, pt0);
osm_gps_map_convert_screen_to_geographic(lib->map, 1.5*ts, 1.5*ts, pt1);
osm_gps_map_point_get_degrees(pt0, &lat0, &lon0);
osm_gps_map_point_get_degrees(pt1, &lat1, &lon1);
osm_gps_map_point_free(pt0);
osm_gps_map_point_free(pt1);
double south_border = lat0 - lat1, west_border = lon1 - lon0;
/* get map view state and store */
int zoom = osm_gps_map_get_zoom(lib->map);
center = osm_gps_map_get_center(lib->map);
dt_conf_set_float("plugins/map/longitude", center->rlon);
dt_conf_set_float("plugins/map/latitude", center->rlat);
dt_conf_set_int("plugins/map/zoom", zoom);
osm_gps_map_point_free(center);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* bind bounding box coords for the main query */
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 1, bb_0_lon - west_border);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 2, bb_1_lon);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 3, bb_0_lat);
DT_DEBUG_SQLITE3_BIND_DOUBLE(lib->statements.main_query, 4, bb_1_lat - south_border);
/* query collection ids */
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
{
int32_t imgid = sqlite3_column_int(lib->statements.main_query, 0);
cairo_set_source_rgba(cri, 0, 0, 0, 0.4);
/* free l if allocated */
if (l)
osm_gps_map_point_free(l);
/* for each image check if within bbox */
const dt_image_t *cimg = dt_image_cache_read_get(darktable.image_cache, imgid);
double longitude = cimg->longitude;
double latitude = cimg->latitude;
dt_image_cache_read_release(darktable.image_cache, cimg);
if(isnan(latitude) || isnan(longitude))
continue;
l = osm_gps_map_point_new_degrees(latitude, longitude);
/* translate l into screen coords */
osm_gps_map_convert_geographic_to_screen(lib->map, l, &px, &py);
/* dependent on scale draw different overlays */
if (zoom >= 14)
{
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(darktable.mipmap_cache, ts, ts);
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, mip, 0);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
float ms = fminf(
ts/(float)buf.width,
ts/(float)buf.height);
#if 0
// this doesn't work since osm-gps-map always gives 0/0 as mouse coords :(
/* find out if the cursor is over the image */
if(pointerx >= px && pointerx <= (px + buf.width*ms + 4) && pointery <= (py - 8) && pointery >= (py - buf.height*ms - 8 - 4))
{
printf("over\n");
cairo_set_source_rgba(cri, 1, 0, 0, 0.7);
}
// else
// printf("%d/%d, %d/%d\n", px, py, pointerx, pointery);
#endif
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf.buf, CAIRO_FORMAT_RGB24,
buf.width, buf.height, stride);
cairo_pattern_set_filter(cairo_get_source(cri), CAIRO_FILTER_NEAREST);
cairo_save(cri);
/* first of lets draw a pin */
cairo_move_to(cri, px, py);
cairo_line_to(cri, px+8, py-8);
cairo_line_to(cri, px+4, py-8);
cairo_fill(cri);
/* and the frame around image */
cairo_move_to(cri, px+2, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4, py-8);
cairo_line_to(cri, px+2 + (buf.width*ms) + 4 , py-8-(buf.height*ms) - 4);
cairo_line_to(cri, px+2 , py-8-(buf.height*ms) - 4);
cairo_fill(cri);
/* draw image*/
cairo_translate(cri, px+4, py - 8 - (buf.height*ms) - 2);
cairo_scale(cri, ms, ms);
cairo_set_source_surface (cri, surface, 0, 0);
cairo_paint(cri);
cairo_restore(cri);
cairo_surface_destroy(surface);
}
}
else
{
/* just draw a patch indicating that there is images at the location */
cairo_rectangle(cri, px-8, py-8, 16, 16);
cairo_fill(cri);
}
}
}
// 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 int32_t thumbnail_export,
const char *filter,
const gboolean copy_metadata,
dt_imageio_module_storage_t *storage,
dt_imageio_module_data_t *storage_params)
{
dt_develop_t dev;
dt_dev_init(&dev, 0);
dt_mipmap_buffer_t buf;
if(thumbnail_export && dt_conf_get_bool("plugins/lighttable/low_quality_thumbnails"))
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_F, DT_MIPMAP_BLOCKING);
else
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
dt_dev_load_image(&dev, imgid);
const dt_image_t *img = &dev.image_storage;
const int wd = img->width;
const int ht = img->height;
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"));
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 1;
}
if(!buf.buf)
{
dt_control_log(_("image `%s' is not available!"), img->filename);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_dev_cleanup(&dev);
return 1;
}
// 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);
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 1;
}
// Add each params
while (stls)
{
dt_style_item_t *s = (dt_style_item_t *) stls->data;
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));
h->params = s->params;
h->blend_params = s->blendop_params;
h->enabled = s->enabled;
h->module = m;
h->multi_priority = 1;
g_strlcpy(h->multi_name, "", 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);
break;
}
modules = g_list_next(modules);
}
stls = g_list_next(stls);
}
}
dt_dev_pixelpipe_set_input(&pipe, &dev, (float *)buf.buf, buf.width, buf.height, 1.0);
dt_dev_pixelpipe_create_nodes(&pipe, &dev);
dt_dev_pixelpipe_synch_all(&pipe, &dev);
dt_dev_pixelpipe_get_dimensions(&pipe, &dev, pipe.iwidth, pipe.iheight, &pipe.processed_width, &pipe.processed_height);
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_show_times(&start, "[export] creating pixelpipe", NULL);
// find output color profile for this image:
int sRGB = 1;
gchar *overprofile = dt_conf_get_string("plugins/lighttable/export/iccprofile");
if(overprofile && !strcmp(overprofile, "sRGB"))
{
sRGB = 1;
}
else if(!overprofile || !strcmp(overprofile, "image"))
{
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 char *iccprofile = colorout->get_p(colorout->params, "iccprofile");
if(!strcmp(iccprofile, "sRGB")) sRGB = 1;
else sRGB = 0;
}
modules = g_list_next(modules);
}
}
else
{
sRGB = 0;
}
g_free(overprofile);
// 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, 1.0) : 1.0;
const double scaley = height > 0 ? fminf(height/(double)pipe.processed_height, 1.0) : 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);
// downsampling done last, if high quality processing was requested:
uint8_t *outbuf = pipe.backbuf;
uint8_t *moutbuf = NULL; // keep track of alloc'ed memory
dt_get_times(&start);
if(high_quality_processing)
{
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
const double scalex = format_params->max_width > 0 ? fminf(format_params->max_width /(double)pipe.processed_width, 1.0) : 1.0;
const double scaley = format_params->max_height > 0 ? fminf(format_params->max_height/(double)pipe.processed_height, 1.0) : 1.0;
const double scale = fminf(scalex, scaley);
processed_width = scale*pipe.processed_width + .5f;
processed_height = scale*pipe.processed_height + .5f;
moutbuf = (uint8_t *)dt_alloc_align(64, (size_t)sizeof(float)*processed_width*processed_height*4);
outbuf = moutbuf;
// now downscale into the new buffer:
dt_iop_roi_t roi_in, roi_out;
roi_in.x = roi_in.y = roi_out.x = roi_out.y = 0;
roi_in.scale = 1.0;
roi_out.scale = scale;
roi_in.width = pipe.processed_width;
roi_in.height = pipe.processed_height;
roi_out.width = processed_width;
roi_out.height = processed_height;
dt_iop_clip_and_zoom((float *)outbuf, (float *)pipe.backbuf, &roi_out, &roi_in, processed_width, pipe.processed_width);
}
else
{
// 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);
outbuf = pipe.backbuf;
}
dt_show_times(&start, thumbnail_export ? "[dev_process_thumbnail] pixel pipeline processing" : "[dev_process_export] pixel pipeline processing", NULL);
// 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];
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);
}
else
{
res = format->write_image (format_params, filename, outbuf, NULL, 0, imgid);
}
dt_dev_pixelpipe_cleanup(&pipe);
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
dt_free_align(moutbuf);
/* 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"))
{
dt_control_signal_raise(darktable.signals,DT_SIGNAL_IMAGE_EXPORT_TMPFILE,imgid,filename,format,format_params,storage,storage_params);
}
return res;
}
static void
expose_filemanager (dt_view_t *self, cairo_t *cr, int32_t width, int32_t height, int32_t pointerx, int32_t pointery)
{
dt_library_t *lib = (dt_library_t *)self->data;
gboolean offset_changed = FALSE;
/* query new collection count */
lib->collection_count = dt_collection_get_count (darktable.collection);
if(darktable.gui->center_tooltip == 1)
darktable.gui->center_tooltip = 2;
/* get grid stride */
const int iir = dt_conf_get_int("plugins/lighttable/images_in_row");
/* get image over id */
lib->image_over = DT_VIEW_DESERT;
int32_t mouse_over_id, mouse_over_group = -1;
DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id);
/* fill background */
cairo_set_source_rgb (cr, .2, .2, .2);
cairo_paint(cr);
if(lib->first_visible_zoomable >= 0)
{
lib->offset = lib->first_visible_zoomable;
}
lib->first_visible_zoomable = -1;
/* check if offset has been changed */
if(lib->track > 2) lib->offset += iir;
if(lib->track < -2) lib->offset -= iir;
lib->track = 0;
if(lib->center) lib->offset = 0;
lib->center = 0;
int offset = lib->offset;
/* if offset differs then flag as changed */
if (offset != lib->first_visible_filemanager)
offset_changed = TRUE;
lib->first_visible_filemanager = offset;
static int oldpan = 0;
const int pan = lib->pan;
const float wd = width/(float)iir;
const float ht = width/(float)iir;
int pi = pointerx / (float)wd;
int pj = pointery / (float)ht;
if(pointerx < 0 || pointery < 0) pi = pj = -1;
//const int pidx = grid_to_index(pj, pi, iir, offset);
const int img_pointerx = iir == 1 ? pointerx : fmodf(pointerx, wd);
const int img_pointery = iir == 1 ? pointery : fmodf(pointery, ht);
const int max_rows = 1 + (int)((height)/ht + .5);
const int max_cols = iir;
int id;
int clicked1 = (oldpan == 0 && pan == 1 && lib->button == 1);
/* get the count of current collection */
if(lib->collection_count == 0)
{
const float fs = 15.0f;
const float ls = 1.5f*fs;
const float offy = height*0.2f;
const float offx = 60;
const float at = 0.3f;
cairo_set_font_size(cr, fs);
cairo_set_source_rgba(cr, .7, .7, .7, 1.0f);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_move_to(cr, offx, offy);
cairo_show_text(cr, _("there are no images in this collection"));
cairo_move_to(cr, offx, offy + 2*ls);
cairo_show_text(cr, _("if you have not imported any images yet"));
cairo_move_to(cr, offx, offy + 3*ls);
cairo_show_text(cr, _("you can do so in the import module"));
cairo_move_to(cr, offx - 10.0f, offy + 3*ls - ls*.25f);
cairo_line_to(cr, 0.0f, 10.0f);
cairo_set_source_rgba(cr, .7, .7, .7, at);
cairo_stroke(cr);
cairo_move_to(cr, offx, offy + 5*ls);
cairo_set_source_rgba(cr, .7, .7, .7, 1.0f);
cairo_show_text(cr, _("try to relax the filter settings in the top panel"));
cairo_rel_move_to(cr, 10.0f, -ls*.25f);
cairo_line_to(cr, width*0.5f, 0.0f);
cairo_set_source_rgba(cr, .7, .7, .7, at);
cairo_stroke(cr);
cairo_move_to(cr, offx, offy + 6*ls);
cairo_set_source_rgba(cr, .7, .7, .7, 1.0f);
cairo_show_text(cr, _("or add images in the collection module in the left panel"));
cairo_move_to(cr, offx - 10.0f, offy + 6*ls - ls*0.25f);
cairo_rel_line_to(cr, - offx + 10.0f, 0.0f);
cairo_set_source_rgba(cr, .7, .7, .7, at);
cairo_stroke(cr);
return;
}
/* do we have a main query collection statement */
if(!lib->statements.main_query)
return;
if(offset < 0)
lib->offset = offset = 0;
while(offset >= lib->collection_count)
lib->offset = (offset -= iir);
/* update scroll borders */
dt_view_set_scrollbar(self, 0, 1, 1, offset, lib->collection_count, max_rows*iir);
/* let's reset and reuse the main_query statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* setup offset and row for the main query */
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.main_query, 1, offset);
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.main_query, 2, max_rows*iir);
if(mouse_over_id != -1)
{
const dt_image_t *mouse_over_image = dt_image_cache_read_get(darktable.image_cache, mouse_over_id);
mouse_over_group = mouse_over_image->group_id;
dt_image_cache_read_release(darktable.image_cache, mouse_over_image);
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.is_grouped);
DT_DEBUG_SQLITE3_RESET(lib->statements.is_grouped);
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.is_grouped, 1, mouse_over_group);
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.is_grouped, 2, mouse_over_id);
if(sqlite3_step(lib->statements.is_grouped) != SQLITE_ROW)
mouse_over_group = -1;
}
// prefetch the ids so that we can peek into the future to see if there are adjacent images in the same group.
int *query_ids = g_malloc0(max_rows*max_cols*sizeof(int));
for(int row = 0; row < max_rows; row++)
{
for(int col = 0; col < max_cols; col++)
{
if(sqlite3_step(lib->statements.main_query) == SQLITE_ROW)
query_ids[row*iir+col] = sqlite3_column_int(lib->statements.main_query, 0);
else goto end_query_cache;
}
}
end_query_cache:
cairo_save(cr);
for(int row = 0; row < max_rows; row++)
{
for(int col = 0; col < max_cols; col++)
{
//curidx = grid_to_index(row, col, iir, offset);
id = query_ids[row*iir+col];
if(id > 0)
{
if (iir == 1 && row)
continue;
/* set mouse over id if pointer is in current row / col */
if(pi == col && pj == row)
{
mouse_over_id = id;
DT_CTL_SET_GLOBAL(lib_image_mouse_over_id, mouse_over_id);
}
/* handle mouse click on current row / col
this could easily and preferable be moved to button_pressed()
*/
if (clicked1 && (pi == col && pj == row))
{
if ((lib->modifiers & (GDK_SHIFT_MASK|GDK_CONTROL_MASK)) == 0)
dt_selection_select_single(darktable.selection, id);
else if ((lib->modifiers & (GDK_CONTROL_MASK)) == GDK_CONTROL_MASK)
dt_selection_toggle(darktable.selection, id);
else if ((lib->modifiers & (GDK_SHIFT_MASK)) == GDK_SHIFT_MASK)
dt_selection_select_range(darktable.selection, id);
}
cairo_save(cr);
// if(iir == 1) dt_image_prefetch(image, DT_IMAGE_MIPF);
dt_view_image_expose(&(lib->image_over), id, cr, wd, iir == 1 ? height : ht, iir, img_pointerx, img_pointery);
cairo_restore(cr);
}
else
goto failure;
cairo_translate(cr, wd, 0.0f);
}
cairo_translate(cr, -max_cols*wd, ht);
}
cairo_restore(cr);
// and now the group borders
for(int row = 0; row < max_rows; row++)
{
for(int col = 0; col < max_cols; col++)
{
id = query_ids[row*iir+col];
if(id > 0)
{
const dt_image_t *image = dt_image_cache_read_get(darktable.image_cache, id);
int group_id = -1;
if(image)
group_id = image->group_id;
dt_image_cache_read_release(darktable.image_cache, image);
if (iir == 1 && row)
continue;
cairo_save(cr);
gboolean paint_border = FALSE;
// regular highlight border
if(group_id != -1)
{
if(mouse_over_group == group_id && iir > 1 && ((!darktable.gui->grouping && dt_conf_get_bool("plugins/lighttable/draw_group_borders")) || group_id == darktable.gui->expanded_group_id))
{
cairo_set_source_rgb(cr, 1, 0.8, 0);
paint_border = TRUE;
}
// border of expanded group
else if(darktable.gui->grouping && group_id == darktable.gui->expanded_group_id && iir > 1)
{
cairo_set_source_rgb(cr, 0, 0, 1);
paint_border = TRUE;
}
}
if(paint_border)
{
int neighbour_group = -1;
// top border
if(row > 0)
{
int _id = query_ids[(row-1)*iir+col];
if(_id > 0)
{
const dt_image_t *_img = dt_image_cache_read_get(darktable.image_cache, _id);
neighbour_group = _img->group_id;
dt_image_cache_read_release(darktable.image_cache, _img);
}
}
if(neighbour_group != group_id)
{
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, wd, 0);
}
// left border
neighbour_group = -1;
if(col > 0)
{
int _id = query_ids[row*iir+(col-1)];
if(_id > 0)
{
const dt_image_t *_img = dt_image_cache_read_get(darktable.image_cache, _id);
neighbour_group = _img->group_id;
dt_image_cache_read_release(darktable.image_cache, _img);
}
}
if(neighbour_group != group_id)
{
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, 0, ht);
}
// bottom border
neighbour_group = -1;
if(row < max_rows-1)
{
int _id = query_ids[(row+1)*iir+col];
if(_id > 0)
{
const dt_image_t *_img = dt_image_cache_read_get(darktable.image_cache, _id);
neighbour_group = _img->group_id;
dt_image_cache_read_release(darktable.image_cache, _img);
}
}
if(neighbour_group != group_id)
{
cairo_move_to(cr, 0, ht);
cairo_line_to(cr, wd, ht);
}
// right border
neighbour_group = -1;
if(col < max_cols-1)
{
int _id = query_ids[row*iir+(col+1)];
if(_id > 0)
{
const dt_image_t *_img = dt_image_cache_read_get(darktable.image_cache, _id);
neighbour_group = _img->group_id;
dt_image_cache_read_release(darktable.image_cache, _img);
}
}
if(neighbour_group != group_id)
{
cairo_move_to(cr, wd, 0);
cairo_line_to(cr, wd, ht);
}
cairo_set_line_width(cr, 0.01*wd);
cairo_stroke(cr);
}
cairo_restore(cr);
}
else
goto failure;
cairo_translate(cr, wd, 0.0f);
}
cairo_translate(cr, -max_cols*wd, ht);
}
/* check if offset was changed and we need to prefetch thumbs */
if (offset_changed)
{
int32_t imgids_num = 0;
const int prefetchrows = .5*max_rows+1;
int32_t imgids[prefetchrows*iir];
/* clear and reset main query */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(lib->statements.main_query);
DT_DEBUG_SQLITE3_RESET(lib->statements.main_query);
/* setup offest and row for prefetch */
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.main_query, 1, offset + max_rows*iir);
DT_DEBUG_SQLITE3_BIND_INT(lib->statements.main_query, 2, prefetchrows*iir);
// prefetch jobs in inverse order: supersede previous jobs: most important last
while(sqlite3_step(lib->statements.main_query) == SQLITE_ROW && imgids_num < prefetchrows*iir)
imgids[imgids_num++] = sqlite3_column_int(lib->statements.main_query, 0);
float imgwd = iir == 1 ? 0.97 : 0.8;
dt_mipmap_size_t mip = dt_mipmap_cache_get_matching_size(
darktable.mipmap_cache,
imgwd*wd, imgwd*(iir==1?height:ht));
while(imgids_num > 0)
{
imgids_num --;
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
imgids[imgids_num],
mip,
DT_MIPMAP_PREFETCH);
}
}
failure:
g_free(query_ids);
oldpan = pan;
if(darktable.unmuted & DT_DEBUG_CACHE)
dt_mipmap_cache_print(darktable.mipmap_cache);
if(darktable.gui->center_tooltip == 1) // set in this round
{
char* tooltip = dt_history_get_items_as_string(mouse_over_id);
if(tooltip != NULL)
{
g_object_set(G_OBJECT(dt_ui_center(darktable.gui->ui)), "tooltip-text", tooltip, (char *)NULL);
g_free(tooltip);
}
}
else if(darktable.gui->center_tooltip == 2) // not set in this round
{
darktable.gui->center_tooltip = 0;
g_object_set(G_OBJECT(dt_ui_center(darktable.gui->ui)), "tooltip-text", "", (char *)NULL);
}
}
// 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 int32_t high_quality,
const int32_t thumbnail_export)
{
dt_develop_t dev;
dt_dev_init(&dev, 0);
dt_mipmap_buffer_t buf;
dt_mipmap_cache_read_get(darktable.mipmap_cache, &buf, imgid, DT_MIPMAP_FULL, DT_MIPMAP_BLOCKING);
dt_dev_load_image(&dev, imgid);
const dt_image_t *img = &dev.image_storage;
const int wd = img->width;
const int ht = img->height;
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);
if(!res)
{
dt_control_log(_("failed to allocate memory for export, please lower the threads used for export or buy more memory."));
dt_dev_cleanup(&dev);
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
return 1;
}
if(!buf.buf)
{
dt_control_log(_("image `%s' is not available!"), img->filename);
dt_dev_cleanup(&dev);
return 1;
}
dt_dev_pixelpipe_set_input(&pipe, &dev, (float *)buf.buf, buf.width, buf.height, 1.0);
dt_dev_pixelpipe_create_nodes(&pipe, &dev);
dt_dev_pixelpipe_synch_all(&pipe, &dev);
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;
gchar *overprofile = dt_conf_get_string("plugins/lighttable/export/iccprofile");
if(overprofile && !strcmp(overprofile, "sRGB"))
{
sRGB = 1;
}
else if(!overprofile || !strcmp(overprofile, "image"))
{
GList *modules = dev.iop;
dt_iop_module_t *colorout = NULL;
while (modules)
{
colorout = (dt_iop_module_t *)modules->data;
if (strcmp(colorout->op, "colorout") == 0)
{
dt_iop_colorout_params_t *p = (dt_iop_colorout_params_t *)colorout->params;
if(!strcmp(p->iccprofile, "sRGB")) sRGB = 1;
else sRGB = 0;
}
modules = g_list_next(modules);
}
}
else
{
sRGB = 0;
}
g_free(overprofile);
// get only once at the beginning, in case the user changes it on the way:
const int 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)) ? 0 :
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 float scalex = width > 0 ? fminf(width /(float)pipe.processed_width, 1.0) : 1.0;
const float scaley = height > 0 ? fminf(height/(float)pipe.processed_height, 1.0) : 1.0;
const float scale = fminf(scalex, scaley);
int processed_width = scale*pipe.processed_width;
int processed_height = scale*pipe.processed_height;
const int bpp = format->bpp(format_params);
// downsampling done last, if high quality processing was requested:
uint8_t *outbuf = pipe.backbuf;
uint8_t *moutbuf = NULL; // keep track of alloc'ed memory
if(high_quality_processing)
{
dt_dev_pixelpipe_process_no_gamma(&pipe, &dev, 0, 0, processed_width, processed_height, scale);
const float scalex = format_params->max_width > 0 ? fminf(format_params->max_width /(float)pipe.processed_width, 1.0) : 1.0;
const float scaley = format_params->max_height > 0 ? fminf(format_params->max_height/(float)pipe.processed_height, 1.0) : 1.0;
const float scale = fminf(scalex, scaley);
processed_width = scale*pipe.processed_width + .5f;
processed_height = scale*pipe.processed_height + .5f;
moutbuf = (uint8_t *)dt_alloc_align(64, sizeof(float)*processed_width*processed_height*4);
outbuf = moutbuf;
// now downscale into the new buffer:
dt_iop_roi_t roi_in, roi_out;
roi_in.x = roi_in.y = roi_out.x = roi_out.y = 0;
roi_in.scale = 1.0;
roi_out.scale = scale;
roi_in.width = pipe.processed_width;
roi_in.height = pipe.processed_height;
roi_out.width = processed_width;
roi_out.height = processed_height;
dt_iop_clip_and_zoom((float *)outbuf, (float *)pipe.backbuf, &roi_out, &roi_in, processed_width, pipe.processed_width);
}
else
{
// 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);
outbuf = pipe.backbuf;
}
// downconversion to low-precision formats:
if(bpp == 8 && !display_byteorder)
{
// ldr output: char
if(high_quality_processing)
{
const float *const inbuf = (float *)outbuf;
for(int k=0; k<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
{
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(int k=0; k<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 int k = x + processed_width*y;
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[1024];
dt_image_full_path(imgid, pathname, 1024);
length = dt_exif_read_blob(exif_profile, pathname, sRGB, imgid);
res = format->write_image (format_params, filename, outbuf, exif_profile, length, imgid);
}
else
{
res = format->write_image (format_params, filename, outbuf, NULL, 0, imgid);
}
dt_dev_pixelpipe_cleanup(&pipe);
dt_dev_cleanup(&dev);
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
free(moutbuf);
return res;
}
void
dt_view_image_expose(
dt_view_image_over_t *image_over,
uint32_t imgid,
cairo_t *cr,
int32_t width,
int32_t height,
int32_t zoom,
int32_t px,
int32_t py)
{
const double start = dt_get_wtime();
// some performance tuning stuff, for your pleasure.
// on my machine with 7 image per row it seems grouping has the largest
// impact from around 400ms -> 55ms per redraw.
#define DRAW_THUMB 1
#define DRAW_COLORLABELS 1
#define DRAW_GROUPING 1
#define DRAW_SELECTED 1
#define DRAW_HISTORY 1
#if DRAW_THUMB == 1
// this function is not thread-safe (gui-thread only), so we
// can safely allocate this leaking bit of memory to decompress thumbnails:
static int first_time = 1;
static uint8_t *scratchmem = NULL;
if(first_time)
{
// scratchmem might still be NULL after this, if compression is off.
scratchmem = dt_mipmap_cache_alloc_scratchmem(darktable.mipmap_cache);
first_time = 0;
}
#endif
cairo_save (cr);
float bgcol = 0.4, fontcol = 0.425, bordercol = 0.1, outlinecol = 0.2;
int selected = 0, altered = 0, imgsel = -1, is_grouped = 0;
// this is a gui thread only thing. no mutex required:
imgsel = darktable.control->global_settings.lib_image_mouse_over_id;
#if DRAW_SELECTED == 1
/* clear and reset statements */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.is_selected);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.is_selected);
/* bind imgid to prepared statments */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.is_selected, 1, imgid);
/* lets check if imgid is selected */
if(sqlite3_step(darktable.view_manager->statements.is_selected) == SQLITE_ROW)
selected = 1;
#endif
#if DRAW_HISTORY == 1
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.have_history);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.have_history, 1, imgid);
/* lets check if imgid has history */
if(sqlite3_step(darktable.view_manager->statements.have_history) == SQLITE_ROW)
altered = 1;
#endif
const dt_image_t *img = dt_image_cache_read_testget(darktable.image_cache, imgid);
#if DRAW_GROUPING == 1
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_grouped);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_grouped);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_grouped, 1, imgid);
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_grouped, 2, imgid);
/* lets check if imgid is in a group */
if(sqlite3_step(darktable.view_manager->statements.get_grouped) == SQLITE_ROW)
is_grouped = 1;
else if(img && darktable.gui->expanded_group_id == img->group_id)
darktable.gui->expanded_group_id = -1;
#endif
if(selected == 1)
{
outlinecol = 0.4;
bgcol = 0.6;
fontcol = 0.5;
}
if(imgsel == imgid)
{
bgcol = 0.8; // mouse over
fontcol = 0.7;
outlinecol = 0.6;
// if the user points at this image, we really want it:
if(!img)
img = dt_image_cache_read_get(darktable.image_cache, imgid);
}
float imgwd = 0.90f;
if(zoom == 1)
{
imgwd = .97f;
// cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
}
else
{
double x0 = 1, y0 = 1, rect_width = width-2, rect_height = height-2, radius = 5;
double x1, y1, off, off1;
x1=x0+rect_width;
y1=y0+rect_height;
off=radius*0.666;
off1 = radius-off;
cairo_move_to (cr, x0, y0 + radius);
cairo_curve_to (cr, x0, y0+off1, x0+off1 , y0, x0 + radius, y0);
cairo_line_to (cr, x1 - radius, y0);
cairo_curve_to (cr, x1-off1, y0, x1, y0+off1, x1, y0 + radius);
cairo_line_to (cr, x1 , y1 - radius);
cairo_curve_to (cr, x1, y1-off1, x1-off1, y1, x1 - radius, y1);
cairo_line_to (cr, x0 + radius, y1);
cairo_curve_to (cr, x0+off1, y1, x0, y1-off1, x0, y1- radius);
cairo_close_path (cr);
cairo_set_source_rgb(cr, bgcol, bgcol, bgcol);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 0.005*width);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_stroke(cr);
if(img)
{
const char *ext = img->filename + strlen(img->filename);
while(ext > img->filename && *ext != '.') ext--;
ext++;
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .25*width);
cairo_text_extents_t text_extends;
cairo_text_extents (cr, ext, &text_extends);
cairo_move_to (cr, .025*width - text_extends.x_bearing, .24*height);
cairo_show_text (cr, ext);
}
}
dt_mipmap_buffer_t buf;
dt_mipmap_size_t mip =
dt_mipmap_cache_get_matching_size(
darktable.mipmap_cache,
imgwd*width, imgwd*height);
dt_mipmap_cache_read_get(
darktable.mipmap_cache,
&buf,
imgid,
mip,
0);
#if DRAW_THUMB == 1
float scale = 1.0;
// decompress image, if necessary. if compression is off, scratchmem will be == NULL,
// so get the real pointer back:
uint8_t *buf_decompressed = dt_mipmap_cache_decompress(&buf, scratchmem);
cairo_surface_t *surface = NULL;
if(buf.buf)
{
const int32_t stride = cairo_format_stride_for_width (CAIRO_FORMAT_RGB24, buf.width);
surface = cairo_image_surface_create_for_data (buf_decompressed, CAIRO_FORMAT_RGB24, buf.width, buf.height, stride);
if(zoom == 1)
{
scale = fminf(
fminf(darktable.thumbnail_width, width) / (float)buf.width,
fminf(darktable.thumbnail_height, height) / (float)buf.height
);
}
else scale = fminf(width*imgwd/(float)buf.width, height*imgwd/(float)buf.height);
}
// draw centered and fitted:
cairo_save(cr);
cairo_translate(cr, width/2.0, height/2.0f);
cairo_scale(cr, scale, scale);
if(buf.buf)
{
cairo_translate(cr, -.5f*buf.width, -.5f*buf.height);
cairo_set_source_surface (cr, surface, 0, 0);
// set filter no nearest:
// in skull mode, we want to see big pixels.
// in 1 iir mode for the right mip, we want to see exactly what the pipe gave us, 1:1 pixel for pixel.
// in between, filtering just makes stuff go unsharp.
if((buf.width <= 8 && buf.height <= 8) || fabsf(scale - 1.0f) < 0.01f)
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_fill(cr);
cairo_surface_destroy (surface);
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
}
// border around image
const float border = zoom == 1 ? 16/scale : 2/scale;
cairo_set_source_rgb(cr, bordercol, bordercol, bordercol);
if(buf.buf && selected)
{
cairo_set_line_width(cr, 1./scale);
if(zoom == 1)
{
// draw shadow around border
cairo_set_source_rgb(cr, 0.2, 0.2, 0.2);
cairo_stroke(cr);
// cairo_new_path(cr);
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
float alpha = 1.0f;
for(int k=0; k<16; k++)
{
cairo_rectangle(cr, 0, 0, buf.width, buf.height);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -k/scale, -k/scale, buf.width+2.*k/scale, buf.height+2.*k/scale);
cairo_set_source_rgba(cr, 0, 0, 0, alpha);
alpha *= 0.6f;
cairo_fill(cr);
}
}
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_new_sub_path(cr);
cairo_rectangle(cr, -border, -border, buf.width+2.*border, buf.height+2.*border);
cairo_stroke_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_fill(cr);
}
}
else if(buf.buf)
{
cairo_set_line_width(cr, 1);
cairo_stroke(cr);
}
cairo_restore(cr);
#endif
if(buf.buf)
dt_mipmap_cache_read_release(darktable.mipmap_cache, &buf);
const float fscale = fminf(width, height);
if(imgsel == imgid)
{
// draw mouseover hover effects, set event hook for mouse button down!
*image_over = DT_VIEW_DESERT;
cairo_set_line_width(cr, 1.5);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
float r1, r2;
if(zoom != 1)
{
r1 = 0.05*width;
r2 = 0.022*width;
}
else
{
r1 = 0.015*fscale;
r2 = 0.007*fscale;
}
float x, y;
if(zoom != 1) y = 0.90*height;
else y = .12*fscale;
gboolean image_is_rejected = (img && ((img->flags & 0x7) == 6));
if(img) for(int k=0; k<5; k++)
{
if(zoom != 1) x = (0.41+k*0.12)*width;
else x = (.08+k*0.04)*fscale;
if(!image_is_rejected) //if rejected: draw no stars
{
dt_view_star(cr, x, y, r1, r2);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_STAR_1 + k;
cairo_fill(cr);
}
else if((img->flags & 0x7) > k)
{
cairo_fill_preserve(cr);
cairo_set_source_rgb(cr, 1.0-bordercol, 1.0-bordercol, 1.0-bordercol);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
}
else cairo_stroke(cr);
}
}
//Image rejected?
if(zoom !=1) x = 0.11*width;
else x = .04*fscale;
if (image_is_rejected)
cairo_set_source_rgb(cr, 1., 0., 0.);
if((px - x)*(px - x) + (py - y)*(py - y) < r1*r1)
{
*image_over = DT_VIEW_REJECT; //mouse sensitive
cairo_new_sub_path(cr);
cairo_arc(cr, x, y, (r1+r2)*.5, 0, 2.0f*M_PI);
cairo_stroke(cr);
}
if (image_is_rejected)
cairo_set_line_width(cr, 2.5);
//reject cross:
cairo_move_to(cr, x-r2, y-r2);
cairo_line_to(cr, x+r2, y+r2);
cairo_move_to(cr, x+r2, y-r2);
cairo_line_to(cr, x-r2, y+r2);
cairo_close_path(cr);
cairo_stroke(cr);
cairo_set_source_rgb(cr, outlinecol, outlinecol, outlinecol);
cairo_set_line_width(cr, 1.5);
// image part of a group?
if(is_grouped && darktable.gui && darktable.gui->grouping)
{
// draw grouping icon and border if the current group is expanded
// align to the right, left of altered
float s = (r1+r2)*.75;
float _x, _y;
if(zoom != 1)
{
_x = width*0.9 - s*2.5;
_y = height*0.1 - s*.4;
}
else
{
_x = (.04+7*0.04-1.1*.04)*fscale;
_y = y - (.17*.04)*fscale;
}
cairo_save(cr);
if(img && (imgid != img->group_id))
cairo_set_source_rgb(cr, fontcol, fontcol, fontcol);
dtgtk_cairo_paint_grouping(cr, _x, _y, s, s, 23);
cairo_restore(cr);
// mouse is over the grouping icon
if(img && abs(px-_x-.5*s) <= .8*s && abs(py-_y-.5*s) <= .8*s)
*image_over = DT_VIEW_GROUP;
}
// image altered?
if(altered)
{
// align to right
float s = (r1+r2)*.5;
if(zoom != 1)
{
x = width*0.9;
y = height*0.1;
}
else x = (.04+7*0.04)*fscale;
dt_view_draw_altered(cr, x, y, s);
//g_print("px = %d, x = %.4f, py = %d, y = %.4f\n", px, x, py, y);
if(img && abs(px-x) <= 1.2*s && abs(py-y) <= 1.2*s) // mouse hovers over the altered-icon -> history tooltip!
{
darktable.gui->center_tooltip = 1;
}
}
}
// kill all paths, in case img was not loaded yet, or is blocked:
cairo_new_path(cr);
#if DRAW_COLORLABELS == 1
// TODO: make mouse sensitive, just as stars!
// TODO: cache in image struct!
{
// color labels:
const float x = zoom == 1 ? (0.07)*fscale : .21*width;
const float y = zoom == 1 ? 0.17*fscale: 0.1*height;
const float r = zoom == 1 ? 0.01*fscale : 0.03*width;
/* clear and reset prepared statement */
DT_DEBUG_SQLITE3_CLEAR_BINDINGS(darktable.view_manager->statements.get_color);
DT_DEBUG_SQLITE3_RESET(darktable.view_manager->statements.get_color);
/* setup statement and iterate rows */
DT_DEBUG_SQLITE3_BIND_INT(darktable.view_manager->statements.get_color, 1, imgid);
while(sqlite3_step(darktable.view_manager->statements.get_color) == SQLITE_ROW)
{
cairo_save(cr);
int col = sqlite3_column_int(darktable.view_manager->statements.get_color, 0);
// see src/dtgtk/paint.c
dtgtk_cairo_paint_label(cr, x+(3*r*col)-5*r, y-r, r*2, r*2, col);
cairo_restore(cr);
}
}
#endif
if(img && (zoom == 1))
{
// some exif data
cairo_set_source_rgb(cr, .7, .7, .7);
cairo_select_font_face (cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, .025*fscale);
cairo_move_to (cr, .02*fscale, .04*fscale);
// cairo_show_text(cr, img->filename);
cairo_text_path(cr, img->filename);
char exifline[50];
cairo_move_to (cr, .02*fscale, .08*fscale);
dt_image_print_exif(img, exifline, 50);
cairo_text_path(cr, exifline);
cairo_fill_preserve(cr);
cairo_set_line_width(cr, 1.0);
cairo_set_source_rgb(cr, 0.3, 0.3, 0.3);
cairo_stroke(cr);
}
if(img) dt_image_cache_read_release(darktable.image_cache, img);
cairo_restore(cr);
// if(zoom == 1) cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
const double end = dt_get_wtime();
dt_print(DT_DEBUG_PERF, "[lighttable] image expose took %0.04f sec\n", end-start);
}
