/*

  24 bit

 */

/*

 *  OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.

 *  Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.  

 *  All Rights Reserved.

 *

 *  This is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This software 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 for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this software; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,

 *  USA.

 */

static void

rfbInitOneRGBTable24 (uint8_t *table, int inMax, int outMax, int outShift,int swap);

static void

rfbInitColourMapSingleTable24(char **table, rfbPixelFormat *in,

                            rfbPixelFormat *out,rfbColourMap* colourMap)

{

    uint32_t i, r, g, b, outValue;

    uint8_t *t;

    uint8_t c;

    unsigned int nEntries = 1 << in->bitsPerPixel;

    int shift = colourMap->is16?16:8;

    if (*table) free(*table);

    *table = (char *)malloc(nEntries * 3 + 1);

    t = (uint8_t *)*table;

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

        r = g = b = 0;

  if(i < colourMap->count) {

    if(colourMap->is16) {

      r = colourMap->data.shorts[3*i+0];

      g = colourMap->data.shorts[3*i+1];

      b = colourMap->data.shorts[3*i+2];

    } else {

      r = colourMap->data.bytes[3*i+0];

      g = colourMap->data.bytes[3*i+1];

      b = colourMap->data.bytes[3*i+2];

    }

  }

        outValue = ((((r * (1 + out->redMax)) >> shift) << out->redShift) |

                (((g * (1 + out->greenMax)) >> shift) << out->greenShift) |

                (((b * (1 + out->blueMax)) >> shift) << out->blueShift));

  *(uint32_t*)&t[3*i] = outValue;

  if(!rfbEndianTest)

    memmove(t+3*i,t+3*i+1,3);

        if (out->bigEndian != in->bigEndian) {

    c = t[3*i]; t[3*i] = t[3*i+2]; t[3*i+2] = c;

        }

    }

}

/*

 * rfbInitTrueColourSingleTable sets up a single lookup table for truecolour

 * translation.

 */

static void

rfbInitTrueColourSingleTable24 (char **table, rfbPixelFormat *in,

                                 rfbPixelFormat *out)

{

    int i,outValue;

    int inRed, inGreen, inBlue, outRed, outGreen, outBlue;

    uint8_t *t;

    uint8_t c;

    int nEntries = 1 << in->bitsPerPixel;

    if (*table) free(*table);

    *table = (char *)malloc(nEntries * 3 + 1);

    t = (uint8_t *)*table;

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

        inRed   = (i >> in->redShift)   & in->redMax;

        inGreen = (i >> in->greenShift) & in->greenMax;

        inBlue  = (i >> in->blueShift)  & in->blueMax;

        outRed   = (inRed   * out->redMax   + in->redMax / 2)   / in->redMax;

        outGreen = (inGreen * out->greenMax + in->greenMax / 2) / in->greenMax;

        outBlue  = (inBlue  * out->blueMax  + in->blueMax / 2)  / in->blueMax;

  outValue = ((outRed   << out->redShift)   |

                (outGreen << out->greenShift) |

                (outBlue  << out->blueShift));

  *(uint32_t*)&t[3*i] = outValue;

  if(!rfbEndianTest)

    memmove(t+3*i,t+3*i+1,3);

        if (out->bigEndian != in->bigEndian) {

    c = t[3*i]; t[3*i] = t[3*i+2]; t[3*i+2] = c;

        }

    }

}

/*

 * rfbInitTrueColourRGBTables sets up three separate lookup tables for the

 * red, green and blue values.

 */

static void

rfbInitTrueColourRGBTables24 (char **table, rfbPixelFormat *in,

                               rfbPixelFormat *out)

{

    uint8_t *redTable;

    uint8_t *greenTable;

    uint8_t *blueTable;

    if (*table) free(*table);

    *table = (char *)malloc((in->redMax + in->greenMax + in->blueMax + 3)

                            * 3 + 1);

    redTable = (uint8_t *)*table;

    greenTable = redTable + 3*(in->redMax + 1);

    blueTable = greenTable + 3*(in->greenMax + 1);

    rfbInitOneRGBTable24 (redTable, in->redMax, out->redMax,

                           out->redShift, (out->bigEndian != in->bigEndian));

    rfbInitOneRGBTable24 (greenTable, in->greenMax, out->greenMax,

                           out->greenShift, (out->bigEndian != in->bigEndian));

    rfbInitOneRGBTable24 (blueTable, in->blueMax, out->blueMax,

                           out->blueShift, (out->bigEndian != in->bigEndian));

}

static void

rfbInitOneRGBTable24 (uint8_t *table, int inMax, int outMax, int outShift,

                       int swap)

{

    int i;

    int nEntries = inMax + 1;

    uint32_t outValue;

    uint8_t c;

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

      outValue = ((i * outMax + inMax / 2) / inMax) << outShift;

      *(uint32_t *)&table[3*i] = outValue;

      if(!rfbEndianTest) {

  memmove(table+3*i,table+3*i+1,3);

      }

      if (swap) {

        c = table[3*i]; table[3*i] = table[3*i+2];

        table[3*i+2] = c;

      }

    }

}