void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o,
const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
// this is called for preview and full pipe separately, each with its own pixelpipe piece.
// get our data struct:
dt_iop_bilat_data_t *d = (dt_iop_bilat_data_t *)piece->data;
// the total scale is composed of scale before input to the pipeline (iscale),
// and the scale of the roi.
const float scale = piece->iscale / roi_in->scale;
const float sigma_r = d->sigma_r; // does not depend on scale
const float sigma_s = d->sigma_s / scale;
if(d->mode == s_mode_bilateral)
{
dt_bilateral_t *b = dt_bilateral_init(roi_in->width, roi_in->height, sigma_s, sigma_r);
dt_bilateral_splat(b, (float *)i);
dt_bilateral_blur(b);
dt_bilateral_slice(b, (float *)i, (float *)o, d->detail);
dt_bilateral_free(b);
}
else // s_mode_local_laplacian
{
local_laplacian(i, o, roi_in->width, roi_in->height, d->midtone, d->sigma_s, d->sigma_r, d->detail, 0);
}
if(piece->pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) dt_iop_alpha_copy(i, o, roi_in->width, roi_in->height);
}
void process(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_profilegamma_data_t *data = (dt_iop_profilegamma_data_t *)piece->data;
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, ivoid, ovoid, data) schedule(static)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
for(int j = 0; j < roi_out->width; j++, in += ch, out += ch)
{
for(int i = 0; i < 3; i++)
{
// use base curve for values < 1, else use extrapolation.
if(in[i] < 1.0f)
out[i] = data->table[CLAMP((int)(in[i] * 0x10000ul), 0, 0xffff)];
else
out[i] = dt_iop_eval_exp(data->unbounded_coeffs, in[i]);
}
}
}
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 *i, void *o,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_exposure_data_t *d = (dt_iop_exposure_data_t *)piece->data;
commit_params_late(self, piece);
const float black = d->black;
const float white = exposure2white(d->exposure);
const int ch = piece->colors;
const float scale = 1.0 / (white - black);
const __m128 blackv = _mm_set1_ps(black);
const __m128 scalev = _mm_set1_ps(scale);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, i, o) schedule(static)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)i) + (size_t)ch * k * roi_out->width;
float *out = ((float *)o) + (size_t)ch * k * roi_out->width;
for(int j = 0; j < roi_out->width; j++, in += 4, out += 4)
_mm_store_ps(out, (_mm_load_ps(in) - blackv) * scalev);
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(i, o, roi_out->width, roi_out->height);
for(int k = 0; k < 3; k++) piece->pipe->processed_maximum[k] *= scale;
}
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *i, void *o, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
float *d = (float *)piece->data;
const float gamma = d[0];
const float linear = d[1];
float table[0x10000];
float a, b, c, g;
if(gamma == 1.0)
{
for(int k=0; k<0x10000; k++) table[k] = 1.0*k/0x10000;
}
else
{
if(linear == 0.0)
{
for(int k=0; k<0x10000; k++)
table[k] = powf(1.00*k/0x10000, gamma);
}
else
{
if(linear<1.0)
{
g = gamma*(1.0-linear)/(1.0-gamma*linear);
a = 1.0/(1.0+linear*(g-1));
b = linear*(g-1)*a;
c = powf(a*linear+b, g)/linear;
}
else
{
a = b = g = 0.0;
c = 1.0;
}
for(int k=0; k<0x10000; k++)
{
float tmp;
if (k<0x10000*linear) tmp = c*k/0x10000;
else tmp = powf(a*k/0x10000+b, g);
table[k] = tmp;
}
}
}
float *in = (float *)i;
float *out = (float *)o;
const int ch = piece->colors;
for(int k=0; k<roi_out->width*roi_out->height; k++)
{
out[0] = table[CLAMP((int)(in[0]*0x10000ul), 0, 0xffff)];
out[1] = table[CLAMP((int)(in[1]*0x10000ul), 0, 0xffff)];
out[2] = table[CLAMP((int)(in[2]*0x10000ul), 0, 0xffff)];
in += ch;
out += ch;
}
if(piece->pipe->mask_display)
dt_iop_alpha_copy(i, o, roi_out->width, roi_out->height);
}
void process(dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid, void *const ovoid,
const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const int ch = piece->colors;
const dt_iop_levels_data_t *const d = (dt_iop_levels_data_t *)piece->data;
if(d->mode == LEVELS_MODE_AUTOMATIC)
{
commit_params_late(self, piece);
}
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(int k = 0; k < roi_out->height; k++)
{
float *in = (float *)ivoid + (size_t)k * ch * roi_out->width;
float *out = (float *)ovoid + (size_t)k * ch * roi_out->width;
for(int j = 0; j < roi_out->width; j++, in += ch, out += ch)
{
float L_in = in[0] / 100.0f;
if(L_in <= d->levels[0])
{
// Anything below the lower threshold just clips to zero
out[0] = 0.0f;
}
else if(L_in >= d->levels[2])
{
float percentage = (L_in - d->levels[0]) / (d->levels[2] - d->levels[0]);
out[0] = 100.0f * pow(percentage, d->in_inv_gamma);
}
else
{
// Within the expected input range we can use the lookup table
float percentage = (L_in - d->levels[0]) / (d->levels[2] - d->levels[0]);
// out[0] = 100.0 * pow(percentage, d->in_inv_gamma);
out[0] = d->lut[CLAMP((int)(percentage * 0xfffful), 0, 0xffff)];
}
// Preserving contrast
if(in[0] > 0.01f)
{
out[1] = in[1] * out[0] / in[0];
out[2] = in[2] * out[0] / in[0];
}
else
{
out[1] = in[1] * out[0] / 0.01f;
out[2] = in[2] * out[0] / 0.01f;
}
}
}
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, const void * const ivoid, void *ovoid, const dt_iop_roi_t *roi_in, const dt_iop_roi_t * const roi_out)
{
dt_develop_t *dev = self->dev;
const int ch = piece->colors;
const __m128 upper = _mm_set_ps(FLT_MAX,
dev->overexposed.upper / 100.0f,
dev->overexposed.upper / 100.0f,
dev->overexposed.upper / 100.0f);
const __m128 lower = _mm_set_ps(FLT_MAX,
dev->overexposed.lower / 100.0f,
dev->overexposed.lower / 100.0f,
dev->overexposed.lower / 100.0f);
const int colorscheme = dev->overexposed.colorscheme;
const __m128 upper_color = _mm_load_ps(dt_iop_overexposed_colors[colorscheme][0]);
const __m128 lower_color = _mm_load_ps(dt_iop_overexposed_colors[colorscheme][1]);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(ovoid) schedule(static)
#endif
for(int k=0; k<roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch*k*roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch*k*roi_out->width;
for (int j=0; j<roi_out->width; j++,in+=4,out+=4)
{
const __m128 pixel = _mm_load_ps(in);
__m128 isoe = _mm_cmpge_ps(pixel, upper);
isoe = _mm_or_ps(_mm_unpacklo_ps(isoe, isoe), _mm_unpackhi_ps(isoe, isoe));
isoe = _mm_or_ps(_mm_unpacklo_ps(isoe, isoe), _mm_unpackhi_ps(isoe, isoe));
__m128 isue = _mm_cmple_ps(pixel, lower);
isue = _mm_and_ps(_mm_unpacklo_ps(isue, isue), _mm_unpackhi_ps(isue, isue));
isue = _mm_and_ps(_mm_unpacklo_ps(isue, isue), _mm_unpackhi_ps(isue, isue));
__m128 result = _mm_or_ps(_mm_andnot_ps(isoe, pixel),
_mm_and_ps(isoe, upper_color));
result = _mm_or_ps(_mm_andnot_ps(isue, result),
_mm_and_ps(isue, lower_color));
_mm_stream_ps(out, result);
}
}
_mm_sfence();
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, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
dt_develop_t *dev = self->dev;
const int ch = piece->colors;
const float lower = dev->overexposed.lower / 100.0;
const float upper = dev->overexposed.upper / 100.0;
const int colorscheme = dev->overexposed.colorscheme;
const float *const upper_color = dt_iop_overexposed_colors[colorscheme][0];
const float *const lower_color = dt_iop_overexposed_colors[colorscheme][1];
const float *const in = (const float *const)ivoid;
float *const out = (float *const)ovoid;
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(size_t k = 0; k < (size_t)ch * roi_out->width * roi_out->height; k += ch)
{
if(in[k + 0] >= upper || in[k + 1] >= upper || in[k + 2] >= upper)
{
for(int c = 0; c < 3; c++)
{
out[k + c] = upper_color[c];
}
}
else if(in[k + 0] <= lower || in[k + 1] <= lower || in[k + 2] <= lower)
{
for(int c = 0; c < 3; c++)
{
out[k + c] = lower_color[c];
}
}
else
{
for(int c = 0; c < 3; c++)
{
const size_t p = (size_t)k + c;
out[p] = in[p];
}
}
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
void process_sse2(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const dt_iop_colorchecker_data_t *const data = (dt_iop_colorchecker_data_t *)piece->data;
const int ch = piece->colors;
// TODO: swizzle this so we can eval the distance of one point
// TODO: to four patches at the same time
v4sf source_Lab[data->num_patches];
for(int i=0;i<data->num_patches;i++)
source_Lab[i] = _mm_set_ps(1.0,
data->source_Lab[3*i+0],
data->source_Lab[3*i+1],
data->source_Lab[3*i+2]);
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) collapse(2)
#endif
for(int j=0;j<roi_out->height;j++)
{
for(int i=0;i<roi_out->width;i++)
{
const float *in = ((float *)ivoid) + (size_t)ch * (j * roi_in->width + i);
float *out = ((float *)ovoid) + (size_t)ch * (j * roi_in->width + i);
// TODO: do this part in SSE (maybe need to store coeff_L in _mm128 on data struct)
out[0] = data->coeff_L[data->num_patches];
out[1] = data->coeff_a[data->num_patches];
out[2] = data->coeff_b[data->num_patches];
// polynomial part:
out[0] += data->coeff_L[data->num_patches+1] * in[0] +
data->coeff_L[data->num_patches+2] * in[1] +
data->coeff_L[data->num_patches+3] * in[2];
out[1] += data->coeff_a[data->num_patches+1] * in[0] +
data->coeff_a[data->num_patches+2] * in[1] +
data->coeff_a[data->num_patches+3] * in[2];
out[2] += data->coeff_b[data->num_patches+1] * in[0] +
data->coeff_b[data->num_patches+2] * in[1] +
data->coeff_b[data->num_patches+3] * in[2];
for(int k=0;k<data->num_patches;k+=4)
{ // rbf from thin plate spline
const v4sf phi = kerneldist4(in, source_Lab[k]);
// TODO: add up 4x output channels
out[0] += data->coeff_L[k] * phi[0];
out[1] += data->coeff_a[k] * phi[0];
out[2] += data->coeff_b[k] * phi[0];
}
}
}
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)
{
dt_iop_global_tonemap_data_t *data = (dt_iop_global_tonemap_data_t *)piece->data;
switch(data->operator) {
case OPERATOR_REINHARD:
process_reinhard(self, piece, ivoid, ovoid, roi_in, roi_out, data);
break;
case OPERATOR_DRAGO:
process_drago(self, piece, ivoid, ovoid, roi_in, roi_out, data);
break;
case OPERATOR_FILMIC:
process_filmic(self, piece, ivoid, ovoid, roi_in, roi_out, data);
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, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const dt_iop_colorchecker_data_t *const data = (dt_iop_colorchecker_data_t *)piece->data;
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static) collapse(2)
#endif
for(int j=0;j<roi_out->height;j++)
{
for(int i=0;i<roi_out->width;i++)
{
const float *in = ((float *)ivoid) + (size_t)ch * (j * roi_in->width + i);
float *out = ((float *)ovoid) + (size_t)ch * (j * roi_in->width + i);
out[0] = data->coeff_L[data->num_patches];
out[1] = data->coeff_a[data->num_patches];
out[2] = data->coeff_b[data->num_patches];
// polynomial part:
out[0] += data->coeff_L[data->num_patches+1] * in[0] +
data->coeff_L[data->num_patches+2] * in[1] +
data->coeff_L[data->num_patches+3] * in[2];
out[1] += data->coeff_a[data->num_patches+1] * in[0] +
data->coeff_a[data->num_patches+2] * in[1] +
data->coeff_a[data->num_patches+3] * in[2];
out[2] += data->coeff_b[data->num_patches+1] * in[0] +
data->coeff_b[data->num_patches+2] * in[1] +
data->coeff_b[data->num_patches+3] * in[2];
#if defined(_OPENMP) && defined(OPENMP_SIMD_) // <== nice try, i don't think this does anything here
#pragma omp SIMD()
#endif
for(int k=0;k<data->num_patches;k++)
{ // rbf from thin plate spline
const float phi = kernel(in, data->source_Lab + 3*k);
out[0] += data->coeff_L[k] * phi;
out[1] += data->coeff_a[k] * phi;
out[2] += data->coeff_b[k] * phi;
}
}
}
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)
{
dt_iop_global_tonemap_data_t *data = (dt_iop_global_tonemap_data_t *)piece->data;
const float scale = piece->iscale/roi_in->scale;
const float sigma_r = 8.0f; // does not depend on scale
const float iw = piece->buf_in.width /scale;
const float ih = piece->buf_in.height/scale;
const float sigma_s = fminf(iw, ih)*0.03f;
dt_bilateral_t *b = NULL;
if(data->detail != 0.0f)
{
b = dt_bilateral_init(roi_in->width, roi_in->height, sigma_s, sigma_r);
// get detail from unchanged input buffer
dt_bilateral_splat(b, (float *)ivoid);
}
switch(data->operator)
{
case OPERATOR_REINHARD:
process_reinhard(self, piece, ivoid, ovoid, roi_in, roi_out, data);
break;
case OPERATOR_DRAGO:
process_drago(self, piece, ivoid, ovoid, roi_in, roi_out, data);
break;
case OPERATOR_FILMIC:
process_filmic(self, piece, ivoid, ovoid, roi_in, roi_out, data);
break;
}
if(data->detail != 0.0f)
{
dt_bilateral_blur(b);
// and apply it to output buffer after logscale
dt_bilateral_slice_to_output(b, (float *)ivoid, (float *)ovoid, data->detail);
dt_bilateral_free(b);
}
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
/** process, all real work is done here. */
void process (struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, void *i, void *o, const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
// this is called for preview and full pipe separately, each with its own pixelpipe piece.
assert(dt_iop_module_colorspace(self) == iop_cs_Lab);
// get our data struct:
dt_iop_colorcontrast_params_t *d = (dt_iop_colorcontrast_params_t *)piece->data;
// how many colors in our buffer?
const int ch = piece->colors;
// iterate over all output pixels (same coordinates as input)
#ifdef _OPENMP
// optional: parallelize it!
#pragma omp parallel for default(none) schedule(static) shared(i,o,roi_in,roi_out,d)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *in = ((float *)i) + ch*roi_in->width *j;
float *out = ((float *)o) + ch*roi_out->width*j;
const __m128 scale = _mm_set_ps(0.0f,d->b_steepness,d->a_steepness,1.0f);
const __m128 offset = _mm_set_ps(0.0f,d->b_offset,d->a_offset,0.0f);
const __m128 min = _mm_set_ps(0.0f,-128.0f,-128.0f, -INFINITY);
const __m128 max = _mm_set_ps(0.0f, 128.0f, 128.0f, INFINITY);
for(int i=0; i<roi_out->width; i++)
{
_mm_stream_ps(out,_mm_min_ps(max,_mm_max_ps(min,_mm_add_ps(offset,_mm_mul_ps(scale,_mm_load_ps(in))))));
in+=ch;
out+=ch;
}
}
_mm_sfence();
if(piece->pipe->mask_display)
dt_iop_alpha_copy(i, o, 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 dt_iop_channelmixer_data_t *data = (dt_iop_channelmixer_data_t *)piece->data;
const gboolean gray_mix_mode = ( data->red[CHANNEL_GRAY] !=0.0 || data->green[CHANNEL_GRAY] !=0.0 || data->blue[CHANNEL_GRAY] !=0.0)?TRUE:FALSE;
const int ch = piece->colors;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(ivoid, ovoid, roi_in, roi_out, data) schedule(static)
#endif
for(int j=0; j<roi_out->height; j++)
{
const float *in = ((float *)ivoid) + (size_t)ch*j*roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch*j*roi_out->width;
for(int i=0; i<roi_out->width; i++)
{
float h,s,l, hmix,smix,lmix,rmix,gmix,bmix,graymix;
// Calculate the HSL mix
hmix = CLIP( in[0] * data->red[CHANNEL_HUE] )+( in[1] * data->green[CHANNEL_HUE])+( in[2] * data->blue[CHANNEL_HUE] );
smix = CLIP( in[0] * data->red[CHANNEL_SATURATION] )+( in[1] * data->green[CHANNEL_SATURATION])+( in[2] * data->blue[CHANNEL_SATURATION] );
lmix = CLIP( in[0] * data->red[CHANNEL_LIGHTNESS] )+( in[1] * data->green[CHANNEL_LIGHTNESS])+( in[2] * data->blue[CHANNEL_LIGHTNESS] );
// If HSL mix is used apply to out[]
if( hmix != 0.0 || smix != 0.0 || lmix != 0.0 )
{
// mix into HSL output channels
rgb2hsl(in,&h,&s,&l);
h = (hmix != 0.0 ) ? hmix : h;
s = (smix != 0.0 ) ? smix : s;
l = (lmix != 0.0 ) ? lmix : l;
hsl2rgb(out,h,s,l);
}
else // no HSL copt in[] to out[]
for(int i=0; i<3; i++) out[i]=in[i];
// Calculate graymix and RGB mix
graymix = CLIP(( out[0] * data->red[CHANNEL_GRAY] )+( out[1] * data->green[CHANNEL_GRAY])+( out[2] * data->blue[CHANNEL_GRAY] ));
rmix = CLIP(( out[0] * data->red[CHANNEL_RED] )+( out[1] * data->green[CHANNEL_RED])+( out[2] * data->blue[CHANNEL_RED] ));
gmix = CLIP(( out[0] * data->red[CHANNEL_GREEN] )+( out[1] * data->green[CHANNEL_GREEN])+( out[2] * data->blue[CHANNEL_GREEN] ));
bmix = CLIP(( out[0] * data->red[CHANNEL_BLUE] )+( out[1] * data->green[CHANNEL_BLUE])+( out[2] * data->blue[CHANNEL_BLUE] ));
if (gray_mix_mode) // Graymix is used...
out[0] = out[1] = out[2] = graymix;
else // RGB mix is used...
{
out[0] = rmix;
out[1] = gmix;
out[2] = bmix;
}
/*mix = CLIP( in[0] * data->red)+( in[1] * data->green)+( in[2] * data->blue );
if( data->output_channel <= CHANNEL_LIGHTNESS ) {
// mix into HSL output channels
rgb2hsl(in,&h,&s,&l);
h = ( data->output_channel == CHANNEL_HUE ) ? mix : h;
s = ( data->output_channel == CHANNEL_SATURATION ) ? mix : s;
l = ( data->output_channel == CHANNEL_LIGHTNESS ) ? mix : l;
hsl2rgb(out,h,s,l);
} else if( data->output_channel > CHANNEL_LIGHTNESS && data->output_channel < CHANNEL_GRAY) {
// mix into rgb output channels
out[0] = ( data->output_channel == CHANNEL_RED ) ? mix : in[0];
out[1] = ( data->output_channel == CHANNEL_GREEN ) ? mix : in[1];
out[2] = ( data->output_channel == CHANNEL_BLUE ) ? mix : in[2];
} else if( data->output_channel <= CHANNEL_GRAY ) {
out[0]=out[1]=out[2] = mix;
}
*/
out += ch;
in += ch;
}
}
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, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const uint32_t filters = piece->pipe->dsc.filters;
dt_iop_highlights_data_t *data = (dt_iop_highlights_data_t *)piece->data;
const float clip
= data->clip * fminf(piece->pipe->dsc.processed_maximum[0],
fminf(piece->pipe->dsc.processed_maximum[1], piece->pipe->dsc.processed_maximum[2]));
// const int ch = piece->colors;
if(!filters)
{
process_clip(piece, ivoid, ovoid, roi_in, roi_out, clip);
for(int k=0;k<3;k++)
piece->pipe->dsc.processed_maximum[k]
= fminf(piece->pipe->dsc.processed_maximum[0],
fminf(piece->pipe->dsc.processed_maximum[1], piece->pipe->dsc.processed_maximum[2]));
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->dsc.processed_maximum[0],
0.987 * data->clip * piece->pipe->dsc.processed_maximum[1],
0.987 * data->clip * piece->pipe->dsc.processed_maximum[2], clip };
if(filters == 9u)
{
const uint8_t(*const xtrans)[6] = (const uint8_t(*const)[6])piece->pipe->dsc.xtrans;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none)
#endif
for(int j = 0; j < roi_out->height; j++)
{
interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 0, 1, j, clips, xtrans, 0);
interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 0, -1, j, clips, xtrans, 1);
}
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none)
#endif
for(int i = 0; i < roi_out->width; i++)
{
interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 1, 1, i, clips, xtrans, 2);
interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 1, -1, i, clips, xtrans, 3);
}
}
else
{
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(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(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:
if(filters == 9u)
process_lch_xtrans(self, piece, ivoid, ovoid, roi_in, roi_out, clip);
else
process_lch_bayer(self, piece, ivoid, ovoid, roi_in, roi_out, clip);
break;
default:
case DT_IOP_HIGHLIGHTS_CLIP:
process_clip(piece, ivoid, ovoid, roi_in, roi_out, clip);
break;
}
// update processed maximum
const float m = fmaxf(fmaxf(piece->pipe->dsc.processed_maximum[0], piece->pipe->dsc.processed_maximum[1]),
piece->pipe->dsc.processed_maximum[2]);
for(int k = 0; k < 3; k++) piece->pipe->dsc.processed_maximum[k] = m;
if(piece->pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) 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)
{
dt_iop_highlights_data_t *data = (dt_iop_highlights_data_t *)piece->data;
float *in;
float *out;
const int ch = piece->colors;
const float clip = data->clip * fminf(piece->pipe->processed_maximum[0], fminf(piece->pipe->processed_maximum[1], piece->pipe->processed_maximum[2]));
float inc[3], lch[3], lchc[3], lchi[3];
switch(data->mode)
{
case DT_IOP_HIGHLIGHTS_LCH:
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_out, data, piece) private(in, out, inc, lch, lchc, lchi)
#endif
for(int j=0; j<roi_out->height; j++)
{
out = (float *)ovoid + ch*roi_out->width*j;
in = (float *)ivoid + ch*roi_out->width*j;
for(int i=0; i<roi_out->width; i++)
{
if(in[0] <= clip && in[1] <= clip && in[2] <= clip)
{
// fast path for well-exposed pixels.
for(int c=0; c<3; c++) out[c] = in[c];
}
else
{
for(int c=0; c<3; c++) inc[c] = fminf(clip, in[c]);
rgb_to_lch(in, lchi);
rgb_to_lch(inc, lchc);
lch[0] = lchc[0] + data->blendL * (lchi[0] - lchc[0]);
lch[1] = lchc[1] + data->blendC * (lchi[1] - lchc[1]);
lch[2] = lchc[2] + data->blendh * (lchi[2] - lchc[2]);
lch_to_rgb(lch, out);
}
out += ch;
in += ch;
}
}
break;
default:
case DT_IOP_HIGHLIGHTS_CLIP:
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_out) private(in, out, inc, lch, lchc, lchi)
#endif
for(int j=0; j<roi_out->height; j++)
{
out = (float *)ovoid + ch*roi_out->width*j;
in = (float *)ivoid + ch*roi_out->width*j;
for(int i=0; i<roi_out->width; i++)
{
for(int c=0; c<3; c++) out[c] = fminf(clip, in[c]);
out += ch;
in += ch;
}
}
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 dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->mode == DT_PROFILE_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
// fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in, roi_out, ivoid, ovoid)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *in = (float *)ivoid + (size_t)ch * roi_in->width * j;
float *out = (float *)ovoid + (size_t)ch * roi_out->width * j;
const __m128 m0 = _mm_set_ps(0.0f, d->cmatrix[6], d->cmatrix[3], d->cmatrix[0]);
const __m128 m1 = _mm_set_ps(0.0f, d->cmatrix[7], d->cmatrix[4], d->cmatrix[1]);
const __m128 m2 = _mm_set_ps(0.0f, d->cmatrix[8], d->cmatrix[5], d->cmatrix[2]);
for(int i = 0; i < roi_out->width; i++, in += ch, out += ch)
{
const __m128 xyz = dt_Lab_to_XYZ_SSE(_mm_load_ps(in));
const __m128 t
= _mm_add_ps(_mm_mul_ps(m0, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(0, 0, 0, 0))),
_mm_add_ps(_mm_mul_ps(m1, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(1, 1, 1, 1))),
_mm_mul_ps(m2, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(2, 2, 2, 2)))));
_mm_stream_ps(out, t);
}
}
_mm_sfence();
// apply profile
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in, roi_out, ivoid, ovoid)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *in = (float *)ivoid + (size_t)ch * roi_in->width * j;
float *out = (float *)ovoid + (size_t)ch * roi_out->width * j;
for(int i = 0; i < roi_out->width; i++, in += ch, out += ch)
{
for(int i = 0; i < 3; i++)
if(d->lut[i][0] >= 0.0f)
{
out[i] = (out[i] < 1.0f) ? lerp_lut(d->lut[i], out[i])
: dt_iop_eval_exp(d->unbounded_coeffs[i], out[i]);
}
}
}
}
else
{
// fprintf(stderr,"Using xform codepath\n");
const __m128 outofgamutpixel = _mm_set_ps(0.0f, 1.0f, 1.0f, 0.0f);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(ivoid, ovoid, roi_out)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
if(!gamutcheck)
{
cmsDoTransform(d->xform, in, out, roi_out->width);
}
else
{
void *rgb = dt_alloc_align(16, 4 * sizeof(float) * roi_out->width);
cmsDoTransform(d->xform, in, rgb, roi_out->width);
float *rgbptr = (float *)rgb;
for(int j = 0; j < roi_out->width; j++, rgbptr += 4, out += 4)
{
const __m128 pixel = _mm_load_ps(rgbptr);
__m128 ingamut = _mm_cmplt_ps(pixel, _mm_set_ps(-FLT_MAX, 0.0f, 0.0f, 0.0f));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
const __m128 result
= _mm_or_ps(_mm_and_ps(ingamut, outofgamutpixel), _mm_andnot_ps(ingamut, pixel));
_mm_stream_ps(out, result);
}
dt_free_align(rgb);
}
}
_mm_sfence();
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
// the basis of how the following algorithm works comes from rawtherapee (http://rawtherapee.com/)
// defringe -- thanks to Emil Martinec <*****@*****.**> for that
// quite some modifications were done though:
// 1. use a fibonacci lattice instead of full window, to speed things up
// 2. option for local averaging or static (RT used the global/region one)
// 3. additional condition to reduce sharp edged artifacts, by blurring pixels near pixels over threshold,
// this really helps improving the filter with thick fringes
// -----------------------------------------------------------------------------------------
// in the following you will also see some more "magic numbers",
// most are chosen arbitrarily and/or by experiment/trial+error ... I am sorry ;-)
// and having everything user-defineable would be just too much
// -----------------------------------------------------------------------------------------
void process(struct dt_iop_module_t *module, dt_dev_pixelpipe_iop_t *piece, void *i, void *o,
const dt_iop_roi_t *roi_in, const dt_iop_roi_t *roi_out)
{
dt_iop_defringe_data_t *d = (dt_iop_defringe_data_t *)piece->data;
assert(dt_iop_module_colorspace(module) == iop_cs_Lab);
const int order = 1; // 0,1,2
const float sigma = fmax(0.1f, fabs(d->radius)) * roi_in->scale / piece->iscale;
const float Labmax[] = { 100.0f, 128.0f, 128.0f, 1.0f };
const float Labmin[] = { 0.0f, -128.0f, -128.0f, 0.0f };
const int ch = piece->colors;
const int radius = ceil(2.0 * ceilf(sigma));
// save the fibonacci lattices in them later
int *xy_avg = NULL;
int *xy_artifact = NULL;
int *xy_small = NULL;
if(roi_out->width < 2 * radius + 1 || roi_out->height < 2 * radius + 1) goto ERROR_EXIT;
float avg_edge_chroma = 0.0;
float *const in = (float *const)i;
float *const out = (float *const)o;
int width = roi_in->width;
int height = roi_in->height;
dt_gaussian_t *gauss = NULL;
gauss = dt_gaussian_init(width, height, ch, Labmax, Labmin, sigma, order);
if(!gauss)
{
fprintf(stderr, "Error allocating memory for gaussian blur in: defringe module\n");
goto ERROR_EXIT;
}
dt_gaussian_blur(gauss, in, out);
dt_gaussian_free(gauss);
// Pre-Compute Fibonacci Lattices
int *tmp;
int samples_wish = radius * radius;
int sampleidx_avg;
// select samples by fibonacci number
if(samples_wish > 89)
{
sampleidx_avg = 12; // 144 samples
}
else if(samples_wish > 55)
{
sampleidx_avg = 11; // 89 samples
}
else if(samples_wish > 34)
{
sampleidx_avg = 10; // ..you get the idea
}
else if(samples_wish > 21)
{
sampleidx_avg = 9;
}
else if(samples_wish > 13)
{
sampleidx_avg = 8;
}
else
{ // don't use less than 13 samples
sampleidx_avg = 7;
}
const int sampleidx_small = sampleidx_avg - 1;
const int small_radius = MAX(radius, 3);
const int avg_radius = 24 + radius * 4;
const int samples_small = fib[sampleidx_small];
const int samples_avg = fib[sampleidx_avg];
// precompute all required fibonacci lattices:
if((xy_avg = malloc((size_t)2 * sizeof(int) * samples_avg)))
{
tmp = xy_avg;
for(int u = 0; u < samples_avg; u++)
{
int dx, dy;
fib_latt(&dx, &dy, avg_radius, u, sampleidx_avg);
*tmp++ = dx;
*tmp++ = dy;
}
}
else
{
fprintf(stderr, "Error allocating memory for fibonacci lattice in: defringe module\n");
goto ERROR_EXIT;
}
if((xy_small = malloc((size_t)2 * sizeof(int) * samples_small)))
{
tmp = xy_small;
for(int u = 0; u < samples_small; u++)
{
int dx, dy;
fib_latt(&dx, &dy, small_radius, u, sampleidx_small);
*tmp++ = dx;
*tmp++ = dy;
}
}
else
{
fprintf(stderr, "Error allocating memory for fibonacci lattice in: defringe module\n");
goto ERROR_EXIT;
}
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(width, height, \
d) reduction(+ : avg_edge_chroma) schedule(static)
#endif
for(int v = 0; v < height; v++)
{
for(int t = 0; t < width; t++)
{
// edge-detect on color channels
// method: difference of original to gaussian blurred image:
float a = in[(size_t)v * width * ch + t * ch + 1] - out[(size_t)v * width * ch + t * ch + 1];
float b = in[(size_t)v * width * ch + t * ch + 2] - out[(size_t)v * width * ch + t * ch + 2];
float edge = (a * a + b * b); // range up to 2*(256)^2 -> approx. 0 to 131072
// save local edge chroma in out[.. +3] , this is later compared with threshold
out[(size_t)v * width * ch + t * ch + 3] = edge;
// the average chroma of the edge-layer in the roi
if(MODE_GLOBAL_AVERAGE == d->op_mode) avg_edge_chroma += edge;
}
}
float thresh;
if(MODE_GLOBAL_AVERAGE == d->op_mode)
{
avg_edge_chroma = avg_edge_chroma / (width * height) + 10.0 * FLT_EPSILON;
thresh = fmax(0.1f, 4.0 * d->thresh * avg_edge_chroma / MAGIC_THRESHOLD_COEFF);
}
else
{
// this fixed value will later be changed when doing local averaging, or kept as-is in "static" mode
avg_edge_chroma = MAGIC_THRESHOLD_COEFF;
thresh = fmax(0.1f, d->thresh);
}
#ifdef _OPENMP
// dynamically/guided scheduled due to possible uneven edge-chroma distribution (thanks to rawtherapee code
// for this hint!)
#pragma omp parallel for default(none) shared(width, height, d, xy_small, xy_avg, xy_artifact) \
firstprivate(thresh, avg_edge_chroma) schedule(guided, 32)
#endif
for(int v = 0; v < height; v++)
{
for(int t = 0; t < width; t++)
{
float local_thresh = thresh;
// think of compiler setting "-funswitch-loops" to maybe improve these things:
if(MODE_LOCAL_AVERAGE == d->op_mode && out[(size_t)v * width * ch + t * ch + 3] > thresh)
{
float local_avg = 0.0;
// use some and not all values from the neigbourhood to speed things up:
const int *tmp = xy_avg;
for(int u = 0; u < samples_avg; u++)
{
int dx = *tmp++;
int dy = *tmp++;
int x = MAX(0, MIN(width - 1, t + dx));
int y = MAX(0, MIN(height - 1, v + dy));
local_avg += out[(size_t)y * width * ch + x * ch + 3];
}
avg_edge_chroma = fmax(0.01f, (float)local_avg / samples_avg);
local_thresh = fmax(0.1f, 4.0 * d->thresh * avg_edge_chroma / MAGIC_THRESHOLD_COEFF);
}
if(out[(size_t)v * width * ch + t * ch + 3] > local_thresh
// reduces artifacts ("region growing by 1 pixel"):
|| out[(size_t)MAX(0, (v - 1)) * width * ch + MAX(0, (t - 1)) * ch + 3] > local_thresh
|| out[(size_t)MAX(0, (v - 1)) * width * ch + t * ch + 3] > local_thresh
|| out[(size_t)MAX(0, (v - 1)) * width * ch + MIN(width - 1, (t + 1)) * ch + 3] > local_thresh
|| out[(size_t)v * width * ch + MAX(0, (t - 1)) * ch + 3] > local_thresh
|| out[(size_t)v * width * ch + MIN(width - 1, (t + 1)) * ch + 3] > local_thresh
|| out[(size_t)MIN(height - 1, (v + 1)) * width * ch + MAX(0, (t - 1)) * ch + 3] > local_thresh
|| out[(size_t)MIN(height - 1, (v + 1)) * width * ch + t * ch + 3] > local_thresh
|| out[(size_t)MIN(height - 1, (v + 1)) * width * ch + MIN(width - 1, (t + 1)) * ch + 3]
> local_thresh)
{
float atot = 0, btot = 0;
float norm = 0;
float weight;
// it seems better to use only some pixels from a larger window instead of all pixels from a smaller
// window
// we use a fibonacci lattice for that, samples amount need to be a fibonacci number, this can then be
// scaled to
// a certain radius
// use some neighbourhood pixels for lowest chroma average
const int *tmp = xy_small;
for(int u = 0; u < samples_small; u++)
{
int dx = *tmp++;
int dy = *tmp++;
int x = MAX(0, MIN(width - 1, t + dx));
int y = MAX(0, MIN(height - 1, v + dy));
// inverse chroma weighted average of neigbouring pixels inside window
// also taking average edge chromaticity into account (either global or local average)
weight = 1.0 / (out[(size_t)y * width * ch + x * ch + 3] + avg_edge_chroma);
atot += weight * in[(size_t)y * width * ch + x * ch + 1];
btot += weight * in[(size_t)y * width * ch + x * ch + 2];
norm += weight;
}
// here we could try using a "balance" between original and changed value, this could be used to
// reduce artifcats
// but on first tries, results weren't very convincing, and there are blend settings available anyway
// in dt
// float balance = (out[v*width*ch +t*ch +3]-thresh)/out[v*width*ch +t*ch +3];
double a = (atot / norm); // *balance + in[v*width*ch + t*ch +1]*(1.0-balance);
double b = (btot / norm); // *balance + in[v*width*ch + t*ch +2]*(1.0-balance);
// if (a < -128.0 || a > 127.0) CLIP(a,-128.0,127.0);
// if (b < -128.0 || b > 127.0) CLIP(b,-128.0,127.0);
out[(size_t)v * width * ch + t * ch + 1] = a;
out[(size_t)v * width * ch + t * ch + 2] = b;
}
else
{
out[(size_t)v * width * ch + t * ch + 1] = in[(size_t)v * width * ch + t * ch + 1];
out[(size_t)v * width * ch + t * ch + 2] = in[(size_t)v * width * ch + t * ch + 2];
}
out[(size_t)v * width * ch + t * ch] = in[(size_t)v * width * ch + t * ch];
}
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(i, o, roi_out->width, roi_out->height);
goto FINISH_PROCESS;
ERROR_EXIT:
memcpy(o, i, (size_t)sizeof(float) * ch * roi_out->width * roi_out->height);
FINISH_PROCESS:
free(xy_artifact);
free(xy_small);
free(xy_avg);
}
void process_sse2(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o,
const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
// this is called for preview and full pipe separately, each with its own pixelpipe piece.
// get our data struct:
dt_iop_bilat_data_t *d = (dt_iop_bilat_data_t *)piece->data;
dt_iop_bilat_gui_data_t *g = self->gui_data;
// the total scale is composed of scale before input to the pipeline (iscale),
// and the scale of the roi.
const float scale = piece->iscale / roi_in->scale;
const float sigma_r = d->sigma_r; // does not depend on scale
const float sigma_s = d->sigma_s / scale;
if(d->mode == s_mode_bilateral)
{
dt_bilateral_t *b = dt_bilateral_init(roi_in->width, roi_in->height, sigma_s, sigma_r);
dt_bilateral_splat(b, (float *)i);
dt_bilateral_blur(b);
dt_bilateral_slice(b, (float *)i, (float *)o, d->detail);
dt_bilateral_free(b);
}
else // s_mode_local_laplacian
{
local_laplacian_boundary_t b = {0};
if(self->dev->gui_attached && g && piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW)
{
b.mode = 1;
}
else if(self->dev->gui_attached && g && piece->pipe->type == DT_DEV_PIXELPIPE_FULL)
{
// full pipeline working on ROI needs boundary conditions from preview pipe
// only do this if roi covers less than 90% of full width
if(MIN(roi_in->width/roi_in->scale / piece->buf_in.width,
roi_in->height/roi_in->scale / piece->buf_in.height) < 0.9)
{
dt_pthread_mutex_lock(&g->lock);
const uint64_t hash = g->hash;
dt_pthread_mutex_unlock(&g->lock);
if(hash != 0 && !dt_dev_sync_pixelpipe_hash(self->dev, piece->pipe, 0, self->priority, &g->lock, &g->hash))
{
// TODO: remove this debug output at some point:
dt_control_log(_("local laplacian: inconsistent output"));
}
else
{
dt_pthread_mutex_lock(&g->lock);
// grab preview pipe buffers here:
b = g->ll_boundary;
dt_pthread_mutex_unlock(&g->lock);
if(b.wd > 0 && b.ht > 0) b.mode = 2;
}
}
}
b.roi = roi_in;
b.buf = &piece->buf_in;
// also lock the ll_boundary in case we're using it.
// could get away without this if the preview pipe didn't also free the data below.
const int lockit = self->dev->gui_attached && g && piece->pipe->type == DT_DEV_PIXELPIPE_FULL;
if(lockit)
{
dt_pthread_mutex_lock(&g->lock);
local_laplacian_sse2(i, o, roi_in->width, roi_in->height, d->midtone, d->sigma_s, d->sigma_r, d->detail, &b);
dt_pthread_mutex_unlock(&g->lock);
}
else local_laplacian_sse2(i, o, roi_in->width, roi_in->height, d->midtone, d->sigma_s, d->sigma_r, d->detail, &b);
// preview pixelpipe stores values.
if(self->dev->gui_attached && g && piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW)
{
uint64_t hash = dt_dev_hash_plus(self->dev, piece->pipe, 0, self->priority);
dt_pthread_mutex_lock(&g->lock);
// store buffer pointers on gui struct. maybe need to swap/free old ones
local_laplacian_boundary_free(&g->ll_boundary);
g->ll_boundary = b;
g->hash = hash;
dt_pthread_mutex_unlock(&g->lock);
}
}
if(piece->pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) dt_iop_alpha_copy(i, o, roi_in->width, roi_in->height);
}
void process_sse2(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const dt_iop_graduatednd_data_t *const data = (const dt_iop_graduatednd_data_t *const)piece->data;
const int ch = piece->colors;
const int ix = (roi_in->x);
const int iy = (roi_in->y);
const float iw = piece->buf_in.width * roi_out->scale;
const float ih = piece->buf_in.height * roi_out->scale;
const float hw = iw / 2.0;
const float hh = ih / 2.0;
const float hw_inv = 1.0 / hw;
const float hh_inv = 1.0 / hh;
const float v = (-data->rotation / 180) * M_PI;
const float sinv = sin(v);
const float cosv = cos(v);
const float filter_radie = sqrt((hh * hh) + (hw * hw)) / hh;
const float offset = data->offset / 100.0 * 2;
#if 1
const float filter_compression = 1.0 / filter_radie
/ (1.0 - (0.5 + (data->compression / 100.0) * 0.9 / 2.0)) * 0.5;
#else
const float compression = data->compression / 100.0f;
const float t = 1.0f - .8f / (.8f + compression);
const float c = 1.0f + 1000.0f * powf(4.0, compression);
#endif
if(data->density > 0)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(int y = 0; y < roi_out->height; y++)
{
size_t k = (size_t)roi_out->width * y * ch;
const float *in = (float *)ivoid + k;
float *out = (float *)ovoid + k;
float length = (sinv * (-1.0 + ix * hw_inv) - cosv * (-1.0 + (iy + y) * hh_inv) - 1.0 + offset)
* filter_compression;
const float length_inc = sinv * hw_inv * filter_compression;
__m128 c = _mm_set_ps(0, data->color[2], data->color[1], data->color[0]);
__m128 c1 = _mm_sub_ps(_mm_set1_ps(1.0f), c);
for(int x = 0; x < roi_out->width; x++, in += ch, out += ch)
{
#if 1
// !!! approximation is ok only when highest density is 8
// for input x = (data->density * CLIP( 0.5+length ), calculate 2^x as (e^(ln2*x/8))^8
// use exp2f approximation to calculate e^(ln2*x/8)
// in worst case - density==8,CLIP(0.5-length) == 1.0 it gives 0.6% of error
const float t = 0.693147181f /* ln2 */ * (data->density * CLIP(0.5f + length) / 8.0f);
float d1 = t * t * 0.5f;
float d2 = d1 * t * 0.333333333f;
float d3 = d2 * t * 0.25f;
float d = 1 + t + d1 + d2 + d3; /* taylor series for e^x till x^4 */
// printf("%d %d %f\n",y,x,d);
__m128 density = _mm_set1_ps(d);
density = _mm_mul_ps(density, density);
density = _mm_mul_ps(density, density);
density = _mm_mul_ps(density, density);
#else
// use fair exp2f
__m128 density = _mm_set1_ps(exp2f(data->density * CLIP(0.5f + length)));
#endif
/* max(0,in / (c + (1-c)*density)) */
_mm_stream_ps(out, _mm_max_ps(_mm_set1_ps(0.0f),
_mm_div_ps(_mm_load_ps(in), _mm_add_ps(c, _mm_mul_ps(c1, density)))));
length += length_inc;
}
}
}
else
{
#ifdef _OPENMP
#pragma omp parallel for default(none) schedule(static)
#endif
for(int y = 0; y < roi_out->height; y++)
{
size_t k = (size_t)roi_out->width * y * ch;
const float *in = (float *)ivoid + k;
float *out = (float *)ovoid + k;
float length = (sinv * (-1.0f + ix * hw_inv) - cosv * (-1.0f + (iy + y) * hh_inv) - 1.0f + offset)
* filter_compression;
const float length_inc = sinv * hw_inv * filter_compression;
__m128 c = _mm_set_ps(0, data->color[2], data->color[1], data->color[0]);
__m128 c1 = _mm_sub_ps(_mm_set1_ps(1.0f), c);
for(int x = 0; x < roi_out->width; x++, in += ch, out += ch)
{
#if 1
// !!! approximation is ok only when lowest density is -8
// for input x = (-data->density * CLIP( 0.5-length ), calculate 2^x as (e^(ln2*x/8))^8
// use exp2f approximation to calculate e^(ln2*x/8)
// in worst case - density==-8,CLIP(0.5-length) == 1.0 it gives 0.6% of error
const float t = 0.693147181f /* ln2 */ * (-data->density * CLIP(0.5f - length) / 8.0f);
float d1 = t * t * 0.5f;
float d2 = d1 * t * 0.333333333f;
float d3 = d2 * t * 0.25f;
float d = 1 + t + d1 + d2 + d3; /* taylor series for e^x till x^4 */
__m128 density = _mm_set1_ps(d);
density = _mm_mul_ps(density, density);
density = _mm_mul_ps(density, density);
density = _mm_mul_ps(density, density);
#else
__m128 density = _mm_set1_ps(exp2f(-data->density * CLIP(0.5f - length)));
#endif
/* max(0,in * (c + (1-c)*density)) */
_mm_stream_ps(out, _mm_max_ps(_mm_set1_ps(0.0f),
_mm_mul_ps(_mm_load_ps(in), _mm_add_ps(c, _mm_mul_ps(c1, density)))));
length += length_inc;
}
}
}
_mm_sfence();
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(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_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 };
if(filters == 9u)
{
const dt_image_t *img = &self->dev->image_storage;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, img)
#endif
for(int j = 0; j < roi_out->height; j++)
{
_interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 0, 1, j, clips, img->xtrans, 0);
_interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 0, -1, j, clips, img->xtrans, 1);
}
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic) default(none) shared(ovoid, ivoid, roi_in, roi_out, img)
#endif
for(int i = 0; i < roi_out->width; i++)
{
_interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 1, 1, i, clips, img->xtrans, 2);
_interpolate_color_xtrans(ivoid, ovoid, roi_in, roi_out, 1, -1, i, clips, img->xtrans, 3);
}
break;
}
#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:
if(filters == 9u)
{
process_lch_xtrans(ivoid, ovoid, roi_out->width, roi_out->height, clip);
break;
}
#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(size_t j = 0; j < (n & ~3u); 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);
}
static void process_common_cleanup(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece,
const void *const ivoid, void *const ovoid,
const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
dt_iop_zonesystem_data_t *d = (dt_iop_zonesystem_data_t *)piece->data;
dt_iop_zonesystem_gui_data_t *g = (dt_iop_zonesystem_gui_data_t *)self->gui_data;
const int width = roi_out->width;
const int height = roi_out->height;
const int ch = piece->colors;
const int size = d->params.size;
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, width, height);
/* if gui and have buffer lets gaussblur and fill buffer with zone indexes */
if(self->dev->gui_attached && piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW && g && g->in_preview_buffer
&& g->out_preview_buffer)
{
float Lmax[] = { 100.0f };
float Lmin[] = { 0.0f };
/* setup gaussian kernel */
const int radius = 8;
const float sigma = 2.5 * (radius * roi_in->scale / piece->iscale);
dt_gaussian_t *gauss = dt_gaussian_init(width, height, 1, Lmax, Lmin, sigma, DT_IOP_GAUSSIAN_ZERO);
float *tmp = g_malloc_n((size_t)width * height, sizeof(float));
if(gauss && tmp)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp) schedule(static)
#endif
for(size_t k = 0; k < (size_t)width * height; k++) tmp[k] = ((float *)ivoid)[ch * k];
dt_gaussian_blur(gauss, tmp, tmp);
/* create zonemap preview for input */
dt_pthread_mutex_lock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp, g) schedule(static)
#endif
for(size_t k = 0; k < (size_t)width * height; k++)
{
g->in_preview_buffer[k] = CLAMPS(tmp[k] * (size - 1) / 100.0f, 0, size - 2);
}
dt_pthread_mutex_unlock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp) schedule(static)
#endif
for(size_t k = 0; k < (size_t)width * height; k++) tmp[k] = ((float *)ovoid)[ch * k];
dt_gaussian_blur(gauss, tmp, tmp);
/* create zonemap preview for output */
dt_pthread_mutex_lock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp, g) schedule(static)
#endif
for(size_t k = 0; k < (size_t)width * height; k++)
{
g->out_preview_buffer[k] = CLAMPS(tmp[k] * (size - 1) / 100.0f, 0, size - 2);
}
dt_pthread_mutex_unlock(&g->lock);
}
g_free(tmp);
if(gauss) dt_gaussian_free(gauss);
}
}
void process(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
dt_iop_bloom_data_t *data = (dt_iop_bloom_data_t *)piece->data;
float *in = (float *)ivoid;
float *out = (float *)ovoid;
const int ch = piece->colors;
/* gather light by threshold */
float *blurlightness = calloc((size_t)roi_out->width * roi_out->height, sizeof(float));
memcpy(out, in, (size_t)roi_out->width * roi_out->height * ch * sizeof(float));
const int rad = 256.0f * (fmin(100.0f, data->size + 1.0f) / 100.0f);
const float _r = ceilf(rad * roi_in->scale / piece->iscale);
const int radius = MIN(256.0f, _r);
const float scale = 1.0f / exp2f(-1.0f * (fmin(100.0f, data->strength + 1.0f) / 100.0f));
/* get the thresholded lights into buffer */
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(data, blurlightness) schedule(static)
#endif
for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height; k++)
{
float *inp = ((float *)ivoid) + ch * k;
const float L = inp[0] * scale;
if(L > data->threshold) blurlightness[k] = L;
}
/* horizontal blur into memchannel lightness */
const int range = 2 * radius + 1;
const int hr = range / 2;
const size_t size = roi_out->width > roi_out->height ? roi_out->width : roi_out->height;
float *const scanline_buf = malloc(size * dt_get_num_threads() * sizeof(float));
for(int iteration = 0; iteration < BOX_ITERATIONS; iteration++)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(blurlightness) schedule(static)
#endif
for(int y = 0; y < roi_out->height; y++)
{
float *scanline = scanline_buf + size * dt_get_thread_num();
float L = 0;
int hits = 0;
const size_t index = (size_t)y * roi_out->width;
for(int x = -hr; x < roi_out->width; x++)
{
int op = x - hr - 1;
int np = x + hr;
if(op >= 0)
{
L -= blurlightness[index + op];
hits--;
}
if(np < roi_out->width)
{
L += blurlightness[index + np];
hits++;
}
if(x >= 0) scanline[x] = L / hits;
}
for(int x = 0; x < roi_out->width; x++) blurlightness[index + x] = scanline[x];
}
/* vertical pass on blurlightness */
const int opoffs = -(hr + 1) * roi_out->width;
const int npoffs = (hr)*roi_out->width;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(blurlightness) schedule(static)
#endif
for(int x = 0; x < roi_out->width; x++)
{
float *scanline = scanline_buf + size * dt_get_thread_num();
float L = 0;
int hits = 0;
size_t index = (size_t)x - hr * roi_out->width;
for(int y = -hr; y < roi_out->height; y++)
{
int op = y - hr - 1;
int np = y + hr;
if(op >= 0)
{
L -= blurlightness[index + opoffs];
hits--;
}
if(np < roi_out->height)
{
L += blurlightness[index + npoffs];
hits++;
}
if(y >= 0) scanline[y] = L / hits;
index += roi_out->width;
}
for(int y = 0; y < roi_out->height; y++) blurlightness[y * roi_out->width + x] = scanline[y];
}
}
free(scanline_buf);
/* screen blend lightness with original */
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(in, out, data, blurlightness) schedule(static)
#endif
for(size_t k = 0; k < (size_t)roi_out->width * roi_out->height; k++)
{
float *inp = in + ch * k;
float *outp = out + ch * k;
outp[0] = 100.0f - (((100.0f - inp[0]) * (100.0f - blurlightness[k])) / 100.0f); // Screen blend
outp[1] = inp[1];
outp[2] = inp[2];
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
free(blurlightness);
}
static gboolean draw(GtkWidget *widget, cairo_t *cr, dt_iop_module_t *self)
{
if(darktable.gui->reset) return FALSE;
if(self->picked_color_max[0] < 0.0f) return FALSE;
if(self->request_color_pick == DT_REQUEST_COLORPICK_OFF) return FALSE;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
if(fabsf(p->color[0] - self->picked_color[0]) < 0.0001f
&& fabsf(p->color[1] - self->picked_color[1]) < 0.0001f
&& fabsf(p->color[2] - self->picked_color[2]) < 0.0001f)
{
// interrupt infinite loops
return FALSE;
}
p->color[0] = self->picked_color[0];
p->color[1] = self->picked_color[1];
p->color[2] = self->picked_color[2];
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
dt_dev_add_history_item(darktable.develop, self, TRUE);
return FALSE;
}
static void colorpicker_callback(GtkColorButton *widget, dt_iop_module_t *self)
{
if(self->dt->gui->reset) return;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
// turn off the other color picker so that this tool actually works ...
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->picker), FALSE);
GdkRGBA c;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
p->color[0] = c.red;
p->color[1] = c.green;
p->color[2] = c.blue;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
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 *const m = piece->pipe->processed_maximum;
float film_rgb[4] = { d->color[0], d->color[1], d->color[2], 0.0f };
// Convert the RGB color to CYGM only if we're not in the preview pipe (which is already RGB)
if((self->dev->image_storage.flags & DT_IMAGE_4BAYER) && !dt_dev_pixelpipe_uses_downsampled_input(piece->pipe))
dt_colorspaces_rgb_to_cygm(film_rgb, 1, d->RGB_to_CAM);
const float film_rgb_f[4] = { film_rgb[0] * m[0], film_rgb[1] * m[1], film_rgb[2] * m[2], film_rgb[3] * m[3] };
// 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_filter(&piece->pipe->image);
const uint8_t (*const xtrans)[6] = (const uint8_t (*const)[6]) self->dev->image_storage.xtrans;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && (filters == 9u))
{ // xtrans float mosaiced
#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) + (size_t)j * roi_out->width;
float *out = ((float *)ovoid) + (size_t)j * roi_out->width;
for(int i = 0; i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FCxtrans(j, i, roi_out, xtrans)] - *in, 0.0f, 1.0f);
}
for(int k = 0; k < 4; k++) piece->pipe->processed_maximum[k] = 1.0f;
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters)
{ // bayer float mosaiced
const __m128 val_min = _mm_setzero_ps();
const __m128 val_max = _mm_set1_ps(1.0f);
#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) + (size_t)j * roi_out->width;
float *out = ((float *)ovoid) + (size_t)j * roi_out->width;
int i = 0;
int alignment = ((4 - (j * roi_out->width & (4 - 1))) & (4 - 1));
// process unaligned pixels
for(; i < alignment; i++, out++, in++)
*out = CLAMP(film_rgb_f[FC(j + roi_out->y, i + roi_out->x, filters)] - *in, 0.0f, 1.0f);
const __m128 film = _mm_set_ps(film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 3, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 2, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i + 1, filters)],
film_rgb_f[FC(j + roi_out->y, roi_out->x + i, filters)]);
// process aligned pixels with SSE
for(; i < roi_out->width - (4 - 1); i += 4, in += 4, out += 4)
{
const __m128 input = _mm_load_ps(in);
const __m128 subtracted = _mm_sub_ps(film, input);
_mm_stream_ps(out, _mm_max_ps(_mm_min_ps(subtracted, val_max), val_min));
}
// process the rest
for(; i < roi_out->width; i++, out++, in++)
*out = CLAMP(film_rgb_f[FC(j + roi_out->y, i + roi_out->x, filters)] - *in, 0.0f, 1.0f);
}
_mm_sfence();
for(int k = 0; k < 4; k++) piece->pipe->processed_maximum[k] = 1.0f;
}
else
{ // non-mosaiced
const int ch = piece->colors;
const __m128 film = _mm_set_ps(1.0f, film_rgb[2], film_rgb[1], film_rgb[0]);
#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) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
for(int j = 0; j < roi_out->width; j++, in += ch, out += ch)
{
const __m128 input = _mm_load_ps(in);
const __m128 subtracted = _mm_sub_ps(film, input);
_mm_stream_ps(out, subtracted);
}
}
_mm_sfence();
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_filter(&piece->pipe->image);
uint8_t (*const xtrans)[6] = self->dev->image_storage.xtrans;
dt_iop_temperature_data_t *d = (dt_iop_temperature_data_t *)piece->data;
if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters == 9u)
{ // xtrans float mosaiced
#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) + (size_t)j*roi_out->width;
float *out = ((float*)ovoid) + (size_t)j*roi_out->width;
for(int i=0; i<roi_out->width; i++,out++,in++)
*out = *in * d->coeffs[FCxtrans(j,i,roi_out,xtrans)];
}
}
else if(!dt_dev_pixelpipe_uses_downsampled_input(piece->pipe) && filters)
{ // bayer float mosaiced
#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) + (size_t)j*roi_out->width;
float *out = ((float*)ovoid) + (size_t)j*roi_out->width;
int i = 0;
int alignment = ((4 - (j * roi_out->width & (4 - 1))) & (4 - 1));
// process unaligned pixels
for ( ; i < alignment ; i++, out++, in++)
*out = *in * d->coeffs[FC(j+roi_out->y, i+roi_out->x, filters)];
const __m128 coeffs = _mm_set_ps(d->coeffs[FC(j+roi_out->y, roi_out->x+i+3, filters)],
d->coeffs[FC(j+roi_out->y, roi_out->x+i+2, filters)],
d->coeffs[FC(j+roi_out->y, roi_out->x+i+1, filters)],
d->coeffs[FC(j+roi_out->y, roi_out->x+i , filters)]);
// process aligned pixels with SSE
for( ; i < roi_out->width - (4-1); i+=4,in+=4,out+=4)
{
const __m128 input = _mm_load_ps(in);
const __m128 multiplied = _mm_mul_ps(input, coeffs);
_mm_stream_ps(out, multiplied);
}
// process the rest
for( ; i<roi_out->width; i++,out++,in++)
*out = *in * d->coeffs[FC(j+roi_out->y, i+roi_out->x, filters)];
}
_mm_sfence();
}
else
{ // non-mosaiced
const int ch = piece->colors;
const __m128 coeffs = _mm_set_ps(1.0f,
d->coeffs[2],
d->coeffs[1],
d->coeffs[0]);
#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) + (size_t)ch*k*roi_out->width;
float *out = ((float*)ovoid) + (size_t)ch*k*roi_out->width;
for (int j=0; j<roi_out->width; j++,in+=ch,out+=ch)
{
const __m128 input = _mm_load_ps(in);
const __m128 multiplied = _mm_mul_ps(input, coeffs);
_mm_stream_ps(out, multiplied);
}
}
_mm_sfence();
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
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)
{
float *in;
float *out;
dt_iop_zonesystem_gui_data_t *g = NULL;
dt_iop_zonesystem_data_t *data = (dt_iop_zonesystem_data_t*)piece->data;
const int width = roi_out->width;
const int height = roi_out->height;
guchar *in_buffer = NULL, *out_buffer = NULL;
if( self->dev->gui_attached && piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW )
{
g = (dt_iop_zonesystem_gui_data_t *)self->gui_data;
dt_pthread_mutex_lock(&g->lock);
if(g->in_preview_buffer)
g_free (g->in_preview_buffer);
if(g->out_preview_buffer)
g_free (g->out_preview_buffer);
in_buffer = g->in_preview_buffer = g_malloc ((size_t)width*height);
out_buffer = g->out_preview_buffer = g_malloc ((size_t)width*height);
g->preview_width = width;
g->preview_height = height;
dt_pthread_mutex_unlock(&g->lock);
}
/* calculate zonemap */
const int size = data->size;
float zonemap[MAX_ZONE_SYSTEM_SIZE]= {-1};
_iop_zonesystem_calculate_zonemap (data, zonemap);
const int ch = piece->colors;
/* process the image */
in = (float *)ivoid;
out = (float *)ovoid;
const float rzscale = (size-1)/100.0f;
float zonemap_offset[MAX_ZONE_SYSTEM_SIZE]= {-1};
float zonemap_scale[MAX_ZONE_SYSTEM_SIZE]= {-1};
// precompute scale and offset
for (int k=0; k < size-1; k++) zonemap_scale[k] = (zonemap[k+1]-zonemap[k])*(size-1);
for (int k=0; k < size-1; k++) zonemap_offset[k] = 100.0f * ((k+1)*zonemap[k] - k*zonemap[k+1]) ;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(in, out, zonemap_scale,zonemap_offset) schedule(static)
#endif
for (int j=0; j<height; j++)
for (int i=0; i<width; i++)
{
/* remap lightness into zonemap and apply lightness */
const float *inp = in + ch*((size_t)j*width+i);
float *outp = out + ch*((size_t)j*width+i);
const int rz = CLAMPS(inp[0]*rzscale, 0, size-2); // zone index
const float zs = ((rz > 0) ? (zonemap_offset[rz]/inp[0]) : 0) + zonemap_scale[rz];
_mm_stream_ps(outp,_mm_mul_ps(_mm_load_ps(inp),_mm_set1_ps(zs)));
}
_mm_sfence();
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, width, height);
/* if gui and have buffer lets gaussblur and fill buffer with zone indexes */
if( self->dev->gui_attached && g && in_buffer && out_buffer)
{
float Lmax[] = { 100.0f };
float Lmin[] = { 0.0f };
/* setup gaussian kernel */
const int radius = 8;
const float sigma = 2.5*(radius*roi_in->scale/piece->iscale);
dt_gaussian_t *gauss = dt_gaussian_init(width, height, 1, Lmax, Lmin, sigma, DT_IOP_GAUSSIAN_ZERO);
float *tmp = g_malloc((size_t)width*height*sizeof(float));
if(gauss && tmp)
{
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(ivoid, tmp) schedule(static)
#endif
for(size_t k=0; k<(size_t)width*height; k++)
tmp[k] = ((float *)ivoid)[ch*k];
dt_gaussian_blur(gauss, tmp, tmp);
/* create zonemap preview for input */
dt_pthread_mutex_lock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp,in_buffer) schedule(static)
#endif
for (size_t k=0; k<(size_t)width*height; k++)
{
in_buffer[k] = CLAMPS(tmp[k]*(size-1)/100.0f, 0, size-2);
}
dt_pthread_mutex_unlock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(ovoid, tmp) schedule(static)
#endif
for(size_t k=0; k<(size_t)width*height; k++)
tmp[k] = ((float *)ovoid)[ch*k];
dt_gaussian_blur(gauss, tmp, tmp);
/* create zonemap preview for output */
dt_pthread_mutex_lock(&g->lock);
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(tmp,out_buffer) schedule(static)
#endif
for (size_t k=0; k<(size_t)width*height; k++)
{
out_buffer[k] = CLAMPS(tmp[k]*(size-1)/100.0f, 0, size-2);
}
dt_pthread_mutex_unlock(&g->lock);
}
if (tmp) g_free(tmp);
if (gauss) dt_gaussian_free(gauss);
}
}
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 dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->softproof_enabled == DT_SOFTPROOF_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
//fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in,roi_out, ivoid, ovoid)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *in = (float*)ivoid + ch*roi_in->width *j;
float *out = (float*)ovoid + ch*roi_out->width*j;
const __m128 m0 = _mm_set_ps(0.0f,d->cmatrix[6],d->cmatrix[3],d->cmatrix[0]);
const __m128 m1 = _mm_set_ps(0.0f,d->cmatrix[7],d->cmatrix[4],d->cmatrix[1]);
const __m128 m2 = _mm_set_ps(0.0f,d->cmatrix[8],d->cmatrix[5],d->cmatrix[2]);
for(int i=0; i<roi_out->width; i++, in+=ch, out+=ch )
{
const __m128 xyz = dt_Lab_to_XYZ_SSE(_mm_load_ps(in));
const __m128 t = _mm_add_ps(_mm_mul_ps(m0,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(0,0,0,0))),_mm_add_ps(_mm_mul_ps(m1,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(1,1,1,1))),_mm_mul_ps(m2,_mm_shuffle_ps(xyz,xyz,_MM_SHUFFLE(2,2,2,2)))));
_mm_stream_ps(out,t);
}
}
_mm_sfence();
// apply profile
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(roi_in,roi_out, ivoid, ovoid)
#endif
for(int j=0; j<roi_out->height; j++)
{
float *in = (float*)ivoid + ch*roi_in->width *j;
float *out = (float*)ovoid + ch*roi_out->width*j;
for(int i=0; i<roi_out->width; i++, in+=ch, out+=ch )
{
for(int i=0; i<3; i++)
if (d->lut[i][0] >= 0.0f)
{
out[i] = (out[i] < 1.0f) ? lerp_lut(d->lut[i], out[i]) : dt_iop_eval_exp(d->unbounded_coeffs[i], out[i]);
}
}
}
}
else
{
float *in = (float*)ivoid;
float *out = (float*)ovoid;
const int rowsize=roi_out->width * 3;
//fprintf(stderr,"Using xform codepath\n");
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none) shared(out, roi_out, in)
#endif
for (int k=0; k<roi_out->height; k++)
{
float Lab[rowsize];
float rgb[rowsize];
const int m=(k*(roi_out->width*ch));
for (int l=0; l<roi_out->width; l++)
{
int li=3*l,ii=ch*l;
Lab[li+0] = in[m+ii+0];
Lab[li+1] = in[m+ii+1];
Lab[li+2] = in[m+ii+2];
}
cmsDoTransform (d->xform, Lab, rgb, roi_out->width);
for (int l=0; l<roi_out->width; l++)
{
int oi=ch*l, ri=3*l;
if(gamutcheck && (rgb[ri+0] < 0.0f || rgb[ri+1] < 0.0f || rgb[ri+2] < 0.0f))
{
out[m+oi+0] = 0.0f;
out[m+oi+1] = 1.0f;
out[m+oi+2] = 1.0f;
}
else
{
out[m+oi+0] = rgb[ri+0];
out[m+oi+1] = rgb[ri+1];
out[m+oi+2] = rgb[ri+2];
}
}
}
}
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, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->mode == DT_PROFILE_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
// fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(size_t k = 0; k < (size_t)ch * roi_out->width * roi_out->height; k += ch)
{
const float *const in = (const float *const)ivoid + (size_t)k;
float *out = (float *)ovoid + (size_t)k;
float xyz[3];
_dt_Lab_to_XYZ(in, xyz);
for(int c = 0; c < 3; c++)
{
out[c] = 0.0f;
for(int i = 0; i < 3; i++)
{
out[c] += d->cmatrix[3 * c + i] * xyz[i];
}
}
}
process_fastpath_apply_tonecurves(self, piece, ivoid, ovoid, roi_in, roi_out);
}
else
{
// fprintf(stderr,"Using xform codepath\n");
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
cmsDoTransform(d->xform, in, out, roi_out->width);
if(gamutcheck)
{
for(int j = 0; j < roi_out->width; j++, out += 4)
{
if(out[0] < 0.0f || out[1] < 0.0f || out[2] < 0.0f)
{
out[0] = 0.0f;
out[1] = 1.0f;
out[2] = 1.0f;
}
}
}
}
}
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)
{
float *in;
float *out;
dt_iop_zonesystem_gui_data_t *g = NULL;
dt_iop_zonesystem_data_t *data = (dt_iop_zonesystem_data_t*)piece->data;
guchar *buffer = NULL;
if( self->dev->gui_attached && piece->pipe->type == DT_DEV_PIXELPIPE_PREVIEW )
{
g = (dt_iop_zonesystem_gui_data_t *)self->gui_data;
dt_pthread_mutex_lock(&g->lock);
if(g->preview_buffer)
g_free (g->preview_buffer);
buffer = g->preview_buffer = g_malloc (roi_in->width*roi_in->height);
g->preview_width=roi_out->width;
g->preview_height=roi_out->height;
}
/* calculate zonemap */
const int size = data->size;
float zonemap[MAX_ZONE_SYSTEM_SIZE]= {-1};
_iop_zonesystem_calculate_zonemap (data, zonemap);
const int ch = piece->colors;
/* if gui and have buffer lets gaussblur and fill buffer with zone indexes */
if( self->dev->gui_attached && g && buffer)
{
/* setup gaussian kernel */
const int radius = 8;
const int rad = MIN(radius, ceilf(radius * roi_in->scale / piece->iscale));
const int wd = 2*rad+1;
float mat[wd*wd];
float *m;
const float sigma2 = (2.5*2.5)*(radius*roi_in->scale/piece->iscale)*(radius*roi_in->scale/piece->iscale);
float weight = 0.0f;
memset(mat, 0, wd*wd*sizeof(float));
m = mat;
for(int l=-rad; l<=rad; l++) for(int k=-rad; k<=rad; k++,m++)
weight += *m = expf(- (l*l + k*k)/(2.f*sigma2));
m = mat;
for(int l=-rad; l<=rad; l++) for(int k=-rad; k<=rad; k++,m++)
*m /= weight;
/* gauss blur the L channel */
#ifdef _OPENMP
#pragma omp parallel for default(none) private(in, out, m) shared(mat, ivoid, ovoid, roi_out, roi_in) schedule(static)
#endif
for(int j=rad; j<roi_out->height-rad; j++)
{
in = ((float *)ivoid) + ch*(j*roi_in->width + rad);
out = ((float *)ovoid) + ch*(j*roi_out->width + rad);
for(int i=rad; i<roi_out->width-rad; i++)
{
for(int c=0; c<3; c++) out[c] = 0.0f;
float sum = 0.0;
m = mat;
for(int l=-rad; l<=rad; l++)
{
float *inrow = in + ch*(l*roi_in->width-rad);
for(int k=-rad; k<=rad; k++,inrow+=ch,m++)
sum += *m * inrow[0];
}
out[0] = sum;
out += ch;
in += ch;
}
}
/* create zonemap preview */
// in = (float *)ivoid;
out = (float *)ovoid;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out,out,buffer,g,zonemap) schedule(static)
#endif
for (int k=0; k<roi_out->width*roi_out->height; k++)
{
buffer[k] = _iop_zonesystem_zone_index_from_lightness (out[ch*k]/100.0f, zonemap, size);
}
dt_pthread_mutex_unlock(&g->lock);
}
/* process the image */
in = (float *)ivoid;
out = (float *)ovoid;
const float rzscale = (size-1)/100.0f;
float zonemap_offset[MAX_ZONE_SYSTEM_SIZE]= {-1};
float zonemap_scale[MAX_ZONE_SYSTEM_SIZE]= {-1};
// precompute scale and offset
for (int k=0; k < size-1; k++) zonemap_scale[k] = (zonemap[k+1]-zonemap[k])*(size-1);
for (int k=0; k < size-1; k++) zonemap_offset[k] = 100.0f * ((k+1)*zonemap[k] - k*zonemap[k+1]) ;
#ifdef _OPENMP
#pragma omp parallel for default(none) shared(roi_out, in, out, zonemap_scale,zonemap_offset) schedule(static)
#endif
for (int j=0; j<roi_out->height; j++)
for (int i=0; i<roi_out->width; i++)
{
/* remap lightness into zonemap and apply lightness */
const float *inp = in + ch*(j*roi_out->width+i);
float *outp = out + ch*(j*roi_out->width+i);
const int rz = CLAMPS(inp[0]*rzscale, 0, size-2); // zone index
const float zs = ((rz > 0) ? (zonemap_offset[rz]/inp[0]) : 0) + zonemap_scale[rz];
_mm_stream_ps(outp,_mm_mul_ps(_mm_load_ps(inp),_mm_set1_ps(zs)));
}
_mm_sfence();
if(piece->pipe->mask_display)
dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
void process_sse2(struct dt_iop_module_t *self, dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
void *const ovoid, const dt_iop_roi_t *const roi_in, const dt_iop_roi_t *const roi_out)
{
const dt_iop_colorout_data_t *const d = (dt_iop_colorout_data_t *)piece->data;
const int ch = piece->colors;
const int gamutcheck = (d->mode == DT_PROFILE_GAMUTCHECK);
if(!isnan(d->cmatrix[0]))
{
// fprintf(stderr,"Using cmatrix codepath\n");
// convert to rgb using matrix
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(int j = 0; j < roi_out->height; j++)
{
float *in = (float *)ivoid + (size_t)ch * roi_in->width * j;
float *out = (float *)ovoid + (size_t)ch * roi_out->width * j;
const __m128 m0 = _mm_set_ps(0.0f, d->cmatrix[6], d->cmatrix[3], d->cmatrix[0]);
const __m128 m1 = _mm_set_ps(0.0f, d->cmatrix[7], d->cmatrix[4], d->cmatrix[1]);
const __m128 m2 = _mm_set_ps(0.0f, d->cmatrix[8], d->cmatrix[5], d->cmatrix[2]);
for(int i = 0; i < roi_out->width; i++, in += ch, out += ch)
{
const __m128 xyz = dt_Lab_to_XYZ_SSE(_mm_load_ps(in));
const __m128 t
= _mm_add_ps(_mm_mul_ps(m0, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(0, 0, 0, 0))),
_mm_add_ps(_mm_mul_ps(m1, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(1, 1, 1, 1))),
_mm_mul_ps(m2, _mm_shuffle_ps(xyz, xyz, _MM_SHUFFLE(2, 2, 2, 2)))));
_mm_stream_ps(out, t);
}
}
_mm_sfence();
process_fastpath_apply_tonecurves(self, piece, ivoid, ovoid, roi_in, roi_out);
}
else
{
// fprintf(stderr,"Using xform codepath\n");
const __m128 outofgamutpixel = _mm_set_ps(0.0f, 1.0f, 1.0f, 0.0f);
#ifdef _OPENMP
#pragma omp parallel for schedule(static) default(none)
#endif
for(int k = 0; k < roi_out->height; k++)
{
const float *in = ((float *)ivoid) + (size_t)ch * k * roi_out->width;
float *out = ((float *)ovoid) + (size_t)ch * k * roi_out->width;
cmsDoTransform(d->xform, in, out, roi_out->width);
if(gamutcheck)
{
for(int j = 0; j < roi_out->width; j++, out += 4)
{
const __m128 pixel = _mm_load_ps(out);
__m128 ingamut = _mm_cmplt_ps(pixel, _mm_set_ps(-FLT_MAX, 0.0f, 0.0f, 0.0f));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
ingamut = _mm_or_ps(_mm_unpacklo_ps(ingamut, ingamut), _mm_unpackhi_ps(ingamut, ingamut));
const __m128 result
= _mm_or_ps(_mm_and_ps(ingamut, outofgamutpixel), _mm_andnot_ps(ingamut, pixel));
_mm_stream_ps(out, result);
}
}
}
_mm_sfence();
}
if(piece->pipe->mask_display) dt_iop_alpha_copy(ivoid, ovoid, roi_out->width, roi_out->height);
}
