From bfdea93a9c5b87f47c63dcca1d26bb14a21a3c3b Mon Sep 17 00:00:00 2001 From: Michael Natterer Date: Thu, 19 Jan 2017 14:31:40 +0100 Subject: [PATCH] app: indentation and formatting cleanup in gimpblendcomposite.h Also remove all includes, they should already be there when this header gets included. --- .../layer-modes/gimpblendcomposite.h | 893 ++++++++++-------- 1 file changed, 488 insertions(+), 405 deletions(-) diff --git a/app/operations/layer-modes/gimpblendcomposite.h b/app/operations/layer-modes/gimpblendcomposite.h index 7483e21147..b36935466e 100644 --- a/app/operations/layer-modes/gimpblendcomposite.h +++ b/app/operations/layer-modes/gimpblendcomposite.h @@ -20,14 +20,6 @@ #define __GIMP_BLEND_COMPOSITE_H__ -#include -#include -#include -#include -#include -#include "../operations-enums.h" -#include "../operations-types.h" -#include "libgimpcolor/gimpcolor.h" extern const Babl *_gimp_fish_rgba_to_perceptual; extern const Babl *_gimp_fish_perceptual_to_rgba; extern const Babl *_gimp_fish_perceptual_to_laba; @@ -35,6 +27,7 @@ extern const Babl *_gimp_fish_rgba_to_laba; extern const Babl *_gimp_fish_laba_to_rgba; extern const Babl *_gimp_fish_laba_to_perceptual; + static inline void compfun_src_atop (gfloat *in, gfloat *layer, @@ -46,27 +39,30 @@ compfun_src_atop (gfloat *in, while (samples--) { gfloat comp_alpha = layer[ALPHA] * opacity; + if (mask) comp_alpha *= *mask; - + if (comp_alpha == 0.0f) { out[RED] = in[RED]; out[GREEN] = in[GREEN]; out[BLUE] = in[BLUE]; } - else + else { - gint b; + gint b; + for (b = RED; b < ALPHA; b++) out[b] = layer[b] * comp_alpha + in[b] * (1.0f - comp_alpha); } + out[ALPHA] = in[ALPHA]; - + in += 4; out += 4; layer += 4; - + if (mask) mask++; } @@ -85,32 +81,34 @@ compfun_src_over (gfloat *in, { gfloat new_alpha; gfloat comp_alpha = layer[ALPHA] * opacity; + if (mask) comp_alpha *= *mask; - + new_alpha = comp_alpha + (1.0f - comp_alpha) * in[ALPHA]; - + if (comp_alpha == 0.0f || new_alpha == 0.0f) { out[RED] = in[RED]; out[GREEN] = in[GREEN]; out[BLUE] = in[BLUE]; } - else + else { - gint b; gfloat ratio = comp_alpha / new_alpha; + gint b; + for (b = RED; b < ALPHA; b++) out[b] = ratio * (in[ALPHA] * (comp[b] - layer[b]) + layer[b] - in[b]) + in[b]; } - + out[ALPHA] = new_alpha; - + in += 4; layer += 4; comp += 4; out += 4; - + if (mask) mask++; } @@ -128,9 +126,10 @@ compfun_src_in (gfloat *in, while (samples--) { gfloat new_alpha = in[ALPHA] * layer[ALPHA] * opacity; + if (mask) new_alpha *= *mask; - + if (new_alpha == 0.0f) { out[RED] = in[RED]; @@ -143,11 +142,13 @@ compfun_src_in (gfloat *in, out[GREEN] = layer[GREEN]; out[BLUE] = layer[BLUE]; } + out[ALPHA] = new_alpha; + in += 4; out += 4; layer += 4; - + if (mask) mask++; } @@ -175,14 +176,14 @@ gimp_composite_blend (gfloat *in, const Babl *fish_to_blend = NULL; const Babl *fish_to_composite = NULL; const Babl *fish_from_composite = NULL; - + switch (blend_trc) - { + { default: case GIMP_LAYER_BLEND_RGB_LINEAR: fish_to_blend = NULL; switch (composite_trc) - { + { case GIMP_LAYER_BLEND_LAB: fish_to_composite = _gimp_fish_rgba_to_laba; fish_from_composite = _gimp_fish_laba_to_rgba; @@ -195,12 +196,13 @@ gimp_composite_blend (gfloat *in, fish_to_composite = _gimp_fish_rgba_to_perceptual; fish_from_composite = _gimp_fish_perceptual_to_rgba; break; - } + } break; + case GIMP_LAYER_BLEND_LAB: fish_to_blend = _gimp_fish_rgba_to_laba; switch (composite_trc) - { + { case GIMP_LAYER_BLEND_LAB: default: fish_to_composite = NULL; @@ -213,12 +215,13 @@ gimp_composite_blend (gfloat *in, fish_to_composite = _gimp_fish_laba_to_perceptual; fish_from_composite = _gimp_fish_perceptual_to_rgba; break; - } + } break; + case GIMP_LAYER_BLEND_RGB_PERCEPTUAL: fish_to_blend = _gimp_fish_rgba_to_perceptual; switch (composite_trc) - { + { case GIMP_LAYER_BLEND_LAB: default: fish_to_composite = _gimp_fish_perceptual_to_laba; @@ -231,21 +234,21 @@ gimp_composite_blend (gfloat *in, fish_to_composite = NULL; fish_from_composite = _gimp_fish_perceptual_to_rgba; break; - } + } break; - } + } if (in == out) /* in-place detected, avoid clobbering since we need to read it for the compositing stage */ - blend_out = alloca (sizeof (gfloat) * 4 * samples); + blend_out = g_alloca (sizeof (gfloat) * 4 * samples); if (fish_to_blend) - { - blend_in = alloca (sizeof (gfloat) * 4 * samples); - blend_layer = alloca (sizeof (gfloat) * 4 * samples); - babl_process (fish_to_blend, in, blend_in, samples); - babl_process (fish_to_blend, layer, blend_layer, samples); - } + { + blend_in = g_alloca (sizeof (gfloat) * 4 * samples); + blend_layer = g_alloca (sizeof (gfloat) * 4 * samples); + babl_process (fish_to_blend, in, blend_in, samples); + babl_process (fish_to_blend, layer, blend_layer, samples); + } blendfun (blend_in, blend_layer, blend_out, samples); @@ -254,35 +257,38 @@ gimp_composite_blend (gfloat *in, babl_process (fish_to_composite, blend_in, blend_in, samples); babl_process (fish_to_composite, blend_out, blend_out, samples); } - + switch (composite_mode) - { + { case GIMP_LAYER_COMPOSITE_SRC_ATOP: default: compfun_src_atop (blend_in, blend_out, mask, opacity, out, samples); break; + case GIMP_LAYER_COMPOSITE_SRC_OVER: if (fish_to_composite) babl_process (fish_to_composite, blend_layer, blend_layer, samples); compfun_src_over (blend_in, blend_layer, blend_out, mask, opacity, out, samples); break; + case GIMP_LAYER_COMPOSITE_DST_ATOP: if (fish_to_composite) babl_process (fish_to_composite, blend_layer, blend_layer, samples); compfun_src_atop (blend_out, blend_in, mask, opacity, out, samples); /* swapped arguments */ break; + case GIMP_LAYER_COMPOSITE_SRC_IN: compfun_src_in (blend_in, blend_out, mask, opacity, out, samples); break; - } + } if (fish_from_composite) - { - babl_process (fish_from_composite, out, out, samples); - } + { + babl_process (fish_from_composite, out, out, samples); + } } - + static inline void blendfun_screen (const float *dest, const float *src, @@ -290,18 +296,21 @@ blendfun_screen (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - out[c] = 1.0f - (1.0f - dest[c]) * (1.0f - src[c]); + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = 1.0f - (1.0f - dest[c]) * (1.0f - src[c]); + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -311,18 +320,21 @@ blendfun_addition (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - out[c] = dest[c] + src[c]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = dest[c] + src[c]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -332,18 +344,21 @@ blendfun_subtract (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - out[c] = dest[c] - src[c]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = dest[c] - src[c]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -353,18 +368,21 @@ blendfun_multiply (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - out[c] = dest[c] * src[c]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = dest[c] * src[c]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -374,18 +392,21 @@ blendfun_normal (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - out[c] = src[c]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = src[c]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -395,23 +416,28 @@ blendfun_burn (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat comp = 1.0f - (1.0f - dest[c]) / src[c]; - /* The CLAMP macro is deliberately inlined and written to map comp == - * NAN (0 / 0) -> 1 */ - out[c] = comp < 0 ? 0.0f : comp < 1.0f ? comp : 1.0f; - } + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + { + gfloat comp = 1.0f - (1.0f - dest[c]) / src[c]; + + /* The CLAMP macro is deliberately inlined and written + * to map comp == NAN (0 / 0) -> 1 + */ + out[c] = comp < 0 ? 0.0f : comp < 1.0f ? comp : 1.0f; + } + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -421,20 +447,21 @@ blendfun_darken_only (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - out[c] = MIN(dest[c], src[c]); - } + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = MIN (dest[c], src[c]); + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -444,20 +471,21 @@ blendfun_lighten_only (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - out[c] = MAX(dest[c], src[c]); - } + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = MAX (dest[c], src[c]); + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -467,22 +495,26 @@ blendfun_difference (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - out[c] = dest[c] - src[c]; - if (out[c] < 0) - out[c] = -out[c]; - } + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + { + out[c] = dest[c] - src[c]; + + if (out[c] < 0) + out[c] = -out[c]; + } + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -492,29 +524,33 @@ blendfun_divide (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat comp = dest[c] / src[c]; + if (src[ALPHA] != 0.0f) + { + gint c; - /* make infinities(or NaN) correspond to a high number, to get more - * predictable math, ideally higher than 5.0 but it seems like some - * babl conversions might be acting up then - */ - if (!(comp > -42949672.0f && comp < 5.0f)) - comp = 5.0f; + for (c = 0; c < 3; c++) + { + gfloat comp = dest[c] / src[c]; - out[c] = comp; - } + /* make infinities(or NaN) correspond to a high number, + * to get more predictable math, ideally higher than 5.0 + * but it seems like some babl conversions might be + * acting up then + */ + if (!(comp > -42949672.0f && comp < 5.0f)) + comp = 5.0f; + + out[c] = comp; + } + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -524,26 +560,29 @@ blendfun_dodge (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat comp = dest[c] / (1.0f - src[c]); - comp = MIN (comp, 1.0f); + if (src[ALPHA] != 0.0f) + { + gint c; - out[c] = comp; - } + for (c = 0; c < 3; c++) + { + gfloat comp = dest[c] / (1.0f - src[c]); + + comp = MIN (comp, 1.0f); + + out[c] = comp; + } + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } - static inline void blendfun_grain_extract (const float *dest, const float *src, @@ -551,20 +590,21 @@ blendfun_grain_extract (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - out[c] = dest[c] - src[c] + 0.5f; - } + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + out[c] = dest[c] - src[c] + 0.5f; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -574,22 +614,22 @@ blendfun_grain_merge (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - out[c] = dest[c] + src[c] - 0.5f; - } - } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } -} + if (src[ALPHA] != 0.0f) + { + gint c; + for (c = 0; c < 3; c++) + out[c] = dest[c] + src[c] - 0.5f; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; + } +} static inline void blendfun_hardlight (const float *dest, @@ -598,31 +638,36 @@ blendfun_hardlight (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat comp; - if (src[c] > 0.5f) - { - comp = (1.0f - dest[c]) * (1.0f - (src[c] - 0.5f) * 2.0f); - comp = MIN (1 - comp, 1); - } - else - { - comp = dest[c] * (src[c] * 2.0f); - comp = MIN (comp, 1.0f); - } - out[c] = comp; - } - out[ALPHA] = src[ALPHA]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + { + gfloat comp; + + if (src[c] > 0.5f) + { + comp = (1.0f - dest[c]) * (1.0f - (src[c] - 0.5f) * 2.0f); + comp = MIN (1 - comp, 1); + } + else + { + comp = dest[c] * (src[c] * 2.0f); + comp = MIN (comp, 1.0f); + } + + out[c] = comp; + } + + out[ALPHA] = src[ALPHA]; + } + + out += 4; + src += 4; + dest += 4; } - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -632,25 +677,28 @@ blendfun_softlight (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat multiply = dest[c] * src[c]; - gfloat screen = 1.0f - (1.0f - dest[c]) * (1.0f - src[c]); - gfloat comp = (1.0f - src[c]) * multiply + dest[c] * screen; - out[c] = comp; - } - out[ALPHA] = src[ALPHA]; - } - out += 4; - src += 4; - dest += 4; - } -} + if (src[ALPHA] != 0.0f) + { + gint c; + for (c = 0; c < 3; c++) + { + gfloat multiply = dest[c] * src[c]; + gfloat screen = 1.0f - (1.0f - dest[c]) * (1.0f - src[c]); + gfloat comp = (1.0f - src[c]) * multiply + dest[c] * screen; + + out[c] = comp; + } + + out[ALPHA] = src[ALPHA]; + } + + out += 4; + src += 4; + dest += 4; + } +} static inline void blendfun_overlay (const float *dest, @@ -659,29 +707,34 @@ blendfun_overlay (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - int c; - for (c = 0; c < 3; c++) - { - gfloat comp; - if (src[c] < 0.5f) - { - comp = 2.0f * dest[c] * src[c]; - } - else - { - comp = 1.0f - 2.0f * (1.0f - src[c]) * (1.0f - dest[c]); - } - out[c] = comp; - } - out[ALPHA] = src[ALPHA]; + if (src[ALPHA] != 0.0f) + { + gint c; + + for (c = 0; c < 3; c++) + { + gfloat comp; + + if (src[c] < 0.5f) + { + comp = 2.0f * dest[c] * src[c]; + } + else + { + comp = 1.0f - 2.0f * (1.0f - src[c]) * (1.0f - dest[c]); + } + + out[c] = comp; + } + + out[ALPHA] = src[ALPHA]; + } + + out += 4; + src += 4; + dest += 4; } - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -691,26 +744,32 @@ blendfun_hsv_color (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - GimpRGB dest_rgb = {dest[0], dest[1], dest[2]}; - GimpRGB src_rgb = {src[0], src[1], src[2]}; - GimpHSL src_hsl, dest_hsl; - gimp_rgb_to_hsl (&dest_rgb, &dest_hsl); - gimp_rgb_to_hsl (&src_rgb, &src_hsl); - dest_hsl.h = src_hsl.h; - dest_hsl.s = src_hsl.s; - gimp_hsl_to_rgb (&dest_hsl, &dest_rgb); - out[RED] = dest_rgb.r; - out[GREEN] = dest_rgb.g; - out[BLUE] = dest_rgb.b; + if (src[ALPHA] != 0.0f) + { + GimpRGB dest_rgb = { dest[0], dest[1], dest[2] }; + GimpRGB src_rgb = { src[0], src[1], src[2] }; + GimpHSL src_hsl, dest_hsl; + + gimp_rgb_to_hsl (&dest_rgb, &dest_hsl); + gimp_rgb_to_hsl (&src_rgb, &src_hsl); + + dest_hsl.h = src_hsl.h; + dest_hsl.s = src_hsl.s; + + gimp_hsl_to_rgb (&dest_hsl, &dest_rgb); + + out[RED] = dest_rgb.r; + out[GREEN] = dest_rgb.g; + out[BLUE] = dest_rgb.b; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -720,25 +779,30 @@ blendfun_hsv_hue (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - GimpRGB dest_rgb = {dest[0], dest[1], dest[2]}; - GimpRGB src_rgb = {src[0], src[1], src[2]}; - GimpHSV src_hsv, dest_hsv; - gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); - gimp_rgb_to_hsv (&src_rgb, &src_hsv); - dest_hsv.h = src_hsv.h; - gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); - out[RED] = dest_rgb.r; - out[GREEN] = dest_rgb.g; - out[BLUE] = dest_rgb.b; + if (src[ALPHA] != 0.0f) + { + GimpRGB dest_rgb = { dest[0], dest[1], dest[2] }; + GimpRGB src_rgb = { src[0], src[1], src[2] }; + GimpHSV src_hsv, dest_hsv; + + gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); + gimp_rgb_to_hsv (&src_rgb, &src_hsv); + + dest_hsv.h = src_hsv.h; + gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); + + out[RED] = dest_rgb.r; + out[GREEN] = dest_rgb.g; + out[BLUE] = dest_rgb.b; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -748,25 +812,30 @@ blendfun_hsv_saturation (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - GimpRGB dest_rgb = {dest[0], dest[1], dest[2]}; - GimpRGB src_rgb = {src[0], src[1], src[2]}; - GimpHSV src_hsv, dest_hsv; - gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); - gimp_rgb_to_hsv (&src_rgb, &src_hsv); - dest_hsv.s = src_hsv.s; - gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); - out[RED] = dest_rgb.r; - out[GREEN] = dest_rgb.g; - out[BLUE] = dest_rgb.b; + if (src[ALPHA] != 0.0f) + { + GimpRGB dest_rgb = { dest[0], dest[1], dest[2] }; + GimpRGB src_rgb = { src[0], src[1], src[2] }; + GimpHSV src_hsv, dest_hsv; + + gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); + gimp_rgb_to_hsv (&src_rgb, &src_hsv); + + dest_hsv.s = src_hsv.s; + gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); + + out[RED] = dest_rgb.r; + out[GREEN] = dest_rgb.g; + out[BLUE] = dest_rgb.b; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -776,25 +845,30 @@ blendfun_hsv_value (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - GimpRGB dest_rgb = {dest[0], dest[1], dest[2]}; - GimpRGB src_rgb = {src[0], src[1], src[2]}; - GimpHSV src_hsv, dest_hsv; - gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); - gimp_rgb_to_hsv (&src_rgb, &src_hsv); - dest_hsv.v = src_hsv.v; - gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); - out[RED] = dest_rgb.r; - out[GREEN] = dest_rgb.g; - out[BLUE] = dest_rgb.b; + if (src[ALPHA] != 0.0f) + { + GimpRGB dest_rgb = { dest[0], dest[1], dest[2] }; + GimpRGB src_rgb = { src[0], src[1], src[2] }; + GimpHSV src_hsv, dest_hsv; + + gimp_rgb_to_hsv (&dest_rgb, &dest_hsv); + gimp_rgb_to_hsv (&src_rgb, &src_hsv); + + dest_hsv.v = src_hsv.v; + gimp_hsv_to_rgb (&dest_hsv, &dest_rgb); + + out[RED] = dest_rgb.r; + out[GREEN] = dest_rgb.g; + out[BLUE] = dest_rgb.b; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -804,30 +878,33 @@ blendfun_lch_chroma (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - gfloat A1 = dest[1]; - gfloat B1 = dest[2]; - gfloat c1 = hypotf (A1, B1); - - if (c1 != 0.0f) + if (src[ALPHA] != 0.0f) { - gfloat A2 = src[1]; - gfloat B2 = src[2]; - gfloat c2 = hypotf (A2, B2); - gfloat A = c2 * A1 / c1; - gfloat B = c2 * B1 / c1; - out[0] = dest[0]; - out[1] = A; - out[2] = B; + gfloat A1 = dest[1]; + gfloat B1 = dest[2]; + gfloat c1 = hypotf (A1, B1); + + if (c1 != 0.0f) + { + gfloat A2 = src[1]; + gfloat B2 = src[2]; + gfloat c2 = hypotf (A2, B2); + gfloat A = c2 * A1 / c1; + gfloat B = c2 * B1 / c1; + + out[0] = dest[0]; + out[1] = A; + out[2] = B; + } } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[ALPHA] = src[ALPHA]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -837,17 +914,19 @@ blendfun_lch_color (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - out[0] = dest[0]; - out[1] = src[1]; - out[2] = src[2]; - } - out[3] = src[3]; - out += 4; - src += 4; - dest += 4; + if (src[ALPHA] != 0.0f) + { + out[0] = dest[0]; + out[1] = src[1]; + out[2] = src[2]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } } @@ -858,37 +937,39 @@ blendfun_lch_hue (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - gfloat A2 = src[1]; - gfloat B2 = src[2]; - gfloat c2 = hypotf (A2, B2); - - if (c2 > 0.1f) + if (src[ALPHA] != 0.0f) { - gfloat A1 = dest[1]; - gfloat B1 = dest[2]; - gfloat c1 = hypotf (A1, B1); - gfloat A = c1 * A2 / c2; - gfloat B = c1 * B2 / c2; + gfloat A2 = src[1]; + gfloat B2 = src[2]; + gfloat c2 = hypotf (A2, B2); - out[0] = dest[0]; - out[1] = A; - out[2] = B; - } - else - { - out[0] = dest[0]; - out[1] = dest[1]; - out[2] = dest[2]; + if (c2 > 0.1f) + { + gfloat A1 = dest[1]; + gfloat B1 = dest[2]; + gfloat c1 = hypotf (A1, B1); + gfloat A = c1 * A2 / c2; + gfloat B = c1 * B2 / c2; + + out[0] = dest[0]; + out[1] = A; + out[2] = B; + } + else + { + out[0] = dest[0]; + out[1] = dest[1]; + out[2] = dest[2]; + } } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[3] = src[3]; - out += 4; - src += 4; - dest += 4; - } } static inline void @@ -898,18 +979,20 @@ blendfun_lch_lightness (const float *dest, int samples) { while (samples--) - { - if (src[ALPHA] != 0.0f) { - out[0] = src[0]; - out[1] = dest[1]; - out[2] = dest[2]; + if (src[ALPHA] != 0.0f) + { + out[0] = src[0]; + out[1] = dest[1]; + out[2] = dest[2]; + } + + out[ALPHA] = src[ALPHA]; + + out += 4; + src += 4; + dest += 4; } - out[3] = src[3]; - out += 4; - src += 4; - dest += 4; - } } -#endif +#endif /* __GIMP_BLEND_COMPOSITE_H__ */