int
process_cl (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_temperature_data_t *d = (dt_iop_temperature_data_t *)piece->data;
dt_iop_temperature_global_data_t *gd = (dt_iop_temperature_global_data_t *)self->data;
const int devid = piece->pipe->devid;
const int filters = dt_image_flipped_filter(&piece->pipe->image);
float coeffs[3] = {d->coeffs[0], d->coeffs[1], d->coeffs[2]};
cl_mem dev_coeffs = NULL;
cl_int err = -999;
int kernel = -1;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp != 4)
{
kernel = gd->kernel_whitebalance_1ui;
for(int k=0; k<3; k++) coeffs[k] /= 65535.0f;
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp == 4)
{
kernel = gd->kernel_whitebalance_1f;
}
else
{
kernel = gd->kernel_whitebalance_4f;
}
dev_coeffs = dt_opencl_copy_host_to_device_constant(devid, sizeof(float)*3, coeffs);
if (dev_coeffs == NULL) goto error;
const int width = roi_in->width;
const int height = roi_in->height;
size_t sizes[] = { ROUNDUPWD(width), ROUNDUPHT(height), 1};
dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(cl_mem), (void *)&dev_coeffs);
dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(uint32_t), (void *)&filters);
dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(uint32_t), (void *)&roi_out->x);
dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(uint32_t), (void *)&roi_out->y);
err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
if(err != CL_SUCCESS) goto error;
dt_opencl_release_mem_object(dev_coeffs);
for(int k=0; k<3; k++)
piece->pipe->processed_maximum[k] = d->coeffs[k] * piece->pipe->processed_maximum[k];
return TRUE;
error:
if (dev_coeffs != NULL) dt_opencl_release_mem_object(dev_coeffs);
dt_print(DT_DEBUG_OPENCL, "[opencl_white_balance] couldn't enqueue kernel! %d\n", err);
return FALSE;
}
void commit_params (struct dt_iop_module_t *self, dt_iop_params_t *params, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
dt_iop_hotpixels_params_t *p = (dt_iop_hotpixels_params_t *)params;
dt_iop_hotpixels_data_t *d = (dt_iop_hotpixels_data_t *)piece->data;
d->filters = dt_image_flipped_filter(&pipe->image);
d->multiplier = p->strength/2.0;
d->threshold = p->threshold;
d->permissive = p->permissive;
d->markfixed = p->markfixed && (pipe->type != DT_DEV_PIXELPIPE_EXPORT) && (pipe->type != DT_DEV_PIXELPIPE_THUMBNAIL);
if (!(pipe->image.flags & DT_IMAGE_RAW)|| pipe->type == DT_DEV_PIXELPIPE_PREVIEW || p->strength == 0.0)
piece->enabled = 0;
}
int
process_cl (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_highlights_data_t *d = (dt_iop_highlights_data_t *)piece->data;
dt_iop_highlights_global_data_t *gd = (dt_iop_highlights_global_data_t *)self->data;
cl_int err = -999;
const int devid = piece->pipe->devid;
const int width = roi_in->width;
const int height = roi_in->height;
size_t sizes[] = { ROUNDUPWD(width), ROUNDUPHT(height), 1};
const float clip = d->clip * fminf(piece->pipe->processed_maximum[0], fminf(piece->pipe->processed_maximum[1], piece->pipe->processed_maximum[2]));
const int filters = dt_image_flipped_filter(&piece->pipe->image);
if(piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW || !filters)
{
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 4, sizeof(int), (void *)&d->mode);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_4f, 5, sizeof(float), (void *)&clip);
err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_highlights_4f, sizes);
if(err != CL_SUCCESS) goto error;
}
else
{
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 0, sizeof(cl_mem), (void *)&dev_in);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 1, sizeof(cl_mem), (void *)&dev_out);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 2, sizeof(int), (void *)&width);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 3, sizeof(int), (void *)&height);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 4, sizeof(int), (void *)&d->mode);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 5, sizeof(float), (void *)&clip);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 6, sizeof(int), (void *)&roi_out->x);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 7, sizeof(int), (void *)&roi_out->y);
dt_opencl_set_kernel_arg(devid, gd->kernel_highlights_1f, 8, sizeof(int), (void *)&filters);
err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_highlights_1f, sizes);
if(err != CL_SUCCESS) goto error;
}
return TRUE;
error:
dt_print(DT_DEBUG_OPENCL, "[opencl_highlights] couldn't enqueue kernel! %d\n", err);
return FALSE;
}
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 process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const int filters = dt_image_flipped_filter(&piece->pipe->image);
dt_iop_temperature_data_t *d = (dt_iop_temperature_data_t *)piece->data;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp != 4)
{
const float coeffsi[3] = {d->coeffs[0]/65535.0f, d->coeffs[1]/65535.0f, d->coeffs[2]/65535.0f};
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) schedule(static)
#endif
for(int j=0; j<roi_out->height; j++)
{
int i=0;
const uint16_t *in = ((uint16_t *)ivoid) + j*roi_out->width;
float *out = ((float*)ovoid) + j*roi_out->width;
// process unaligned pixels
for ( ; i < ((4-(j*roi_out->width & 3)) & 3) ; i++,out++,in++)
*out = *in * coeffsi[FC(j+roi_out->y, i+roi_out->x, filters)];
const __m128 coeffs = _mm_set_ps(coeffsi[FC(j+roi_out->y, roi_out->x+i+3, filters)],
coeffsi[FC(j+roi_out->y, roi_out->x+i+2, filters)],
coeffsi[FC(j+roi_out->y, roi_out->x+i+1, filters)],
coeffsi[FC(j+roi_out->y, roi_out->x+i , filters)]);
// process aligned pixels with SSE
for( ; i < roi_out->width - 3 ; i+=4,out+=4,in+=4)
{
_mm_stream_ps(out,_mm_mul_ps(coeffs,_mm_set_ps(in[3],in[2],in[1],in[0])));
}
// process the rest
for( ; i<roi_out->width; i++,out++,in++)
*out = *in * coeffsi[FC(j+roi_out->y, i+roi_out->x, filters)];
}
_mm_sfence();
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp == 4)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) schedule(static)
#endif
for(int j=0; j<roi_out->height; j++)
{
const float *in = ((float *)ivoid) + j*roi_out->width;
float *out = ((float*)ovoid) + j*roi_out->width;
for(int i=0; i<roi_out->width; i++,out++,in++)
*out = *in * d->coeffs[FC(j+roi_out->x, i+roi_out->y, filters)];
}
}
else
{
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, d) schedule(static)
#endif
for(int k=0; k<roi_out->height; k++)
{
const float *in = ((float*)ivoid) + ch*k*roi_out->width;
float *out = ((float*)ovoid) + ch*k*roi_out->width;
for (int j=0; j<roi_out->width; j++,in+=ch,out+=ch)
for(int c=0; c<3; c++) out[c] = in[c]*d->coeffs[c];
}
}
for(int k=0; k<3; k++)
piece->pipe->processed_maximum[k] = d->coeffs[k] * piece->pipe->processed_maximum[k];
}
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_invert_data_t *d = (dt_iop_invert_data_t *)piece->data;
const float film_rgb[3] = {d->color[0], d->color[1], d->color[2]};
//FIXME: it could be wise to make this a NOP when picking colors. not sure about that though.
// if(self->request_color_pick){
// do nothing
// }
const int filters = dt_image_flipped_filter(&piece->pipe->image);
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp != 4)
{
const float *const m = piece->pipe->processed_maximum;
const int32_t film_rgb_i[3] = {m[0]*film_rgb[0]*65535, m[1]*film_rgb[1]*65535, m[2]*film_rgb[2]*65535};
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, /*film_rgb_i, min, max, res*/) schedule(static)
#endif
for(int j=0; j<roi_out->height; j++)
{
const uint16_t *in = ((uint16_t*)ivoid) + j*roi_out->width;
uint16_t *out = ((uint16_t*)ovoid) + j*roi_out->width;
for(int i=0; i<roi_out->width; i++,out++,in++)
{
*out = CLAMP(film_rgb_i[FC(j+roi_out->x, i+roi_out->y, filters)] - (int32_t)in[0], 0, 0xffff);
}
}
for(int k=0; k<3; k++)
piece->pipe->processed_maximum[k] = 1.0f;
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters && piece->pipe->image.bpp == 4)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid) schedule(static)
#endif
for(int j=0; j<roi_out->height; j++)
{
const float *in = ((float *)ivoid) + j*roi_out->width;
float *out = ((float*)ovoid) + j*roi_out->width;
for(int i=0; i<roi_out->width; i++,out++,in++)
{
*out = CLAMP(film_rgb[FC(j+roi_out->x, i+roi_out->y, filters)] - *in/(float)0xffff, 0, 1.0f);
}
}
for(int k=0; k<3; k++)
piece->pipe->processed_maximum[k] = 1.0f;
}
else
{
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid) schedule(static)
#endif
for(int k=0; k<roi_out->height; k++)
{
const float *in = ((float*)ivoid) + ch*k*roi_out->width;
float *out = ((float*)ovoid) + ch*k*roi_out->width;
for (int j=0; j<roi_out->width; j++,in+=ch,out+=ch)
for(int c=0; c<3; c++) out[c] = film_rgb[c] - in[c];
}
}
}
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;
}
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
const int filters = dt_image_flipped_filter(&piece->pipe->image);
dt_iop_highlights_data_t *data = (dt_iop_highlights_data_t *)piece->data;
const float clip = data->clip * fminf(piece->pipe->processed_maximum[0], fminf(piece->pipe->processed_maximum[1], piece->pipe->processed_maximum[2]));
// const int ch = piece->colors;
if(piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW || !filters)
{
const __m128 clipm = _mm_set1_ps(clip);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *out = (float *)ovoid + 4*roi_out->width*j;
float *in = (float *)ivoid + 4*roi_in->width*j;
for(int i=0; i<roi_out->width; i++)
{
_mm_stream_ps(out, _mm_min_ps(clipm, _mm_set_ps(in[3],in[2],in[1],in[0])));
in += 4;
out += 4;
}
}
_mm_sfence();
return;
}
switch(data->mode)
{
case DT_IOP_HIGHLIGHTS_LCH:
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *out = (float *)ovoid + roi_out->width*j;
float *in = (float *)ivoid + roi_out->width*j;
for(int i=0; i<roi_out->width; i++)
{
if(in[0] <= clip || i==0 || i==roi_out->width-1 || j==0 || j==roi_out->height-1)
{
// fast path for well-exposed pixels.
out[0] = in[0];
}
else
{
// r and b are same, so we only need two masks
const float lum[3] = { 0.299, 0.587, 0.144 };
// go for all 9 neighbours
float accum[3] = {0.0f, 0.0f, 0.0f};
int cnt[3] = {0, 0, 0};
for(int jj=-1;jj<=1;jj++)
{
for(int ii=-1;ii<=1;ii++)
{
const float val = in[jj*roi_out->width + ii];
if(val > clip)
{
const int c = FC(j+jj+roi_out->y, i+ii+roi_out->x, filters);
accum[c] += lum[c] * val;
cnt[c] ++;
}
}
}
if(cnt[0] && cnt[1] && cnt[2])
{
out[0] = 0.0f;
for(int c=0;c<3;c++)
out[0] += accum[c]/cnt[c];
}
else out[0] = clip;
}
out ++;
in ++;
}
}
break;
default:
case DT_IOP_HIGHLIGHTS_CLIP:
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_out)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *out = (float *)ovoid + roi_out->width*j;
float *in = (float *)ivoid + roi_out->width*j;
for(int i=0; i<roi_out->width; i++)
{
out[0] = MIN(clip, in[0]);
out ++;
in ++;
}
}
break;
}
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
void process(
struct dt_iop_module_t *self,
dt_dev_pixelpipe_iop_t *piece,
void *ivoid,
void *ovoid,
const dt_iop_roi_t *roi_in,
const dt_iop_roi_t *roi_out)
{
const int filters = dt_image_flipped_filter(&piece->pipe->image);
dt_iop_highlights_data_t *data = (dt_iop_highlights_data_t *)piece->data;
const float clip = data->clip * fminf(piece->pipe->processed_maximum[0], fminf(piece->pipe->processed_maximum[1], piece->pipe->processed_maximum[2]));
// const int ch = piece->colors;
if(dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) || !filters)
{
const __m128 clipm = _mm_set1_ps(clip);
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *out = (float *)ovoid + (size_t)4*roi_out->width*j;
float *in = (float *)ivoid + (size_t)4*roi_in->width*j;
for(int i=0; i<roi_out->width; i++)
{
_mm_stream_ps(out, _mm_min_ps(clipm, _mm_set_ps(in[3],in[2],in[1],in[0])));
in += 4;
out += 4;
}
}
_mm_sfence();
return;
}
switch(data->mode)
{
case DT_IOP_HIGHLIGHTS_INPAINT: // a1ex's (magiclantern) idea of color inpainting:
{
const float clips[4] = {
0.987*data->clip * piece->pipe->processed_maximum[0],
0.987*data->clip * piece->pipe->processed_maximum[1],
0.987*data->clip * piece->pipe->processed_maximum[2],
clip};
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int j=0; j<roi_out->height; j++)
{
_interpolate_color(ivoid, ovoid, roi_out, 0, 1, j, clips, filters, 0);
_interpolate_color(ivoid, ovoid, roi_out, 0, -1, j, clips, filters, 1);
}
// up/down directions
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int i=0; i<roi_out->width; i++)
{
_interpolate_color(ivoid, ovoid, roi_out, 1, 1, i, clips, filters, 2);
_interpolate_color(ivoid, ovoid, roi_out, 1, -1, i, clips, filters, 3);
}
break;
}
case DT_IOP_HIGHLIGHTS_LCH:
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, data, piece)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *out = (float *)ovoid + (size_t)roi_out->width*j;
float *in = (float *)ivoid + (size_t)roi_out->width*j;
for(int i=0; i<roi_out->width; i++)
{
if(i==0 || i==roi_out->width-1 || j==0 || j==roi_out->height-1)
{
// fast path for border
out[0] = in[0];
}
else
{
// analyse one bayer block to get same number of rggb pixels each time
const float near_clip = 0.96f*clip;
const float post_clip = 1.10f*clip;
float blend = 0.0f;
float mean = 0.0f;
for(int jj=0; jj<=1; jj++)
{
for(int ii=0; ii<=1; ii++)
{
const float val = in[(size_t)jj*roi_out->width + ii];
mean += val*0.25f;
blend += (fminf(post_clip, val) - near_clip)/(post_clip-near_clip);
}
}
blend = CLAMP(blend, 0.0f, 1.0f);
if(blend > 0)
{
// recover:
out[0] = blend*mean + (1.f-blend)*in[0];
}
else out[0] = in[0];
}
out ++;
in ++;
}
}
break;
default:
case DT_IOP_HIGHLIGHTS_CLIP:
{
const __m128 clipm = _mm_set1_ps(clip);
const size_t n = (size_t)roi_out->height*roi_out->width;
float *const out = (float *)ovoid;
float *const in = (float *)ivoid;
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(int j=0; j<n; j+=4)
_mm_stream_ps(out+j, _mm_min_ps(clipm, _mm_load_ps(in+j)));
_mm_sfence();
// lets see if there's a non-multiple of four rest to process:
if(n & 3) for(size_t j=n&~3u; j<n; j++) out[j] = MIN(clip, in[j]);
break;
}
}
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, 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;
}
