alphablender.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

                g9 = (green + g9 * ia) >> SCALE_SH;
                b9 = (blue + b9 * ia) >> SCALE_SH;
            }

            red = redMap[pixel10];
            green = greenMap[pixel10];
            blue = blueMap[pixel10];
            ia = inverseAlphaMap[pixel10];
            if (ia == 0) {
                r10 = red >> SCALE_SH;
                g10 = green >> SCALE_SH;
                b10 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r10 = (red + r10 * ia) >> SCALE_SH;
                g10 = (green + g10 * ia) >> SCALE_SH;
                b10 = (blue + b10 * ia) >> SCALE_SH;
            }

            red = redMap[pixel11];
            green = greenMap[pixel11];
            blue = blueMap[pixel11];
            ia = inverseAlphaMap[pixel11];
            if (ia == 0) {
                r11 = red >> SCALE_SH;
                g11 = green >> SCALE_SH;
                b11 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r11 = (red + r11 * ia) >> SCALE_SH;
                g11 = (green + g11 * ia) >> SCALE_SH;
                b11 = (blue + b11 * ia) >> SCALE_SH;
            }

            red = redMap[pixel12];
            green = greenMap[pixel12];
            blue = blueMap[pixel12];
            ia = inverseAlphaMap[pixel12];
            if (ia == 0) {
                r12 = red >> SCALE_SH;
                g12 = green >> SCALE_SH;
                b12 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r12 = (red + r12 * ia) >> SCALE_SH;
                g12 = (green + g12 * ia) >> SCALE_SH;
                b12 = (blue + b12 * ia) >> SCALE_SH;
            }

            red = redMap[pixel13];
            green = greenMap[pixel13];
            blue = blueMap[pixel13];
            ia = inverseAlphaMap[pixel13];
            if (ia == 0) {
                r13 = red >> SCALE_SH;
                g13 = green >> SCALE_SH;
                b13 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r13 = (red + r13 * ia) >> SCALE_SH;
                g13 = (green + g13 * ia) >> SCALE_SH;
                b13 = (blue + b13 * ia) >> SCALE_SH;
            }

            red = redMap[pixel14];
            green = greenMap[pixel14];
            blue = blueMap[pixel14];
            ia = inverseAlphaMap[pixel14];
            if (ia == 0) {
                r14 = red >> SCALE_SH;
                g14 = green >> SCALE_SH;
                b14 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r14 = (red + r14 * ia) >> SCALE_SH;
                g14 = (green + g14 * ia) >> SCALE_SH;
                b14 = (blue + b14 * ia) >> SCALE_SH;
            }

            red = redMap[pixel15];
            green = greenMap[pixel15];
            blue = blueMap[pixel15];
            ia = inverseAlphaMap[pixel15];
            if (ia == 0) {
                r15 = red >> SCALE_SH;
                g15 = green >> SCALE_SH;
                b15 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r15 = (red + r15 * ia) >> SCALE_SH;
                g15 = (green + g15 * ia) >> SCALE_SH;
                b15 = (blue + b15 * ia) >> SCALE_SH;
            }

            red = redMap[pixel16];
            green = greenMap[pixel16];
            blue = blueMap[pixel16];
            ia = inverseAlphaMap[pixel16];
            if (ia == 0) {
                r16 = red >> SCALE_SH;
                g16 = green >> SCALE_SH;
                b16 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r16 = (red + r16 * ia) >> SCALE_SH;
                g16 = (green + g16 * ia) >> SCALE_SH;
                b16 = (blue + b16 * ia) >> SCALE_SH;
            }

            red = redMap[pixel17];
            green = greenMap[pixel17];
            blue = blueMap[pixel17];
            ia = inverseAlphaMap[pixel17];
            if (ia == 0) {
                r17 = red >> SCALE_SH;
                g17 = green >> SCALE_SH;
                b17 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r17 = (red + r17 * ia) >> SCALE_SH;
                g17 = (green + g17 * ia) >> SCALE_SH;
                b17 = (blue + b17 * ia) >> SCALE_SH;
            }

            red = redMap[pixel18];
            green = greenMap[pixel18];
            blue = blueMap[pixel18];
            ia = inverseAlphaMap[pixel18];
            if (ia == 0) {
                r18 = red >> SCALE_SH;
                g18 = green >> SCALE_SH;
                b18 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r18 = (red + r18 * ia) >> SCALE_SH;
                g18 = (green + g18 * ia) >> SCALE_SH;
                b18 = (blue + b18 * ia) >> SCALE_SH;
            }

            red = redMap[pixel19];
            green = greenMap[pixel19];
            blue = blueMap[pixel19];
            ia = inverseAlphaMap[pixel19];
            if (ia == 0) {
                r19 = red >> SCALE_SH;
                g19 = green >> SCALE_SH;
                b19 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r19 = (red + r19 * ia) >> SCALE_SH;
                g19 = (green + g19 * ia) >> SCALE_SH;
                b19 = (blue + b19 * ia) >> SCALE_SH;
            }

            red = redMap[pixel20];
            green = greenMap[pixel20];
            blue = blueMap[pixel20];
            ia = inverseAlphaMap[pixel20];
            if (ia == 0) {
                r20 = red >> SCALE_SH;
                g20 = green >> SCALE_SH;
                b20 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r20 = (red + r20 * ia) >> SCALE_SH;
                g20 = (green + g20 * ia) >> SCALE_SH;
                b20 = (blue + b20 * ia) >> SCALE_SH;
            }

            red = redMap[pixel21];
            green = greenMap[pixel21];
            blue = blueMap[pixel21];
            ia = inverseAlphaMap[pixel21];
            if (ia == 0) {
                r21 = red >> SCALE_SH;
                g21 = green >> SCALE_SH;
                b21 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r21 = (red + r21 * ia) >> SCALE_SH;
                g21 = (green + g21 * ia) >> SCALE_SH;
                b21 = (blue + b21 * ia) >> SCALE_SH;
            }

            red = redMap[pixel22];
            green = greenMap[pixel22];
            blue = blueMap[pixel22];
            ia = inverseAlphaMap[pixel22];
            if (ia == 0) {
                r22 = red >> SCALE_SH;
                g22 = green >> SCALE_SH;
                b22 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r22 = (red + r22 * ia) >> SCALE_SH;
                g22 = (green + g22 * ia) >> SCALE_SH;
                b22 = (blue + b22 * ia) >> SCALE_SH;
            }

            red = redMap[pixel23];
            green = greenMap[pixel23];
            blue = blueMap[pixel23];
            ia = inverseAlphaMap[pixel23];
            if (ia == 0) {
                r23 = red >> SCALE_SH;
                g23 = green >> SCALE_SH;
                b23 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r23 = (red + r23 * ia) >> SCALE_SH;
                g23 = (green + g23 * ia) >> SCALE_SH;
                b23 = (blue + b23 * ia) >> SCALE_SH;
            }

            red = redMap[pixel24];
            green = greenMap[pixel24];
            blue = blueMap[pixel24];
            ia = inverseAlphaMap[pixel24];
            if (ia == 0) {
                r24 = red >> SCALE_SH;
                g24 = green >> SCALE_SH;
                b24 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r24 = (red + r24 * ia) >> SCALE_SH;
                g24 = (green + g24 * ia) >> SCALE_SH;
                b24 = (blue + b24 * ia) >> SCALE_SH;
            }

            red = redMap[pixel25];
            green = greenMap[pixel25];
            blue = blueMap[pixel25];
            ia = inverseAlphaMap[pixel25];
            if (ia == 0) {
                r25 = red >> SCALE_SH;
                g25 = green >> SCALE_SH;
                b25 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r25 = (red + r25 * ia) >> SCALE_SH;
                g25 = (green + g25 * ia) >> SCALE_SH;
                b25 = (blue + b25 * ia) >> SCALE_SH;
            }

            red = redMap[pixel26];
            green = greenMap[pixel26];
            blue = blueMap[pixel26];
            ia = inverseAlphaMap[pixel26];
            if (ia == 0) {
                r26 = red >> SCALE_SH;
                g26 = green >> SCALE_SH;
                b26 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r26 = (red + r26 * ia) >> SCALE_SH;
                g26 = (green + g26 * ia) >> SCALE_SH;
                b26 = (blue + b26 * ia) >> SCALE_SH;
            }

            red = redMap[pixel27];
            green = greenMap[pixel27];
            blue = blueMap[pixel27];
            ia = inverseAlphaMap[pixel27];
            if (ia == 0) {
                r27 = red >> SCALE_SH;
                g27 = green >> SCALE_SH;
                b27 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r27 = (red + r27 * ia) >> SCALE_SH;
                g27 = (green + g27 * ia) >> SCALE_SH;
                b27 = (blue + b27 * ia) >> SCALE_SH;
            }

            red = redMap[pixel28];
            green = greenMap[pixel28];
            blue = blueMap[pixel28];
            ia = inverseAlphaMap[pixel28];
            if (ia == 0) {
                r28 = red >> SCALE_SH;
                g28 = green >> SCALE_SH;
                b28 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r28 = (red + r28 * ia) >> SCALE_SH;
                g28 = (green + g28 * ia) >> SCALE_SH;
                b28 = (blue + b28 * ia) >> SCALE_SH;
            }

            red = redMap[pixel29];
            green = greenMap[pixel29];
            blue = blueMap[pixel29];
            ia = inverseAlphaMap[pixel29];
            if (ia == 0) {
                r29 = red >> SCALE_SH;
                g29 = green >> SCALE_SH;
                b29 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r29 = (red + r29 * ia) >> SCALE_SH;
                g29 = (green + g29 * ia) >> SCALE_SH;
                b29 = (blue + b29 * ia) >> SCALE_SH;
            }

            red = redMap[pixel30];
            green = greenMap[pixel30];
            blue = blueMap[pixel30];
            ia = inverseAlphaMap[pixel30];
            if (ia == 0) {
                r30 = red >> SCALE_SH;
                g30 = green >> SCALE_SH;
                b30 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r30 = (red + r30 * ia) >> SCALE_SH;
                g30 = (green + g30 * ia) >> SCALE_SH;
                b30 = (blue + b30 * ia) >> SCALE_SH;
            }

            red = redMap[pixel31];
            green = greenMap[pixel31];
            blue = blueMap[pixel31];
            ia = inverseAlphaMap[pixel31];
            if (ia == 0) {
                r31 = red >> SCALE_SH;
                g31 = green >> SCALE_SH;
                b31 = blue >> SCALE_SH;
            } else if (ia != SCALE) {
                r31 = (red + r31 * ia) >> SCALE_SH;
                g31 = (green + g31 * ia) >> SCALE_SH;
                b31 = (blue + b31 * ia) >> SCALE_SH;
            }
        }
    }
}