native/libsplashscreen/splashscreen_gfx_impl.c

/*
 * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "splashscreen_gfx_impl.h"

/* *INDENT-OFF* */
const byte_t baseDitherMatrix[DITHER_SIZE][DITHER_SIZE] = {
  /* Bayer's order-4 dither array.  Generated by the code given in
   * Stephen Hawley's article "Ordered Dithering" in Graphics Gems I.
   */
  {   0,192, 48,240, 12,204, 60,252,  3,195, 51,243, 15,207, 63,255 },
  { 128, 64,176,112,140, 76,188,124,131, 67,179,115,143, 79,191,127 },
  {  32,224, 16,208, 44,236, 28,220, 35,227, 19,211, 47,239, 31,223 },
  { 160, 96,144, 80,172,108,156, 92,163, 99,147, 83,175,111,159, 95 },
  {   8,200, 56,248,  4,196, 52,244, 11,203, 59,251,  7,199, 55,247 },
  { 136, 72,184,120,132, 68,180,116,139, 75,187,123,135, 71,183,119 },
  {  40,232, 24,216, 36,228, 20,212, 43,235, 27,219, 39,231, 23,215 },
  { 168,104,152, 88,164,100,148, 84,171,107,155, 91,167,103,151, 87 },
  {   2,194, 50,242, 14,206, 62,254,  1,193, 49,241, 13,205, 61,253 },
  { 130, 66,178,114,142, 78,190,126,129, 65,177,113,141, 77,189,125 },
  {  34,226, 18,210, 46,238, 30,222, 33,225, 17,209, 45,237, 29,221 },
  { 162, 98,146, 82,174,110,158, 94,161, 97,145, 81,173,109,157, 93 },
  {  10,202, 58,250,  6,198, 54,246,  9,201, 57,249,  5,197, 53,245 },
  { 138, 74,186,122,134, 70,182,118,137, 73,185,121,133, 69,181,117 },
  {  42,234, 26,218, 38,230, 22,214, 41,233, 25,217, 37,229, 21,213 },
  { 170,106,154, 90,166,102,150, 86,169,105,153, 89,165,101,149, 85 }
};
/* *INDENT-ON* */

// FIXME: tinting on some colormaps (e.g. 1-2-1) means something is slightly wrong with
// colormap calculation... probably it's some rounding error

/*  calculates the colorTable for mapping from 0..255 to 0..numColors-1
    also calculates the dithering matrix, scaling baseDitherMatrix accordingly */
void
initDither(DitherSettings * pDither, int numColors, int scale)
{
    int i, j;

    pDither->numColors = numColors;
    for (i = 0; i < (MAX_COLOR_VALUE + 1) * 2; i++) {
        pDither->colorTable[i] =
            (((i > MAX_COLOR_VALUE) ? MAX_COLOR_VALUE : i) *
             (numColors - 1) / MAX_COLOR_VALUE) * scale;
    }
    for (i = 0; i < DITHER_SIZE; i++)
        for (j = 0; j < DITHER_SIZE; j++)
            pDither->matrix[i][j] =
                (int) baseDitherMatrix[i][j] / (numColors - 1);
}

/* scale a number on the range of 0..numColorsIn-1 to 0..numColorsOut-1
 0 maps to 0 and numColorsIn-1 maps to numColorsOut-1
 intermediate values are spread evenly between 0 and numColorsOut-1 */
INLINE int
scaleColor(int color, int numColorsIn, int numColorsOut)
{
    return (color * (numColorsOut - 1) + (numColorsIn - 1) / 2)
        / (numColorsIn - 1);
}

/*  build a colormap for a color cube and a dithering matrix. color cube is quantized
    according to the provided maximum number of colors */
int
quantizeColors(int maxNumColors, int *numColors)
{

    // static const int scale[3]={10000/11,10000/69,10000/30};
    // FIXME: sort out the adaptive color cube subdivision... realistic 11:69:30 is good on photos,
    // but would be bad on other pictures. A stupid approximation is used now.

    static const int scale[3] = { 8, 4, 6 };

    // maxNumColors should be at least 2x2x2=8, or we lose some color components completely
    numColors[0] = numColors[1] = numColors[2] = 2;

    while (1) {
        int idx[3] = { 0, 1, 2 };
        /* bubble sort the three indexes according to scaled numColors values */
#define SORT(i,j) \
        if (numColors[idx[i]]*scale[idx[i]]>numColors[idx[j]]*scale[idx[j]]) \
            { int t = idx[i]; idx[i] = idx[j]; idx[j] = t; }
        SORT(0, 1);
        SORT(1, 2);
        SORT(0, 1);
        /* try increasing numColors for the first color */
        if ((numColors[idx[0]] + 1) * numColors[idx[1]] *
            numColors[idx[2]] <= maxNumColors) {
                numColors[idx[0]]++;
        } else if (numColors[idx[0]] * (numColors[idx[1]] + 1) *
            numColors[idx[2]] <= maxNumColors) {
            numColors[idx[1]]++;
        } else if (numColors[idx[0]] * numColors[idx[1]] *
            (numColors[idx[2]] + 1) <= maxNumColors) {
            numColors[idx[2]]++;
        } else {
            break;
        }
    }
    return numColors[0] * numColors[1] * numColors[2];
}

void
initColorCube(int *numColors, rgbquad_t * pColorMap, DitherSettings * pDithers,
              rgbquad_t * colorIndex)
{
    int r, g, b, n;

    n = 0;
    for (r = 0; r < numColors[2]; r++) {
        for (g = 0; g < numColors[1]; g++)
            for (b = 0; b < numColors[0]; b++) {
                pColorMap[colorIndex[n++]] =
                    scaleColor(b, numColors[0], MAX_COLOR_VALUE) +
                    (scaleColor(g, numColors[1], MAX_COLOR_VALUE) << 8) +
                    (scaleColor(r, numColors[2], MAX_COLOR_VALUE) << 16);
            }
    }
    initDither(pDithers + 0, numColors[0], 1);
    initDither(pDithers + 1, numColors[1], numColors[0]);
    initDither(pDithers + 2, numColors[2], numColors[1] * numColors[0]);
}

/*
    the function below is a line conversion loop

    incSrc and incDst are pSrc and pDst increment values for the loop, in bytes
    mode defines how the pixels should be processed

    mode==CVT_COPY means the pixels should be copied as is
    mode==CVT_ALPHATEST means pixels should be skipped when source pixel alpha is above the threshold
    mode==CVT_BLEND means alpha blending between source and destination should be performed, while
    destination alpha should be retained. source alpha is used for blending.
*/
void
convertLine(void *pSrc, int incSrc, void *pDst, int incDst, int numSamples,
            ImageFormat * srcFormat, ImageFormat * dstFormat, int doAlpha,
            void *pSrc2, int incSrc2, ImageFormat * srcFormat2,
            int row, int col)
{
    int i;

    switch (doAlpha) {
    case CVT_COPY:
        for (i = 0; i < numSamples; ++i) {
            putRGBADither(getRGBA(pSrc, srcFormat), pDst, dstFormat,
                row, col++);
            INCPN(byte_t, pSrc, incSrc);
            INCPN(byte_t, pDst, incDst);
        }
        break;
    case CVT_ALPHATEST:
        for (i = 0; i < numSamples; ++i) {
            rgbquad_t color = getRGBA(pSrc, srcFormat);

            if (color >= ALPHA_THRESHOLD) {     // test for alpha component >50%. that's an extra branch, and it's bad...
                putRGBADither(color, pDst, dstFormat, row, col++);
            }
            INCPN(byte_t, pSrc, incSrc);
            INCPN(byte_t, pDst, incDst);
        }
        break;
    case CVT_BLEND:
        for (i = 0; i < numSamples; ++i) {
            rgbquad_t src = getRGBA(pSrc, srcFormat);
            rgbquad_t src2 = getRGBA(pSrc2, srcFormat);

            putRGBADither(blendRGB(src, src2,
                QUAD_ALPHA(src2)) | (src & QUAD_ALPHA_MASK), pDst, dstFormat,
                row, col++);
            INCPN(byte_t, pSrc, incSrc);
            INCPN(byte_t, pDst, incDst);
            INCPN(byte_t, pSrc2, incSrc2);
        }
        break;
    }
}

/* initialize ImageRect structure according to function arguments */
void
initRect(ImageRect * pRect, int x, int y, int width, int height, int jump,
         int stride, void *pBits, ImageFormat * format)
{
    int depthBytes = format->depthBytes;

    pRect->pBits = pBits;
    INCPN(byte_t, pRect->pBits, y * stride + x * depthBytes);
    pRect->numLines = height;
    pRect->numSamples = width;
    pRect->stride = stride * jump;
    pRect->depthBytes = depthBytes;
    pRect->format = format;
    pRect->row = y;
    pRect->col = x;
    pRect->jump = jump;
}

/*  copy image rectangle from source to destination, or from two sources with blending */

int
convertRect(ImageRect * pSrcRect, ImageRect * pDstRect, int mode)
{
    return convertRect2(pSrcRect, pDstRect, mode, NULL);
}

int
convertRect2(ImageRect * pSrcRect, ImageRect * pDstRect, int mode,
             ImageRect * pSrcRect2)
{
    int numLines = pSrcRect->numLines;
    int numSamples = pSrcRect->numSamples;
    void *pSrc = pSrcRect->pBits;
    void *pDst = pDstRect->pBits;
    void *pSrc2 = NULL;
    int j, row;

    if (pDstRect->numLines < numLines)
        numLines = pDstRect->numLines;
    if (pDstRect->numSamples < numSamples) {
        numSamples = pDstRect->numSamples;
    }
    if (pSrcRect2) {
        if (pSrcRect2->numLines < numLines) {
            numLines = pSrcRect2->numLines;
        }
        if (pSrcRect2->numSamples < numSamples) {
            numSamples = pSrcRect2->numSamples;
        }
        pSrc2 = pSrcRect2->pBits;
    }
    row = pDstRect->row;
    for (j = 0; j < numLines; j++) {
        convertLine(pSrc, pSrcRect->depthBytes, pDst, pDstRect->depthBytes,
            numSamples, pSrcRect->format, pDstRect->format, mode,
            pSrc2, pSrcRect2 ? pSrcRect2->depthBytes : 0,
            pSrcRect2 ? pSrcRect2->format : 0, row, pDstRect->col);
        INCPN(byte_t, pSrc, pSrcRect->stride);
        INCPN(byte_t, pDst, pDstRect->stride);
        if (pSrcRect2) {
            INCPN(byte_t, pSrc2, pSrcRect2->stride);
        }
        row += pDstRect->jump;
    }
    return numLines * pSrcRect->stride;
}

int
fillRect(rgbquad_t color, ImageRect * pDstRect)
{
    int numLines = pDstRect->numLines;
    int numSamples = pDstRect->numSamples;
    void *pDst = pDstRect->pBits;
    int j, row;

    row = pDstRect->row;
    for (j = 0; j < numLines; j++) {
        fillLine(color, pDst, pDstRect->depthBytes, numSamples,
            pDstRect->format, row, pDstRect->col);
        INCPN(byte_t, pDst, pDstRect->stride);
        row += pDstRect->jump;
    }
    return numLines * pDstRect->stride;
}

/* init the masks; all other parameters are initialized to default values */
void
initFormat(ImageFormat * format, int redMask, int greenMask, int blueMask,
           int alphaMask)
{
    int i, shift, numBits;

    format->byteOrder = BYTE_ORDER_NATIVE;
    format->colorMap = NULL;
    format->depthBytes = 4;
    format->fixedBits = 0;
    format->premultiplied = 0;
    format->mask[0] = blueMask;
    format->mask[1] = greenMask;
    format->mask[2] = redMask;
    format->mask[3] = alphaMask;
    for (i = 0; i < 4; i++) {
        getMaskShift(format->mask[i], &shift, &numBits);
        format->shift[i] = shift + numBits - i * 8 - 8;
    }
}

/* dump the visual format */
void
dumpFormat(ImageFormat * format)
{
#ifdef _DEBUG
    int i;

    printf("byteorder=%d colormap=%08x depthBytes=%d fixedBits=%08x transparentColor=%u ",
        format->byteOrder, (unsigned) format->colorMap, format->depthBytes,
        (unsigned) format->fixedBits, (unsigned) format->transparentColor);
    for (i = 0; i < 4; i++) {
        printf("mask[%d]=%08x shift[%d]=%d\n", i, (unsigned) format->mask[i], i,
            format->shift[i]);
    }
    printf("\n");
#endif
}

/* optimize the format */
void
optimizeFormat(ImageFormat * format)
{
    if (platformByteOrder() == format->byteOrder && format->depthBytes != 3) {
        format->byteOrder = BYTE_ORDER_NATIVE;
    }
    /* FIXME: some advanced optimizations are possible, especially for format pairs */
}

int
platformByteOrder()
{
    int test = 1;

    *(char *) &test = 0;
    return test ? BYTE_ORDER_MSBFIRST : BYTE_ORDER_LSBFIRST;
}