Pillow

1
/*
2
 * The Python Imaging Library
3
 * $Id$
4
 *
5
 * Alpha composite imSrc over imDst.
6
 * https://en.wikipedia.org/wiki/Alpha_compositing
7
 *
8
 * See the README file for details on usage and redistribution.
9
 */
10

11
#include "Imaging.h"
12

13
#define PRECISION_BITS 7
14

15
typedef struct {
16
    UINT8 r;
17
    UINT8 g;
18
    UINT8 b;
19
    UINT8 a;
20
} rgba8;
21

22
Imaging
23
ImagingAlphaComposite(Imaging imDst, Imaging imSrc) {
24
    Imaging imOut;
25
    int x, y;
26

27
    /* Check arguments */
28
    if (!imDst || !imSrc || strcmp(imDst->mode, "RGBA") ||
29
        imDst->type != IMAGING_TYPE_UINT8 || imDst->bands != 4) {
30
        return ImagingError_ModeError();
31
    }
32

33
    if (strcmp(imDst->mode, imSrc->mode) || imDst->type != imSrc->type ||
34
        imDst->bands != imSrc->bands || imDst->xsize != imSrc->xsize ||
35
        imDst->ysize != imSrc->ysize) {
36
        return ImagingError_Mismatch();
37
    }
38

39
    imOut = ImagingNewDirty(imDst->mode, imDst->xsize, imDst->ysize);
40
    if (!imOut) {
41
        return NULL;
42
    }
43

44
    for (y = 0; y < imDst->ysize; y++) {
45
        rgba8 *dst = (rgba8 *)imDst->image[y];
46
        rgba8 *src = (rgba8 *)imSrc->image[y];
47
        rgba8 *out = (rgba8 *)imOut->image[y];
48

49
        for (x = 0; x < imDst->xsize; x++) {
50
            if (src->a == 0) {
51
                // Copy 4 bytes at once.
52
                *out = *dst;
53
            } else {
54
                // Integer implementation with increased precision.
55
                // Each variable has extra meaningful bits.
56
                // Divisions are rounded.
57

58
                UINT32 tmpr, tmpg, tmpb;
59
                UINT32 blend = dst->a * (255 - src->a);
60
                UINT32 outa255 = src->a * 255 + blend;
61
                // There we use 7 bits for precision.
62
                // We could use more, but we go beyond 32 bits.
63
                UINT32 coef1 = src->a * 255 * 255 * (1 << PRECISION_BITS) / outa255;
64
                UINT32 coef2 = 255 * (1 << PRECISION_BITS) - coef1;
65

66
                tmpr = src->r * coef1 + dst->r * coef2;
67
                tmpg = src->g * coef1 + dst->g * coef2;
68
                tmpb = src->b * coef1 + dst->b * coef2;
69
                out->r =
70
                    SHIFTFORDIV255(tmpr + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
71
                out->g =
72
                    SHIFTFORDIV255(tmpg + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
73
                out->b =
74
                    SHIFTFORDIV255(tmpb + (0x80 << PRECISION_BITS)) >> PRECISION_BITS;
75
                out->a = SHIFTFORDIV255(outa255 + 0x80);
76
            }
77

78
            dst++;
79
            src++;
80
            out++;
81
        }
82
    }
83

84
    return imOut;
85
}
86