commit c0397269fcab67e9acd4fdcbc29f24d79ed0ef39
author Pierre Ossman <ossman@cendio.se> Fri Mar 14 15:59:46 2014 +0100
committer Pierre Ossman <ossman@cendio.se> Mon Jul 14 16:03:42 2014 +0200
tree 41ac251e5a595a37b832a61626723a89258bb018
parent a088f1ab3923482998174b9db8949cf06d0761af

Move image encoding logic into a central EncodeManager class

This allows us to apply a lot more server logic
independently of which encoder is in use.

Most of this class are things moved over from the
Tight encoder.

common/rfb/Encoder.cxx

diff --git a/common/rfb/Encoder.cxx b/common/rfb/Encoder.cxx
index 89a5f14..16f7081 100644
--- a/common/rfb/Encoder.cxx
+++ b/common/rfb/Encoder.cxx
@@ -16,20 +16,17 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
  * USA.
  */
-#include <stdio.h>
-#include <rfb/encodings.h>
-#include <rfb/Exception.h>
+
 #include <rfb/Encoder.h>
-#include <rfb/RawEncoder.h>
-#include <rfb/RREEncoder.h>
-#include <rfb/HextileEncoder.h>
-#include <rfb/ZRLEEncoder.h>
-#include <rfb/TightEncoder.h>
-#include <rfb/SConnection.h>
+#include <rfb/PixelBuffer.h>
+#include <rfb/Palette.h>
 
 using namespace rfb;
 
-Encoder::Encoder(SConnection *conn_) : conn(conn_)
+Encoder::Encoder(SConnection *conn_, int encoding_,
+                 enum EncoderFlags flags_, unsigned int maxPaletteSize_) :
+  conn(conn_), encoding(encoding_), flags(flags_),
+  maxPaletteSize(maxPaletteSize_)
 {
 }
 
@@ -37,34 +34,50 @@
 {
 }
 
-bool Encoder::supported(int encoding)
+void Encoder::writeSolidRect(int width, int height,
+                             const PixelFormat& pf, const rdr::U8* colour)
 {
-  switch (encoding) {
-  case encodingRaw:
-  case encodingRRE:
-  case encodingHextile:
-  case encodingZRLE:
-  case encodingTight:
-    return true;
-  default:
-    return false;
-  }
+  ManagedPixelBuffer buffer(pf, width, height);
+  Pixel pixel;
+
+  Palette palette;
+  rdr::U32 palcol;
+
+  pixel = pf.pixelFromBuffer(colour);
+  buffer.fillRect(buffer.getRect(), pixel);
+
+  palcol = 0;
+  memcpy(&palcol, colour, pf.bpp/8);
+  palette.insert(palcol, 1);
+
+  writeRect(&buffer, palette);
 }
 
-Encoder* Encoder::createEncoder(int encoding, SConnection* conn)
+void Encoder::writeSolidRect(const PixelBuffer* pb, const Palette& palette)
 {
-  switch (encoding) {
-  case encodingRaw:
-    return new RawEncoder(conn);
-  case encodingRRE:
-    return new RREEncoder(conn);
-  case encodingHextile:
-    return new HextileEncoder(conn);
-  case encodingZRLE:
-    return new ZRLEEncoder(conn);
-  case encodingTight:
-    return new TightEncoder(conn);
+  rdr::U32 col32;
+  rdr::U16 col16;
+  rdr::U8 col8;
+
+  rdr::U8* buffer;
+
+  assert(palette.size() == 1);
+
+  // The Palette relies on implicit up and down conversion
+  switch (pb->getPF().bpp) {
+  case 32:
+    col32 = (rdr::U32)palette.getColour(0);
+    buffer = (rdr::U8*)&col32;
+    break;
+  case 16:
+    col16 = (rdr::U16)palette.getColour(0);
+    buffer = (rdr::U8*)&col16;
+    break;
   default:
-    return NULL;
+    col8 = (rdr::U8)palette.getColour(0);
+    buffer = (rdr::U8*)&col8;
+    break;
   }
+
+  writeSolidRect(pb->width(), pb->height(), pb->getPF(), buffer);
 }