Restructure the TigerVNC 1.2 encoder so that it uses TigerVNC's pixel translation code instead of the built-in pixel translation code in the benchmark tools. Also fix an issue whereby the bits per pixel field in rfbScreen was being set to the BPP of the client, not the server. As a result of both of these changes, the -o option now works when using the TigerVNC 1.2 encoder with the CUT active.

git-svn-id: svn+ssh://svn.code.sf.net/p/turbovnc/code/vncbenchtools/trunk@2802 799e4f7b-5fd2-41f6-823c-2ecc41bc7f0b

Author: dcommander

misc.c

@@ -128,7 +128,7 @@ void InitEverything (int color_depth)
 
   image->width = 1280;
   image->height = 1024;
-  image->bits_per_pixel = rfbClient.format.bitsPerPixel;
+  image->bits_per_pixel = rfbServerFormat.bitsPerPixel;
   image->bytes_per_line = ((image->width * image->bits_per_pixel / 8) + 3) & (~3);
   image->data = (char *)malloc(image->width * image->bytes_per_line);
 

tiger-1.2.cxx

@@ -16,16 +16,19 @@
  * USA.
  */
 
+#include <rdr/Exception.h>
+#include <rfb/ComparingUpdateTracker.h>
+#include <rdr/RFBOutStream.h>
+#include <rfb/TightEncoder.h>
 #include "rfb.h"
 
 static int compressLevel = 1;
 static int qualityLevel = 8;
 
-#include <rfb/PixelFormat.h>
-
 using namespace rfb;
 
 rfbClientPtr cl = NULL;
+rdr::RFBOutStream rfbos;
 static rdr::U8* imageBuf = NULL;
 static int imageBufSize = 0;
 
@@ -46,13 +49,11 @@ rdr::U8* getImageBuf(int required, const PixelFormat& pf)
   return imageBuf;
 }
 
-#include <rdr/Exception.h>
-#include <rfb/TightEncoder.h>
-#include <rfb/ComparingUpdateTracker.h>
-
 static TightEncoder *te = NULL;
 static TransImageGetter image_getter;
 
+PixelFormat clientPF;
+
 Bool compareFB = FALSE;
 
 static ComparingUpdateTracker *cut = NULL;
@@ -74,14 +75,27 @@ Bool rfbSendRectEncodingTight(rfbClientPtr _cl, int x, int y, int w, int h)
 
     te->setCompressLevel(compressLevel);
     te->setQualityLevel(qualityLevel);
+
+    PixelFormat serverPF(rfbServerFormat.bitsPerPixel, rfbServerFormat.depth,
+      rfbServerFormat.bigEndian==1, rfbServerFormat.trueColour==1,
+      rfbServerFormat.redMax, rfbServerFormat.greenMax,
+      rfbServerFormat.blueMax, rfbServerFormat.redShift,
+      rfbServerFormat.greenShift, rfbServerFormat.blueShift);
+
+    PixelFormat cpf(cl->format.bitsPerPixel, cl->format.depth,
+      cl->format.bigEndian==1, cl->format.trueColour==1, cl->format.redMax,
+      cl->format.greenMax, cl->format.blueMax, cl->format.redShift,
+      cl->format.greenShift, cl->format.blueShift);
+    clientPF = cpf;
+
+    if (!fb) fb = new FullFramePixelBuffer(serverPF, rfbScreen.width,
+      rfbScreen.height, (rdr::U8 *)rfbScreen.pfbMemory, NULL);
+
+    image_getter.init(fb, clientPF, NULL);
+
+    rfbos.setptr((rdr::U8 *)&updateBuf[ublen]);
+
     if (compareFB) {
-      PixelFormat spf(rfbServerFormat.bitsPerPixel, rfbServerFormat.depth,
-        rfbServerFormat.bigEndian==1, rfbServerFormat.trueColour==1,
-        rfbServerFormat.redMax, rfbServerFormat.greenMax,
-        rfbServerFormat.blueMax, rfbServerFormat.redShift,
-        rfbServerFormat.greenShift, rfbServerFormat.blueShift);
-      if (!fb) fb = new FullFramePixelBuffer(spf, rfbScreen.width,
-        rfbScreen.height, (rdr::U8 *)rfbScreen.pfbMemory, NULL);
       if (!cut) cut = new ComparingUpdateTracker(fb);
       rfb::Region changed;
       cut->compareRect(r, &changed);
@@ -93,6 +107,8 @@ Bool rfbSendRectEncodingTight(rfbClientPtr _cl, int x, int y, int w, int h)
       }
     }
     else te->writeRect(r, &image_getter, NULL);
+
+    ublen = rfbos.getptr() - (rdr::U8 *)updateBuf;
   }
   catch (rdr::Exception e) {
     fprintf(stderr, "ERROR: %s\n", e.str());

tiger-1.2/CMakeLists.txt

@@ -7,8 +7,10 @@ set(SOURCES
   rfb/JpegDecompressor.cxx
   rfb/PixelBuffer.cxx
   rfb/PixelFormat.cxx
+  rfb/PixelTransformer.cxx
   rfb/Region.cxx
   rfb/TightEncoder.cxx
+  rfb/TransImageGetter.cxx
   Xregion/Region.c)
 
 add_library(tigervnc ${SOURCES})

tiger-1.2/rdr/RFBOutStream.h

@@ -0,0 +1,89 @@
+/* Copyright (C) 2014 D. R. Commander.  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.
+ */
+
+//
+// OutStream wrapper for the buffering code used by the TurboVNC benchmark
+//
+
+#ifndef __RDR_RFBOUTSTREAM_H__
+#define __RDR_RFBOUTSTREAM_H__
+
+#include <rdr/OutStream.h>
+#include <rdr/Exception.h>
+#include "rfb.h"
+
+extern rfbClientPtr cl;
+
+namespace rdr {
+
+  class RFBOutStream : public OutStream {
+
+  public:
+
+    RFBOutStream() {
+      ptr = (rdr::U8 *)&updateBuf[ublen];
+      end = (rdr::U8 *)&updateBuf[UPDATE_BUF_SIZE];
+    }
+
+    virtual ~RFBOutStream() {
+    }
+
+    void writeBytes(const void* data, int length) {
+      ublen = ptr - (rdr::U8 *)updateBuf;
+
+      int portionLen = UPDATE_BUF_SIZE;
+      int compressedLen = length;
+      char *buf = (char *)data;
+      for(int i = 0; i < compressedLen; i += portionLen) {
+        if(i + portionLen > compressedLen) {
+          portionLen = compressedLen - i;
+        }
+        if(ublen + portionLen > UPDATE_BUF_SIZE)
+          if(!rfbSendUpdateBuf(cl))
+            throw Exception("rfbSendUpdateBuf() failed");
+        memcpy(&updateBuf[ublen], &buf[i], portionLen);
+        ublen += portionLen;
+      }
+
+      ptr = (rdr::U8 *)&updateBuf[ublen];
+    }
+
+    int length() { return ublen; }
+
+  protected:
+
+    int overrun(int itemSize, int nItems) {
+      ublen = ptr - (rdr::U8 *)updateBuf;
+
+      if(ublen + itemSize * nItems > UPDATE_BUF_SIZE)
+        if(!rfbSendUpdateBuf(cl))
+          throw Exception("rfbSendUpdateBuf() failed");
+
+      if(ublen + itemSize * nItems > UPDATE_BUF_SIZE)
+        throw Exception("Not enough room in buffer");
+
+      ptr = (rdr::U8 *)&updateBuf[ublen];
+
+      return nItems;
+    }
+
+  };
+
+}
+
+#endif

tiger-1.2/rfb/ColourCube.h

@@ -0,0 +1,96 @@
+/* Copyright (C) 2002-2005 RealVNC Ltd.  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.
+ */
+//
+// ColourCube - structure to represent a colour cube.  The colour cube consists
+// of its dimensions (nRed x nGreen x nBlue) and a table mapping an (r,g,b)
+// triple to a pixel value.
+//
+// A colour cube is used in two cases.  The first is internally in a viewer
+// when it cannot use a trueColour format, nor can it have exclusive access to
+// a writable colour map.  This is most notably the case for an X viewer
+// wishing to use a PseudoColor X server's default colormap.
+//
+// The second use is on the server side when a client has asked for a colour
+// map and the server is trueColour.  Instead of setting an uneven trueColour
+// format like bgr233, it can set the client's colour map up with a 6x6x6
+// colour cube.  For this use the colour cube table has a null mapping, which
+// makes it easy to perform the reverse lookup operation from pixel value to
+// r,g,b values.
+
+#ifndef __RFB_COLOURCUBE_H__
+#define __RFB_COLOURCUBE_H__
+
+#include <rfb/Pixel.h>
+#include <rfb/ColourMap.h>
+
+namespace rfb {
+
+  class ColourCube : public ColourMap {
+  public:
+    ColourCube(int nr, int ng, int nb, Pixel* table_=0)
+      : nRed(nr), nGreen(ng), nBlue(nb), table(table_), deleteTable(false)
+    {
+      if (!table) {
+        table = new Pixel[size()];
+        deleteTable = true;
+        // set a null mapping by default
+        for (int i = 0; i < size(); i++)
+          table[i] = i;
+      }
+    }
+
+    ColourCube() : deleteTable(false) {}
+
+    virtual ~ColourCube() {
+      if (deleteTable) delete [] table;
+    }
+
+    void set(int r, int g, int b, Pixel p) {
+      table[(r * nGreen + g) * nBlue + b] = p;
+    }
+
+    Pixel lookup(int r, int g, int b) const {
+      return table[(r * nGreen + g) * nBlue + b];
+    }
+
+    int size()      const { return nRed*nGreen*nBlue; }
+    int redMult()   const { return nGreen*nBlue; }
+    int greenMult() const { return nBlue; }
+    int blueMult()  const { return 1; }
+
+    // ColourMap lookup() method.  Note that this only works when the table has
+    // the default null mapping.
+    virtual void lookup(int i, int* r, int* g, int* b) {
+      if (i >= size()) return;
+      *b = i % nBlue;
+      i /= nBlue;
+      *g = i % nGreen;
+      *r = i / nGreen;
+      *r = (*r * 65535 + (nRed-1)   / 2) / (nRed-1);
+      *g = (*g * 65535 + (nGreen-1) / 2) / (nGreen-1);
+      *b = (*b * 65535 + (nBlue-1)  / 2) / (nBlue-1);
+    }
+
+    int nRed;
+    int nGreen;
+    int nBlue;
+    Pixel* table;
+    bool deleteTable;
+  };
+}
+#endif

tiger-1.2/rfb/ComparingUpdateTracker.cxx

@@ -38,6 +38,15 @@ ComparingUpdateTracker::~ComparingUpdateTracker()
 
 void ComparingUpdateTracker::compareRect(const Rect& r, Region* newChanged)
 {
+  if (!r.enclosed_by(fb->getRect())) {
+    Rect safe;
+    // Crop the rect and try again
+    safe = r.intersect(fb->getRect());
+    if (!safe.is_empty())
+      compareRect(safe, newChanged);
+    return;
+  }
+
   if (firstCompare) {
     // NB: We leave the change region untouched on this iteration,
     // since in effect the entire framebuffer has changed.
@@ -49,14 +58,10 @@ void ComparingUpdateTracker::compareRect(const Rect& r, Region* newChanged)
       oldFb.imageRect(pos, srcData, srcStride);
     }
     firstCompare = false;
-  }
 
-  if (!r.enclosed_by(fb->getRect())) {
-    Rect safe;
-    // Crop the rect and try again
-    safe = r.intersect(fb->getRect());
-    if (!safe.is_empty())
-      compareRect(safe, newChanged);
+    Region temp;
+    temp.reset(fb->getRect());
+    newChanged->assign_union(temp);
     return;
   }