/*

 * Copyright (c) 1995, 2014, 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.

 */

/*

 *      Image dithering and rendering code for X11.

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include <sys/time.h>

#include <sys/resource.h>

#ifndef HEADLESS

#include <X11/Xlib.h>

#include <X11/Xatom.h>

#include <X11/Xutil.h>

#endif /* !HEADLESS */

#include "awt_p.h"

#include "java_awt_Color.h"

#include "java_awt_SystemColor.h"

#include "java_awt_color_ColorSpace.h"

#include "java_awt_Transparency.h"

#include "java_awt_image_DataBuffer.h"

#include "img_colors.h"

#include "imageInitIDs.h"

#include "dither.h"

#include <jni.h>

#include <jni_util.h>

#ifdef DEBUG

static int debug_colormap = 0;

#endif

#define MAX_PALETTE8_SIZE (256)

#define MAX_PALETTE12_SIZE (4096)

#define MAX_PALETTE_SIZE MAX_PALETTE12_SIZE

/* returns the absolute value x */

#define ABS(x) ((x) < 0 ? -(x) : (x))

#define CLIP(val,min,max)       ((val < min) ? min : ((val > max) ? max : val))

#define RGBTOGRAY(r, g, b) ((int) (.299 * r + .587 * g + .114 * b + 0.5))

enum {

    FREE_COLOR          = 0,

    LIKELY_COLOR        = 1,

    UNAVAILABLE_COLOR   = 2,

    ALLOCATED_COLOR     = 3

};

/*

 * Constants to control the filling of the colormap.

 * By default, try to allocate colors in the default colormap until

 * CMAP_ALLOC_DEFAULT colors are being used (by Java and/or other

 * applications).

 * For cases where the default colormap may already have a large

 * number of colors in it, make sure that we ourselves try to add

 * at least CMAP_ALLOC_MIN new colors, even if we need to allocate

 * more than the DEFAULT to do that.

 * Under no circumstances will the colormap be filled to more than

 * CMAP_ALLOC_MAX colors.

 */

#define CMAP_ALLOC_MIN          100     /* minimum number of colors to "add" */

#define CMAP_ALLOC_DEFAULT      200     /* default number of colors in cmap */

#define CMAP_ALLOC_MAX          245     /* maximum number of colors in cmap */

#ifdef __solaris__

#include <sys/utsname.h>

struct {

    char *machine;

    int  cubesize;

} machinemap[] = {

    { "i86pc", LOOKUPSIZE / 4 }, /* BugTraq ID 4102599 */

    { "sun4c", LOOKUPSIZE / 4 },

    { "sun4m", LOOKUPSIZE / 2 },

    { "sun4d", LOOKUPSIZE / 2 },

    { "sun4u", LOOKUPSIZE / 1 },

};

#define MACHMAPSIZE     (sizeof(machinemap) / sizeof(machinemap[0]))

    struct utsname name;

    int i, ret;

    ret = uname(&name);

    if (ret < 0) {

#ifdef DEBUG

#include <errno.h>

        jio_fprintf(stderr, "uname errno = %d, using default cubesize %d\n",

                    errno, LOOKUPSIZE);

#endif

        return LOOKUPSIZE;

    }

    for (i = 0; i < MACHMAPSIZE; i++) {

        if (strcmp(name.machine, machinemap[i].machine) == 0) {

#ifdef DEBUG

            if (debug_colormap) {

                jio_fprintf(stderr, "'%s'.cubesize = '%d'\n",

                            machinemap[i].machine, machinemap[i].cubesize);

            }

#endif

            return machinemap[i].cubesize;

        }

    }

#ifdef DEBUG

    if (debug_colormap) {

        jio_fprintf(stderr, "unknown machine '%s' using cubesize %d\n",

                    name.machine, LOOKUPSIZE);

    }

#endif

    return LOOKUPSIZE;

}

#else /* __solaris__ */

#define getVirtCubeSize()       (LOOKUPSIZE)

#endif /* __solaris__ */

unsigned char img_bwgamma[256];

uns_ordered_dither_array img_oda_alpha;

#ifdef NEED_IMAGE_CONVERT

ImgConvertFcn DirectImageConvert;

ImgConvertFcn Dir16IcmOpqUnsImageConvert;

ImgConvertFcn Dir16IcmTrnUnsImageConvert;

ImgConvertFcn Dir16IcmOpqSclImageConvert;

ImgConvertFcn Dir16DcmOpqUnsImageConvert;

ImgConvertFcn Dir16DcmTrnUnsImageConvert;

ImgConvertFcn Dir16DcmOpqSclImageConvert;

ImgConvertFcn Dir32IcmOpqUnsImageConvert;

ImgConvertFcn Dir32IcmTrnUnsImageConvert;

ImgConvertFcn Dir32IcmOpqSclImageConvert;

ImgConvertFcn Dir32DcmOpqUnsImageConvert;

ImgConvertFcn Dir32DcmTrnUnsImageConvert;

ImgConvertFcn Dir32DcmOpqSclImageConvert;

ImgConvertFcn PseudoImageConvert;

ImgConvertFcn PseudoFSImageConvert;

ImgConvertFcn FSColorIcmOpqUnsImageConvert;

ImgConvertFcn FSColorDcmOpqUnsImageConvert;

ImgConvertFcn OrdColorIcmOpqUnsImageConvert;

ImgConvertFcn OrdColorDcmOpqUnsImageConvert;

#endif /* NEED_IMAGE_CONVERT */

#ifndef HEADLESS

/*

 * Find the best color.

 */

int

awt_color_matchTC(int r, int g, int b, AwtGraphicsConfigDataPtr awt_data)

{

    r = CLIP(r, 0, 255);

    g = CLIP(g, 0, 255);

    b = CLIP(b, 0, 255);

    return (((r >> awt_data->awtImage->clrdata.rScale)

                << awt_data->awtImage->clrdata.rOff) |

            ((g >> awt_data->awtImage->clrdata.gScale)

                << awt_data->awtImage->clrdata.gOff) |

            ((b >> awt_data->awtImage->clrdata.bScale)

                << awt_data->awtImage->clrdata.bOff));

}

int

awt_color_matchGS(int r, int g, int b, AwtGraphicsConfigDataPtr awt_data)

{

    r = CLIP(r, 0, 255);

    g = CLIP(g, 0, 255);

    b = CLIP(b, 0, 255);

    return awt_data->color_data->img_grays[RGBTOGRAY(r, g, b)];

}

int

awt_color_match(int r, int g, int b, AwtGraphicsConfigDataPtr awt_data)

{

    int besti = 0;

    int mindist, i, t, d;

    ColorEntry *p = awt_data->color_data->awt_Colors;

    r = CLIP(r, 0, 255);

    g = CLIP(g, 0, 255);

    b = CLIP(b, 0, 255);

    /* look for pure gray match */

    if ((r == g) && (g == b)) {

      mindist = 256;

      for (i = 0 ; i < awt_data->awt_num_colors ; i++, p++)

        if (p->flags == ALLOCATED_COLOR) {

          if (! ((p->r == p->g) && (p->g == p->b)) )

              continue;

          d = ABS(p->r - r);

          if (d == 0)

              return i;

          if (d < mindist) {

              besti = i;

              mindist = d;

          }

        }

      return besti;

    }

    /* look for non-pure gray match */

    mindist = 256 * 256 * 256;

    for (i = 0 ; i < awt_data->awt_num_colors ; i++, p++)

        if (p->flags == ALLOCATED_COLOR) {

            t = p->r - r;

            d = t * t;

            if (d >= mindist)

                continue;

            t = p->g - g;

            d += t * t;

            if (d >= mindist)

                continue;

            t = p->b - b;

            d += t * t;

            if (d >= mindist)

                continue;

            if (d == 0)

                return i;

            if (d < mindist) {

                besti = i;

                mindist = d;

            }

        }

    return besti;

}

/*

 * Allocate a color in the X color map and return the pixel.

 * If the "expected pixel" is non-negative then we will only

 * accept the allocation if we get exactly that pixel value.

 * This prevents us from seeing a bunch of ReadWrite pixels

 * allocated by another imaging application and duplicating

 * that set of inaccessible pixels in our precious remaining

 * ReadOnly colormap cells.

 */

static int

alloc_col(Display *dpy, Colormap cm, int r, int g, int b, int pixel,

          AwtGraphicsConfigDataPtr awt_data)

{

    XColor col;

    r = CLIP(r, 0, 255);

    g = CLIP(g, 0, 255);

    b = CLIP(b, 0, 255);

    col.flags = DoRed | DoGreen | DoBlue;

    col.red   = (r << 8) | r;

    col.green = (g << 8) | g;

    col.blue  = (b << 8) | b;

    if (XAllocColor(dpy, cm, &col)) {

#ifdef DEBUG

        if (debug_colormap)

            jio_fprintf(stdout, "allocated %d (%d,%d, %d)\n", col.pixel, r, g, b);

#endif

        if (pixel >= 0 && col.pixel != (unsigned long)pixel) {

            /*

             * If we were trying to allocate a shareable "ReadOnly"

             * color then we would have gotten back the expected

             * pixel.  If the returned pixel was different, then

             * the source color that we were attempting to gain

             * access to must be some other application's ReadWrite

             * private color.  We free the returned pixel so that

             * we won't waste precious colormap entries by duplicating

             * that color in the as yet unallocated entries.  We

             * return -1 here to indicate the failure to get the

             * expected pixel.

             */

#ifdef DEBUG

            if (debug_colormap)

                jio_fprintf(stdout, "   used by other app, freeing\n");

#endif

            awt_data->color_data->awt_Colors[pixel].flags = UNAVAILABLE_COLOR;

            XFreeColors(dpy, cm, &col.pixel, 1, 0);

            return -1;

        }

        /*

         * Our current implementation doesn't support pixels which

         * don't fit in 8 bit (even for 12-bit visuals)

         */

        if (col.pixel > 255) {

#ifdef DEBUG

            if (debug_colormap)

                jio_fprintf(stdout, "pixel %d for (%d,%d, %d) is > 8 bit, releasing.\n",

                            col.pixel, r, g, b);

#endif

            XFreeColors(dpy, cm, &col.pixel, 1, 0);

            return awt_color_match(r, g, b, awt_data);

        }

        awt_data->color_data->awt_Colors[col.pixel].flags = ALLOCATED_COLOR;

        awt_data->color_data->awt_Colors[col.pixel].r = col.red   >> 8;

        awt_data->color_data->awt_Colors[col.pixel].g = col.green >> 8;

        awt_data->color_data->awt_Colors[col.pixel].b = col.blue  >> 8;

        if (awt_data->color_data->awt_icmLUT != 0) {

            awt_data->color_data->awt_icmLUT2Colors[col.pixel] = col.pixel;

            awt_data->color_data->awt_icmLUT[col.pixel] =

                0xff000000 |

                (awt_data->color_data->awt_Colors[col.pixel].r<<16) |

                (awt_data->color_data->awt_Colors[col.pixel].g<<8) |

                (awt_data->color_data->awt_Colors[col.pixel].b);

        }

        return col.pixel;

#ifdef DEBUG

    } else if (debug_colormap) {

        jio_fprintf(stdout, "can't allocate (%d,%d, %d)\n", r, g, b);

#endif

    }

    return awt_color_match(r, g, b, awt_data);

}

void

awt_allocate_systemcolors(XColor *colorsPtr, int num_pixels, AwtGraphicsConfigDataPtr awtData) {

    int i;

    int r, g, b, pixel;

    for (i=0; i < num_pixels; i++) {

        r = colorsPtr[i].red   >> 8;

        g = colorsPtr[i].green >> 8;

        b = colorsPtr[i].blue  >> 8;

        pixel = alloc_col(awt_display, awtData->awt_cmap, r, g, b, -1, awtData);

    }

}

#endif /* !HEADLESS */

void

awt_fill_imgcv(ImgConvertFcn **array, int mask, int value, ImgConvertFcn fcn)

{

    int i;

    for (i = 0; i < NUM_IMGCV; i++) {

        if ((i & mask) == value) {

            array[i] = fcn;

        }

    }

}

#ifndef HEADLESS

/*

 * called from X11Server_create() in xlib.c

 */

int

awt_allocate_colors(AwtGraphicsConfigDataPtr awt_data)

{

    Display *dpy;

    unsigned long freecolors[MAX_PALETTE_SIZE], plane_masks[1];

    int paletteSize;

    XColor cols[MAX_PALETTE_SIZE];

    unsigned char reds[256], greens[256], blues[256];

    int indices[256];

    Colormap cm;

    int i, j, k, cmapsize, nfree, depth, bpp;

    int allocatedColorsNum, unavailableColorsNum;

    XPixmapFormatValues *pPFV;

    int numpfv;

    XVisualInfo *pVI;

    char *forcemono;

    char *forcegray;

    make_uns_ordered_dither_array(img_oda_alpha, 256);

    forcemono = getenv("FORCEMONO");

    forcegray = getenv("FORCEGRAY");

    if (forcemono && !forcegray)

        forcegray = forcemono;

    /*

     * Get the colormap and make sure we have the right visual

     */

    dpy = awt_display;

    cm = awt_data->awt_cmap;

    depth = awt_data->awt_depth;

    pVI = &awt_data->awt_visInfo;

    awt_data->awt_num_colors = awt_data->awt_visInfo.colormap_size;

    awt_data->awtImage = (awtImageData *) calloc (1, sizeof (awtImageData));

    pPFV = XListPixmapFormats(dpy, &numpfv);

    if (pPFV) {

        for (i = 0; i < numpfv; i++) {

            if (pPFV[i].depth == depth) {

                awt_data->awtImage->wsImageFormat = pPFV[i];

                break;

            }

        }

        XFree(pPFV);

    }

    bpp = awt_data->awtImage->wsImageFormat.bits_per_pixel;

    if (bpp == 24) {

        bpp = 32;

    }

    awt_data->awtImage->clrdata.bitsperpixel = bpp;

    awt_data->awtImage->Depth = depth;

    if ((bpp == 32 || bpp == 16) && pVI->class == TrueColor && depth >= 15) {

        awt_data->AwtColorMatch = awt_color_matchTC;

        awt_data->awtImage->clrdata.rOff = 0;

        for (i = pVI->red_mask; (i & 1) == 0; i >>= 1) {

            awt_data->awtImage->clrdata.rOff++;

        }

        awt_data->awtImage->clrdata.rScale = 0;

        while (i < 0x80) {

            awt_data->awtImage->clrdata.rScale++;

            i <<= 1;

        }

        awt_data->awtImage->clrdata.gOff = 0;

        for (i = pVI->green_mask; (i & 1) == 0; i >>= 1) {

            awt_data->awtImage->clrdata.gOff++;

        }

        awt_data->awtImage->clrdata.gScale = 0;

        while (i < 0x80) {

            awt_data->awtImage->clrdata.gScale++;

            i <<= 1;

        }

        awt_data->awtImage->clrdata.bOff = 0;

        for (i = pVI->blue_mask; (i & 1) == 0; i >>= 1) {

            awt_data->awtImage->clrdata.bOff++;

        }

        awt_data->awtImage->clrdata.bScale = 0;

        while (i < 0x80) {

            awt_data->awtImage->clrdata.bScale++;

            i <<= 1;

        }

#ifdef NEED_IMAGE_CONVERT

        awt_fill_imgcv(awt_data->awtImage->convert, 0, 0, DirectImageConvert);

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_UNSCALED | IMGCV_BYTEIN

                        | IMGCV_OPAQUE | IMGCV_ICM),

                       (bpp == 32

                        ? Dir32IcmOpqUnsImageConvert

                        : Dir16IcmOpqUnsImageConvert));

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_UNSCALED | IMGCV_BYTEIN

                        | IMGCV_ALPHA | IMGCV_ICM),

                       (bpp == 32

                        ? Dir32IcmTrnUnsImageConvert

                        : Dir16IcmTrnUnsImageConvert));

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_SCALED | IMGCV_BYTEIN

                        | IMGCV_OPAQUE | IMGCV_ICM),

                       (bpp == 32

                        ? Dir32IcmOpqSclImageConvert

                        : Dir16IcmOpqSclImageConvert));

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_UNSCALED | IMGCV_INTIN

                        | IMGCV_OPAQUE | IMGCV_DCM8),

                       (bpp == 32

                        ? Dir32DcmOpqUnsImageConvert

                        : Dir16DcmOpqUnsImageConvert));

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_UNSCALED | IMGCV_INTIN

                        | IMGCV_ALPHA | IMGCV_DCM8),

                       (bpp == 32

                        ? Dir32DcmTrnUnsImageConvert

                        : Dir16DcmTrnUnsImageConvert));

        awt_fill_imgcv(awt_data->awtImage->convert,

                       (IMGCV_SCALEBITS | IMGCV_INSIZEBITS

                        | IMGCV_ALPHABITS | IMGCV_CMBITS),

                       (IMGCV_SCALED | IMGCV_INTIN

                        | IMGCV_OPAQUE | IMGCV_DCM8),

                       (bpp == 32

                        ? Dir32DcmOpqSclImageConvert

                        : Dir16DcmOpqSclImageConvert));

#endif /* NEED_IMAGE_CONVERT */

    } else if (bpp <= 16 && (pVI->class == StaticGray

                            || pVI->class == GrayScale

                            || (pVI->class == PseudoColor && forcegray))) {

        awt_data->AwtColorMatch = awt_color_matchGS;

        awt_data->awtImage->clrdata.grayscale = 1;

        awt_data->awtImage->clrdata.bitsperpixel = MAX(bpp, 8);

#ifdef NEED_IMAGE_CONVERT

        awt_fill_imgcv(awt_data->awtImage->convert, 0, 0, PseudoImageConvert);

        if (getenv("NOFSDITHER") == NULL) {

            awt_fill_imgcv(awt_data->awtImage->convert,

                           IMGCV_ORDERBITS, IMGCV_TDLRORDER,

                           PseudoFSImageConvert);

        }

#endif /* NEED_IMAGE_CONVERT */

    } else if (depth <= 12 && (pVI->class == PseudoColor

                             || pVI->class == TrueColor

                             || pVI->class == StaticColor)) {

        if (pVI->class == TrueColor)

           awt_data->awt_num_colors = (1 << pVI->depth);

        awt_data->AwtColorMatch = awt_color_match;

        awt_data->awtImage->clrdata.bitsperpixel = MAX(bpp, 8);

#ifdef NEED_IMAGE_CONVERT

        awt_fill_imgcv(awt_data->awtImage->convert, 0, 0, PseudoImageConvert);

        if (getenv("NOFSDITHER") == NULL) {

            awt_fill_imgcv(awt_data->awtImage->convert, IMGCV_ORDERBITS,