flatten.c File Reference

#include "xcftools.h"
#include "flatten.h"
#include "pixels.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>

Go to the source code of this file.

Classes
struct	HSV

Macros
#define	exotic_combinator   static inline unsigned __ATTRIBUTE__((const))
#define	HEXTANT(b, m, t)
#define	HEXTANT(b, m, t)
#define	UNIFORM(mode)

Functions
static struct Tile *	__ATTRIBUTE__ ((noinline))
static rgba	__ATTRIBUTE__ ((noinline, const))
static int	addBackground (struct FlattenSpec *spec, struct Tile *tile, unsigned ncols)
static void	collector (unsigned num, rgba *row)
static void	dissolveTile (struct Tile *tile)
rgba **	flattenAll (struct FlattenSpec *spec)
int	flattenIncrementally (struct FlattenSpec *spec, lineCallback callback)
static struct Tile *	flattenTopdown (struct FlattenSpec *spec, struct Tile *top, unsigned nlayers, const struct rect *where)
static void	RGBtoHSV (rgba rgb, struct HSV *hsv)
static void	roundAlpha (struct Tile *tile)
void	shipoutWithCallback (struct FlattenSpec *spec, rgba **pixels, lineCallback callback)
exotic_combinator	ucombine_ADDITION (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_BURN (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_DARKEN_ONLY (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_DIFFERENCE (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_DIVIDE (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_DODGE (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_GRAIN_EXTRACT (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_GRAIN_MERGE (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_HARDLIGHT (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_LIGHTEN_ONLY (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_MULTIPLY (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_OVERLAY (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_SCREEN (uint8_t bot, uint8_t top)
exotic_combinator	ucombine_SUBTRACT (uint8_t bot, uint8_t top)

Variables
static rgba **	collectPointer

Macro Definition Documentation

exotic_combinator

#define exotic_combinator   static inline unsigned __ATTRIBUTE__((const))

Definition at line 122 of file flatten.c.

HEXTANT [1/2]

#define HEXTANT	(		b,
			m,
			t )

Value:

    hsv->ch1 = b, hsv->ch2 = m, hsv->ch3 = t, \
    hsv->hue = HUE_ ## b ## _ ## m ## _ ## t

HEXTANT [2/2]

#define HEXTANT	(		b,
			m,
			t )

Value:

    case HUE_ ## b ## _ ## m ## _ ## t : \
    b = hsvBot.ch1; m = hsvBot.ch2; t = hsvBot.ch3; break;

UNIFORM

#define UNIFORM

(

mode

)

Value:

    case GIMP_ ## mode ## _MODE: \
    RED   = ucombine_ ## mode (bot->pixels[i]>>RED_SHIFT  ,  \
    top->pixels[i]>>RED_SHIFT  ); \
    GREEN = ucombine_ ## mode (bot->pixels[i]>>GREEN_SHIFT,  \
    top->pixels[i]>>GREEN_SHIFT); \
    BLUE  = ucombine_ ## mode (bot->pixels[i]>>BLUE_SHIFT ,  \
    top->pixels[i]>>BLUE_SHIFT ); \
    break ;

Function Documentation

__ATTRIBUTE__() [1/2]

static int __ATTRIBUTE__ ( (noinline) )

static

Definition at line 76 of file flatten.c.

{
    unsigned i ;
    assertTileCompatibility(bot,top);
 
    /* See if there is an easy winner */
    if( (bot->summary & TILESUMMARY_ALLNULL) ||
            (top->summary & TILESUMMARY_ALLFULL) ) {
        freeTile(bot);
        return top ;
    }
    if( top->summary & TILESUMMARY_ALLNULL ) {
        freeTile(top);
        return bot ;
    }
 
    /* Try hard to make top win */
    for( i=0; ; i++ ) {
        if( i == top->count ) {
            freeTile(bot);
            return top ;
        }
        if( !(NULLALPHA(bot->pixels[i]) || FULLALPHA(top->pixels[i])) )
            break ;
    }
 
    INIT_SCALETABLE_IF( !(top->summary & TILESUMMARY_CRISP) );
 
    /* Otherwise bot wins, but is forever changed ... */
    if( (top->summary & TILESUMMARY_ALLNULL) == 0 ) {
        unsigned i ;
        invalidateSummary(bot,0);
        for( i=0 ; i < top->count ; i++ ) {
            if( !NULLALPHA(top->pixels[i]) ) {
                if( FULLALPHA(top->pixels[i]) || NULLALPHA(bot->pixels[i]) )
                    bot->pixels[i] = top->pixels[i] ;
                else
                    bot->pixels[i] = composite_one(bot->pixels[i],top->pixels[i]);
            }
        }
    }
    freeTile(top);
    return bot ;
}

References assertTileCompatibility, Tile::count, freeTile(), FULLALPHA, INIT_SCALETABLE_IF, invalidateSummary, NULLALPHA, Tile::pixels, Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, and TILESUMMARY_CRISP.

__ATTRIBUTE__() [2/2]

static rgba __ATTRIBUTE__ ( (noinline, const) )

static

Definition at line 26 of file flatten.c.

{
    unsigned tfrac, alpha ;
 
    tfrac = ALPHA(top) ;
    alpha = 255 ;
    if( !FULLALPHA(bot) ) {
        alpha = 255 ^ scaletable[255-ALPHA(bot)][255-ALPHA(top)] ;
        /* This peculiar combination of ^ and - makes the GCC code
         * generator for i386 particularly happy.
         */
        tfrac = (256*ALPHA(top) - 1) / alpha ;
        /* Tfrac is the fraction of the coposited pixel's covered area
         * that comes from the top pixel.
         * For mathematical accuracy we ought to scale by 255 and
         * subtract alpha/2, but this is faster, and never misses the
         * true value by more than one 1/255. This effect is completely
         * overshadowed by the linear interpolation in the first place.
         * (I.e. gamma is ignored when combining intensities).
         *   [In any case, complete fairness is not possible: if the
         *    bottom pixel had alpha=170 and the top has alpha=102,
         *    each should contribute equally to the color of the
         *    resulting alpha=204 pixel, which is not possible in general]
         * Subtracting one helps the topfrac never be 256, which would
         * be bad.
         * On the other hand it means that we would get tfrac=-1 if the
         * top pixel is completely transparent, and we get a division
         * by zero if _both_ pixels are fully transparent. These cases
         * must be handled by all callers.
         *    More snooping in the Gimp sources reveal that it uses
         *    floating-point for its equivalent of tfrac when the
         *    bottom layer has an alpha channel. (alphify() macro
         *    in paint-funcs.c). What gives?
         */
    }
    return (alpha << ALPHA_SHIFT)
            + ((uint32_t)scaletable[  tfrac  ][255&(top>>RED_SHIFT  )] << RED_SHIFT   )
            + ((uint32_t)scaletable[  tfrac  ][255&(top>>GREEN_SHIFT)] << GREEN_SHIFT )
            + ((uint32_t)scaletable[  tfrac  ][255&(top>>BLUE_SHIFT )] << BLUE_SHIFT  )
            + ((uint32_t)scaletable[255^tfrac][255&(bot>>RED_SHIFT  )] << RED_SHIFT   )
            + ((uint32_t)scaletable[255^tfrac][255&(bot>>GREEN_SHIFT)] << GREEN_SHIFT )
            + ((uint32_t)scaletable[255^tfrac][255&(bot>>BLUE_SHIFT )] << BLUE_SHIFT  )
            ;
}

References ALPHA, ALPHA_SHIFT, BLUE_SHIFT, FULLALPHA, GREEN_SHIFT, RED_SHIFT, and scaletable.

addBackground()

static int addBackground ( struct FlattenSpec * spec, struct Tile * tile, unsigned ncols )

static

Definition at line 589 of file flatten.c.

{
    unsigned i ;
 
    if( tileSummary(tile) & TILESUMMARY_ALLFULL )
        return XCF_OK;
 
    switch( spec->partial_transparency_mode ) {
    case FORBID_PARTIAL_TRANSPARENCY:
        if( !(tileSummary(tile) & TILESUMMARY_CRISP) ) {
            FatalGeneric(102,_("Flattened image has partially transparent pixels"));
            return XCF_ERROR;
        }
        break ;
    case DISSOLVE_PARTIAL_TRANSPARENCY:
        dissolveTile(tile);
        break ;
    case ALLOW_PARTIAL_TRANSPARENCY:
    case PARTIAL_TRANSPARENCY_IMPOSSIBLE:
        break ;
    }
 
    if( spec->default_pixel == CHECKERED_BACKGROUND ) {
        INIT_SCALETABLE_IF( !(tile->summary & TILESUMMARY_CRISP ) );
        for( i=0; i<tile->count; i++ )
            if( !FULLALPHA(tile->pixels[i]) ) {
                rgba fillwith = ((i/ncols)^(i%ncols))&8 ? 0x66 : 0x99 ;
                fillwith = graytable[fillwith] + (255 << ALPHA_SHIFT) ;
                if( NULLALPHA(tile->pixels[i]) )
                    tile->pixels[i] = fillwith ;
                else
                    tile->pixels[i] = composite_one(fillwith,tile->pixels[i]);
            }
        tile->summary = TILESUMMARY_UPTODATE +
                TILESUMMARY_ALLFULL + TILESUMMARY_CRISP ;
        return XCF_OK;
    }
    if( !FULLALPHA(spec->default_pixel) )  return XCF_OK;
    if( tileSummary(tile) & TILESUMMARY_ALLNULL ) {
        fillTile(tile,spec->default_pixel);
    } else {
        INIT_SCALETABLE_IF( !(tile->summary & TILESUMMARY_CRISP) );
        for( i=0; i<tile->count; i++ )
            if( NULLALPHA(tile->pixels[i]) )
                tile->pixels[i] = spec->default_pixel ;
            else if( FULLALPHA(tile->pixels[i]) )
                ;
            else
                tile->pixels[i] = composite_one(spec->default_pixel,tile->pixels[i]);
 
        tile->summary = TILESUMMARY_UPTODATE +
                TILESUMMARY_ALLFULL + TILESUMMARY_CRISP ;
    }
    return XCF_OK;
}

References _, ALPHA_SHIFT, CHECKERED_BACKGROUND, Tile::count, FlattenSpec::default_pixel, dissolveTile(), FatalGeneric(), fillTile(), FULLALPHA, graytable, INIT_SCALETABLE_IF, NULLALPHA, FlattenSpec::partial_transparency_mode, Tile::pixels, Tile::summary, tileSummary(), TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, TILESUMMARY_UPTODATE, XCF_ERROR, and XCF_OK.

collector()

static void collector ( unsigned num, rgba * row )

static

Definition at line 704 of file flatten.c.

{
    (void)num;
    *collectPointer++ = row ;
}

References collectPointer, and void().

dissolveTile()

static void dissolveTile ( struct Tile * tile )

static

Definition at line 433 of file flatten.c.

{
    unsigned i ;
    summary_t summary ;
    assert( tile->refcount == 1 );
    if( (tile->summary & TILESUMMARY_CRISP) )
        return ;
    summary = TILESUMMARY_UPTODATE + TILESUMMARY_ALLNULL
            + TILESUMMARY_ALLFULL + TILESUMMARY_CRISP ;
    for( i = 0 ; i < tile->count ; i++ ) {
        if( FULLALPHA(tile->pixels[i]) )
            summary &= ~TILESUMMARY_ALLNULL ;
        else if ( NULLALPHA(tile->pixels[i]) )
            summary &= ~TILESUMMARY_ALLFULL ;
        else if( ALPHA(tile->pixels[i]) > rand() % 0xFF ) {
            tile->pixels[i] |= 255 << ALPHA_SHIFT ;
            summary &= ~TILESUMMARY_ALLNULL ;
        } else {
            tile->pixels[i] = 0 ;
            summary &= ~TILESUMMARY_ALLFULL ;
        }
    }
    tile->summary = summary ;
}

References ALPHA, ALPHA_SHIFT, Tile::count, FULLALPHA, NULLALPHA, Tile::pixels, Tile::refcount, Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, and TILESUMMARY_UPTODATE.

flattenAll()

rgba ** flattenAll

(

struct FlattenSpec *

spec

)

Definition at line 711 of file flatten.c.

{
    rgba **rows = xcfmalloc(spec->dim.height * sizeof(rgba*));
    if( verboseFlag )
        fprintf(stderr,_("Flattening image ..."));
    collectPointer = rows ;
    if (flattenIncrementally(spec,collector) != XCF_OK) {
        xcffree(rows);
        collectPointer = XCF_PTR_EMPTY;
        return XCF_PTR_EMPTY;
    }
    if( verboseFlag )
        fprintf(stderr,"\n");
    return rows ;
}

References _, collector(), collectPointer, FlattenSpec::dim, flattenIncrementally(), tileDimensions::height, verboseFlag, XCF_OK, XCF_PTR_EMPTY, xcffree(), and xcfmalloc().

flattenIncrementally()

int flattenIncrementally	(	struct FlattenSpec *	spec,
		lineCallback	callback )

Definition at line 646 of file flatten.c.

{
    rgba *rows[TILE_HEIGHT] ;
    unsigned i, y, nrows, ncols ;
    struct rect where ;
    struct Tile *tile ;
    static struct Tile toptile ;
 
    toptile.count = TILE_HEIGHT * TILE_WIDTH ;
    fillTile(&toptile,0);
 
    for( where.t = spec->dim.c.t; where.t < spec->dim.c.b; where.t=where.b ) {
        where.b = TILE_TOP(where.t)+TILE_HEIGHT ;
        if( where.b > spec->dim.c.b ) where.b = spec->dim.c.b ;
        nrows = where.b - where.t ;
        for( y = 0; y < nrows ; y++ )
            rows[y] = xcfmalloc(4*(spec->dim.c.r-spec->dim.c.l));
 
        for( where.l = spec->dim.c.l; where.l < spec->dim.c.r; where.l=where.r ) {
            where.r = TILE_LEFT(where.l)+TILE_WIDTH ;
            if( where.r > spec->dim.c.r ) where.r = spec->dim.c.r ;
            ncols = where.r - where.l ;
 
            toptile.count = ncols * nrows ;
            toptile.refcount = 2 ; /* For bug checking */
            assert( toptile.summary == TILESUMMARY_UPTODATE +
                    TILESUMMARY_ALLNULL + TILESUMMARY_CRISP );
            tile = flattenTopdown(spec,&toptile,spec->numLayers,&where) ;
            if (tile == XCF_PTR_EMPTY) {
                return XCF_ERROR;
            }
            toptile.refcount-- ; /* addBackground may change destructively */
            if (addBackground(spec,tile,ncols) != XCF_OK) {
                return XCF_ERROR;
            }
 
            for( i = 0 ; i < tile->count ; i++ )
                if( NULLALPHA(tile->pixels[i]) )
                    tile->pixels[i] = 0 ;
            for( y = 0 ; y < nrows ; y++ )
                memcpy(rows[y] + (where.l - spec->dim.c.l),
                       tile->pixels + y * ncols, ncols*4);
 
            if( tile == &toptile ) {
                fillTile(&toptile,0);
            } else {
                freeTile(tile);
            }
        }
        for( y = 0 ; y < nrows ; y++ )
            callback(spec->dim.width,rows[y]);
    }
    return XCF_OK;
}

References addBackground(), rect::b, tileDimensions::c, Tile::count, FlattenSpec::dim, fillTile(), flattenTopdown(), freeTile(), rect::l, NULLALPHA, FlattenSpec::numLayers, Tile::pixels, rect::r, Tile::refcount, Tile::summary, rect::t, TILE_HEIGHT, TILE_LEFT, TILE_TOP, TILE_WIDTH, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, TILESUMMARY_UPTODATE, tileDimensions::width, XCF_ERROR, XCF_OK, XCF_PTR_EMPTY, and xcfmalloc().

flattenTopdown()

static struct Tile * flattenTopdown ( struct FlattenSpec * spec, struct Tile * top, unsigned nlayers, const struct rect * where )

static

Definition at line 484 of file flatten.c.

{
    struct Tile *tile = 0;
 
    while( nlayers-- ) {
        if( tileSummary(top) & TILESUMMARY_ALLFULL ) {
            if (tile) {
                /* it should always be not null here though */
                freeTile(tile);
            }
            return top ;
        }
        if( !spec->layers[nlayers].isVisible )
            continue ;
 
        freeTile(tile);
        tile = getLayerTile(&spec->layers[nlayers],where);
        if (tile == XCF_PTR_EMPTY) {
            return XCF_PTR_EMPTY;
        }
 
        if( tile->summary & TILESUMMARY_ALLNULL )
            continue ; /* Simulate a tail call */
 
        switch( spec->layers[nlayers].mode ) {
        case GIMP_NORMAL_NOPARTIAL_MODE:
            roundAlpha(tile) ;
            /* Falls through */
        case GIMP_DISSOLVE_MODE:
            dissolveTile(tile);
            /* Falls through */
        case GIMP_NORMAL_MODE:
            top = merge_normal(tile,top);
            break ;
        default:
        {
            struct Tile *below, *above ;
            unsigned i ;
            if( !(top->summary & TILESUMMARY_ALLNULL) ) {
                rgba tile_or = 0 ;
                invalidateSummary(tile,0);
                for( i=0; i<top->count; i++ )
                    if( FULLALPHA(top->pixels[i]) )
                        tile->pixels[i] = 0 ;
                    else
                        tile_or |= tile->pixels[i] ;
                /* If the tile only has pixels that will be covered by 'top' anyway,
                 * forget it anyway.
                 */
                if( ALPHA(tile_or) == 0 ) {
                    freeTile(tile);
                    break ; /* from the switch, which will continue the while */
                }
            }
            /* Create a dummy top for the layers below this */
            if( top->summary & TILESUMMARY_CRISP ) {
                above = forkTile(top);
                if(above == XCF_PTR_EMPTY) {
                    freeTile(tile);
                    return XCF_PTR_EMPTY;
                }
            } else {
                summary_t summary = TILESUMMARY_ALLNULL ;
                above = newTile(*where);
                for( i=0; i<top->count; i++ )
                    if( FULLALPHA(top->pixels[i]) ) {
                        above->pixels[i] = -1 ;
                        summary = 0 ;
                    } else
                        above->pixels[i] = 0 ;
                above->summary = TILESUMMARY_UPTODATE + TILESUMMARY_CRISP + summary;
            }
            below = flattenTopdown(spec, above, nlayers, where);
            if (below == XCF_PTR_EMPTY) {
                freeTile(tile);
                return XCF_PTR_EMPTY;
            }
            if( below->refcount > 1 ) {
                if (below != top) {
                    freeTile(tile);
                    return XCF_PTR_EMPTY;
                }
                /* This can only happen if 'below' is a copy of 'top'
                 * THROUGH 'above', which in turn means that none of all
                 * this is visible after all. So just free it and return 'top'.
                 */
                freeTile(below);
                freeTile(tile);
                return top ;
            }
            if (merge_exotic(below,tile,spec->layers[nlayers].mode) != XCF_OK) {
                return XCF_PTR_EMPTY;
            }
            freeTile(tile);
            top = merge_normal(below,top);
            return top ;
        }
        }
    }
    freeTile(tile);
    return top ;
}

References ALPHA, Tile::count, dissolveTile(), flattenTopdown(), forkTile(), freeTile(), FULLALPHA, getLayerTile(), GIMP_DISSOLVE_MODE, GIMP_NORMAL_MODE, GIMP_NORMAL_NOPARTIAL_MODE, invalidateSummary, xcfLayer::isVisible, FlattenSpec::layers, xcfLayer::mode, newTile(), Tile::pixels, Tile::refcount, roundAlpha(), Tile::summary, tileSummary(), TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, TILESUMMARY_UPTODATE, XCF_OK, and XCF_PTR_EMPTY.

RGBtoHSV()

static void RGBtoHSV ( rgba rgb, struct HSV * hsv )

static

Definition at line 236 of file flatten.c.

{
    unsigned RED = (uint8_t)(rgb >> RED_SHIFT);
    unsigned GREEN = (uint8_t)(rgb >> GREEN_SHIFT);
    unsigned BLUE = (uint8_t)(rgb >> BLUE_SHIFT) ;
#define HEXTANT(b,m,t) hsv->ch1 = b, hsv->ch2 = m, hsv->ch3 = t, \
    hsv->hue = HUE_ ## b ## _ ## m ## _ ## t
    if( GREEN <= RED )
        if( BLUE <= RED )
            if( GREEN <= BLUE )
                HEXTANT(GREEN,BLUE,RED);
            else
                HEXTANT(BLUE,GREEN,RED);
        else
            HEXTANT(GREEN,RED,BLUE);
    else if( BLUE <= RED )
        HEXTANT(BLUE,RED,GREEN);
    else if( BLUE <= GREEN )
        HEXTANT(RED,BLUE,GREEN);
    else
        HEXTANT(RED,GREEN,BLUE);
#undef HEXTANT
}

References BLUE_SHIFT, GREEN_SHIFT, HEXTANT, and RED_SHIFT.

roundAlpha()

static void roundAlpha ( struct Tile * tile )

static

Definition at line 459 of file flatten.c.

{
    unsigned i ;
    summary_t summary ;
    assert( tile->refcount == 1 );
    if( (tile->summary & TILESUMMARY_CRISP) )
        return ;
    summary = TILESUMMARY_UPTODATE + TILESUMMARY_ALLNULL
            + TILESUMMARY_ALLFULL + TILESUMMARY_CRISP ;
    for( i = 0 ; i < tile->count ; i++ ) {
        if( ALPHA(tile->pixels[i]) >= 128 ) {
            tile->pixels[i] |= 255 << ALPHA_SHIFT ;
            summary &= ~TILESUMMARY_ALLNULL ;
        } else {
            tile->pixels[i] = 0 ;
            summary &= ~TILESUMMARY_ALLFULL ;
        }
    }
    tile->summary = summary ;
}

References ALPHA, ALPHA_SHIFT, Tile::count, Tile::pixels, Tile::refcount, Tile::summary, TILESUMMARY_ALLFULL, TILESUMMARY_ALLNULL, TILESUMMARY_CRISP, and TILESUMMARY_UPTODATE.

shipoutWithCallback()

void shipoutWithCallback	(	struct FlattenSpec *	spec,
		rgba **	pixels,
		lineCallback	callback )

Definition at line 728 of file flatten.c.

{
    unsigned i ;
    for( i = 0; i < spec->dim.height; i++ ) {
        callback(spec->dim.width,pixels[i]);
    }
    xcffree(pixels);
}

References FlattenSpec::dim, tileDimensions::height, Tile::pixels, tileDimensions::width, and xcffree().

ucombine_ADDITION()

exotic_combinator ucombine_ADDITION	(	uint8_t	bot,
		uint8_t	top )

Definition at line 127 of file flatten.c.

{
    return bot+top > 255 ? 255 : bot+top ;
}

ucombine_BURN()

exotic_combinator ucombine_BURN	(	uint8_t	bot,
		uint8_t	top )

Definition at line 198 of file flatten.c.

{
    return 255 - ucombine_DIVIDE(255-bot,top);
}

References ucombine_DIVIDE().

ucombine_DARKEN_ONLY()

exotic_combinator ucombine_DARKEN_ONLY	(	uint8_t	bot,
		uint8_t	top )

Definition at line 145 of file flatten.c.

{
    return top < bot ? top : bot ;
}

ucombine_DIFFERENCE()

exotic_combinator ucombine_DIFFERENCE	(	uint8_t	bot,
		uint8_t	top )

Definition at line 151 of file flatten.c.

{
    return top > bot ? top-bot : bot-top ;
}

ucombine_DIVIDE()

exotic_combinator ucombine_DIVIDE	(	uint8_t	bot,
		uint8_t	top )

Definition at line 163 of file flatten.c.

{
    int result = (int)bot*256 / (1+top) ;
    return result >= 256 ? 255 : result ;
}

ucombine_DODGE()

exotic_combinator ucombine_DODGE	(	uint8_t	bot,
		uint8_t	top )

Definition at line 192 of file flatten.c.

{
    return ucombine_DIVIDE(bot,255-top);
}

References ucombine_DIVIDE().

ucombine_GRAIN_EXTRACT()

exotic_combinator ucombine_GRAIN_EXTRACT	(	uint8_t	bot,
		uint8_t	top )

Definition at line 216 of file flatten.c.

{
    int temp = (int)bot - (int)top + 128 ;
    return temp < 0 ? 0 : temp >= 256 ? 255 : temp ;
}

ucombine_GRAIN_MERGE()

exotic_combinator ucombine_GRAIN_MERGE	(	uint8_t	bot,
		uint8_t	top )

Definition at line 223 of file flatten.c.

{
    int temp = (int)bot + (int)top - 128 ;
    return temp < 0 ? 0 : temp >= 256 ? 255 : temp ;
}

ucombine_HARDLIGHT()

exotic_combinator ucombine_HARDLIGHT	(	uint8_t	bot,
		uint8_t	top )

Definition at line 204 of file flatten.c.

{
    if( top >= 128 )
        return 255 ^ scaletable[255-bot][2*(255-top)] ;
    else
        return scaletable[bot][2*top];
    /* The code that implements "hardlight" in Gimp 2.2.10 has some
     * rounding errors, but this is undoubtedly what is meant.
     */
}

References scaletable.

ucombine_LIGHTEN_ONLY()

exotic_combinator ucombine_LIGHTEN_ONLY	(	uint8_t	bot,
		uint8_t	top )

Definition at line 139 of file flatten.c.

{
    return top > bot ? top : bot ;
}

ucombine_MULTIPLY()

exotic_combinator ucombine_MULTIPLY	(	uint8_t	bot,
		uint8_t	top )

Definition at line 157 of file flatten.c.

{
    return scaletable[bot][top] ;
}

References scaletable.

ucombine_OVERLAY()

exotic_combinator ucombine_OVERLAY	(	uint8_t	bot,
		uint8_t	top )

Definition at line 177 of file flatten.c.

{
    return scaletable[bot][bot] +
            2*scaletable[top][scaletable[bot][255-bot]] ;
    /* This strange formula is equivalent to
     *   (1-top)*(bot^2) + top*(1-(1-top)^2)
     * that is, the top value is used to interpolate between
     * the self-multiply and the self-screen of the bottom.
     */
    /* Note: This is exactly what the "Soft light" effect also
     * does, though with different code in the Gimp.
     */
}

References scaletable.

ucombine_SCREEN()

exotic_combinator ucombine_SCREEN	(	uint8_t	bot,
		uint8_t	top )

Definition at line 170 of file flatten.c.

{
    /* An inverted version of "multiply" */
    return 255 ^ scaletable[255-bot][255-top] ;
}

References scaletable.

ucombine_SUBTRACT()

exotic_combinator ucombine_SUBTRACT	(	uint8_t	bot,
		uint8_t	top )

Definition at line 133 of file flatten.c.

{
    return top>bot ? 0 : bot-top ;
}

Variable Documentation

collectPointer

rgba** collectPointer

static

Definition at line 701 of file flatten.c.