/apps/desktop/libvncserver/tableinit24.c

  1/*
  2  24 bit
  3 */
  4
  5/*
  6 *  OSXvnc Copyright (C) 2001 Dan McGuirk <mcguirk@incompleteness.net>.
  7 *  Original Xvnc code Copyright (C) 1999 AT&T Laboratories Cambridge.  
  8 *  All Rights Reserved.
  9 *
 10 *  This is free software; you can redistribute it and/or modify
 11 *  it under the terms of the GNU General Public License as published by
 12 *  the Free Software Foundation; either version 2 of the License, or
 13 *  (at your option) any later version.
 14 *
 15 *  This software is distributed in the hope that it will be useful,
 16 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 17 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 18 *  GNU General Public License for more details.
 19 *
 20 *  You should have received a copy of the GNU General Public License
 21 *  along with this software; if not, write to the Free Software
 22 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 23 *  USA.
 24 */
 25
 26static void
 27rfbInitOneRGBTable24 (uint8_t *table, int inMax, int outMax, int outShift,int swap);
 28
 29
 30static void
 31rfbInitColourMapSingleTable24(char **table, rfbPixelFormat *in,
 32                            rfbPixelFormat *out,rfbColourMap* colourMap)
 33{
 34    uint32_t i, r, g, b, outValue;
 35    uint8_t *t;
 36    uint8_t c;
 37    unsigned int nEntries = 1 << in->bitsPerPixel;
 38    int shift = colourMap->is16?16:8;
 39
 40    if (*table) free(*table);
 41    *table = (char *)malloc(nEntries * 3 + 1);
 42    t = (uint8_t *)*table;
 43
 44    for (i = 0; i < nEntries; i++) {
 45        r = g = b = 0;
 46	if(i < colourMap->count) {
 47	  if(colourMap->is16) {
 48	    r = colourMap->data.shorts[3*i+0];
 49	    g = colourMap->data.shorts[3*i+1];
 50	    b = colourMap->data.shorts[3*i+2];
 51	  } else {
 52	    r = colourMap->data.bytes[3*i+0];
 53	    g = colourMap->data.bytes[3*i+1];
 54	    b = colourMap->data.bytes[3*i+2];
 55	  }
 56	}
 57        outValue = ((((r * (1 + out->redMax)) >> shift) << out->redShift) |
 58                (((g * (1 + out->greenMax)) >> shift) << out->greenShift) |
 59                (((b * (1 + out->blueMax)) >> shift) << out->blueShift));
 60	*(uint32_t*)&t[3*i] = outValue;
 61	if(!rfbEndianTest)
 62	  memmove(t+3*i,t+3*i+1,3);
 63        if (out->bigEndian != in->bigEndian) {
 64	  c = t[3*i]; t[3*i] = t[3*i+2]; t[3*i+2] = c;
 65        }
 66    }
 67}
 68
 69/*
 70 * rfbInitTrueColourSingleTable sets up a single lookup table for truecolour
 71 * translation.
 72 */
 73
 74static void
 75rfbInitTrueColourSingleTable24 (char **table, rfbPixelFormat *in,
 76                                 rfbPixelFormat *out)
 77{
 78    int i,outValue;
 79    int inRed, inGreen, inBlue, outRed, outGreen, outBlue;
 80    uint8_t *t;
 81    uint8_t c;
 82    int nEntries = 1 << in->bitsPerPixel;
 83
 84    if (*table) free(*table);
 85    *table = (char *)malloc(nEntries * 3 + 1);
 86    t = (uint8_t *)*table;
 87
 88    for (i = 0; i < nEntries; i++) {
 89        inRed   = (i >> in->redShift)   & in->redMax;
 90        inGreen = (i >> in->greenShift) & in->greenMax;
 91        inBlue  = (i >> in->blueShift)  & in->blueMax;
 92
 93        outRed   = (inRed   * out->redMax   + in->redMax / 2)   / in->redMax;
 94        outGreen = (inGreen * out->greenMax + in->greenMax / 2) / in->greenMax;
 95        outBlue  = (inBlue  * out->blueMax  + in->blueMax / 2)  / in->blueMax;
 96
 97	outValue = ((outRed   << out->redShift)   |
 98                (outGreen << out->greenShift) |
 99                (outBlue  << out->blueShift));
100	*(uint32_t*)&t[3*i] = outValue;
101	if(!rfbEndianTest)
102	  memmove(t+3*i,t+3*i+1,3);
103        if (out->bigEndian != in->bigEndian) {
104	  c = t[3*i]; t[3*i] = t[3*i+2]; t[3*i+2] = c;
105        }
106    }
107}
108
109
110/*
111 * rfbInitTrueColourRGBTables sets up three separate lookup tables for the
112 * red, green and blue values.
113 */
114
115static void
116rfbInitTrueColourRGBTables24 (char **table, rfbPixelFormat *in,
117                               rfbPixelFormat *out)
118{
119    uint8_t *redTable;
120    uint8_t *greenTable;
121    uint8_t *blueTable;
122
123    if (*table) free(*table);
124    *table = (char *)malloc((in->redMax + in->greenMax + in->blueMax + 3)
125                            * 3 + 1);
126    redTable = (uint8_t *)*table;
127    greenTable = redTable + 3*(in->redMax + 1);
128    blueTable = greenTable + 3*(in->greenMax + 1);
129
130    rfbInitOneRGBTable24 (redTable, in->redMax, out->redMax,
131                           out->redShift, (out->bigEndian != in->bigEndian));
132    rfbInitOneRGBTable24 (greenTable, in->greenMax, out->greenMax,
133                           out->greenShift, (out->bigEndian != in->bigEndian));
134    rfbInitOneRGBTable24 (blueTable, in->blueMax, out->blueMax,
135                           out->blueShift, (out->bigEndian != in->bigEndian));
136}
137
138static void
139rfbInitOneRGBTable24 (uint8_t *table, int inMax, int outMax, int outShift,
140                       int swap)
141{
142    int i;
143    int nEntries = inMax + 1;
144    uint32_t outValue;
145    uint8_t c;
146
147    for (i = 0; i < nEntries; i++) {
148      outValue = ((i * outMax + inMax / 2) / inMax) << outShift;
149      *(uint32_t *)&table[3*i] = outValue;
150      if(!rfbEndianTest)
151	memmove(table+3*i,table+3*i+1,3);
152        if (swap) {
153	  c = table[3*i]; table[3*i] = table[3*i+2];
154	  table[3*i+2] = c;
155        }
156    }
157}