move the library into libvncserver/, x11vnc into x11vnc/

1 files changed, 157 insertions, 0 deletions

diff --git a/libvncserver/tableinit24.c b/libvncserver/tableinit24.c
new file mode 100755
index 0000000..39e9920
--- /dev/null
+++ b/libvncserver/tableinit24.c
@@ -0,0 +1,157 @@
+/*
+  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;
+        }
+    }
+}