Push encoding specific formats into the encoders and decoders

Keep the generic stream classes clean and general.

diff --git a/common/rdr/InStream.h b/common/rdr/InStream.h
index 6d22ac6af509f9305f729435bd93274a81458a6f..760fb3dcf5f28ac6acad55d4113e874c30d5db70 100644 (file)
--- a/common/rdr/InStream.h
+++ b/common/rdr/InStream.h
@@ -71,23 +71,6 @@ namespace rdr {
     inline S16 readS16() { return (S16)readU16(); }
     inline S32 readS32() { return (S32)readU32(); }
 
-    // readCompactLength() reads 1..3 bytes representing length of the data
-    // following.  This method is used by the Tight decoder.
-
-    inline unsigned int readCompactLength() {
-      U8 b = readU8();
-      int result = (int)b & 0x7F;
-      if (b & 0x80) {
-        b = readU8();
-        result |= ((int)b & 0x7F) << 7;
-        if (b & 0x80) {
-          b = readU8();
-          result |= ((int)b & 0xFF) << 14;
-        }
-      }
-      return result;
-    }
-
     // readString() reads a string - a U32 length followed by the data.
     // Returns a null-terminated string - the caller should delete[] it
     // afterwards.
@@ -128,12 +111,6 @@ namespace rdr {
     inline U32 readOpaque32() { check(4); U32 r; ((U8*)&r)[0] = *ptr++;
                                 ((U8*)&r)[1] = *ptr++; ((U8*)&r)[2] = *ptr++;
                                 ((U8*)&r)[3] = *ptr++; return r; }
-    inline U32 readOpaque24A() { check(3); U32 r=0; ((U8*)&r)[0] = *ptr++;
-                                 ((U8*)&r)[1] = *ptr++; ((U8*)&r)[2] = *ptr++;
-                                 return r; }
-    inline U32 readOpaque24B() { check(3); U32 r=0; ((U8*)&r)[1] = *ptr++;
-                                 ((U8*)&r)[2] = *ptr++; ((U8*)&r)[3] = *ptr++;
-                                 return r; }
 
     // pos() returns the position in the stream.
 

diff --git a/common/rdr/OutStream.h b/common/rdr/OutStream.h
index aed2eea189fd366538a57fa47d7c630c2a94d485..4afd4bfb3b1574d4c60a719bcf1715a9aa95b8b6 100644 (file)
--- a/common/rdr/OutStream.h
+++ b/common/rdr/OutStream.h
@@ -65,25 +65,6 @@ namespace rdr {
     inline void writeS16(S16 s) { writeU16((U16)s); }
     inline void writeS32(S32 s) { writeU32((U32)s); }
 
-    // writeCompactLength() writes 1..3 bytes representing length of the data
-    // following.  This method is used by the Tight encoder.
-
-    inline void writeCompactLength(unsigned int len) {
-      U8 b = len & 0x7F;
-      if (len <= 0x7F) {
-        writeU8(b);
-      } else {
-        writeU8(b | 0x80);
-        b = len >> 7 & 0x7F;
-        if (len <= 0x3FFF) {
-          writeU8(b);
-        } else {
-          writeU8(b | 0x80);
-          writeU8(len >> 14 & 0xFF);
-        }
-      }
-    }
-
     // writeString() writes a string - a U32 length followed by the data.  The
     // given string should be null-terminated (but the terminating null is not
     // written to the stream).
@@ -128,12 +109,6 @@ namespace rdr {
                                        *ptr++ = ((U8*)&u)[1];
                                        *ptr++ = ((U8*)&u)[2];
                                        *ptr++ = ((U8*)&u)[3]; }
-    inline void writeOpaque24A(U32 u) { check(3); *ptr++ = ((U8*)&u)[0];
-                                        *ptr++ = ((U8*)&u)[1];
-                                        *ptr++ = ((U8*)&u)[2]; }
-    inline void writeOpaque24B(U32 u) { check(3); *ptr++ = ((U8*)&u)[1];
-                                        *ptr++ = ((U8*)&u)[2];
-                                        *ptr++ = ((U8*)&u)[3]; }
 
     // length() returns the length of the stream.
 

diff --git a/common/rfb/TightDecoder.cxx b/common/rfb/TightDecoder.cxx
index 83e84f7031ee33fec76ee32541e2676bc3312aa4..635df551871e87e8c9f17886a1122245d3d92925 100644 (file)
--- a/common/rfb/TightDecoder.cxx
+++ b/common/rfb/TightDecoder.cxx
@@ -69,3 +69,22 @@ void TightDecoder::readRect(const Rect& r, CMsgHandler* handler)
     tightDecode32(r); break;
   }
 }
+
+rdr::U32 TightDecoder::readCompact(rdr::InStream* is)
+{
+  rdr::U8 b;
+  rdr::U32 result;
+
+  b = is->readU8();
+  result = (int)b & 0x7F;
+  if (b & 0x80) {
+    b = is->readU8();
+    result |= ((int)b & 0x7F) << 7;
+    if (b & 0x80) {
+      b = is->readU8();
+      result |= ((int)b & 0xFF) << 14;
+    }
+  }
+
+  return result;
+}

diff --git a/common/rfb/TightDecoder.h b/common/rfb/TightDecoder.h
index 0b915f925426592f0bffb0c9d1a350d0efc73c64..18b01f8a4f4b151dc6ed10e6e86eee8742019354 100644 (file)
--- a/common/rfb/TightDecoder.h
+++ b/common/rfb/TightDecoder.h
@@ -33,6 +33,8 @@ namespace rfb {
     virtual void readRect(const Rect& r, CMsgHandler* handler);
 
   private:
+    rdr::U32 readCompact(rdr::InStream* is);
+
     void tightDecode8(const Rect& r);
     void tightDecode16(const Rect& r);
     void tightDecode32(const Rect& r);

diff --git a/common/rfb/TightEncoder.cxx b/common/rfb/TightEncoder.cxx
index 622dc3d40126fa9078d4611f9ab7aab25ecb94e7..b94b53e3875ff77ab92f9aebc7d76da43b5969f7 100644 (file)
--- a/common/rfb/TightEncoder.cxx
+++ b/common/rfb/TightEncoder.cxx
@@ -410,3 +410,21 @@ void TightEncoder::writeSubrect(const Rect& r, bool forceSolid)
   os->writeBytes(mos.data(), mos.length());
   writer->endRect();
 }
+
+void TightEncoder::writeCompact(rdr::OutStream* os, rdr::U32 value)
+{
+  rdr::U8 b;
+  b = value & 0x7F;
+  if (value <= 0x7F) {
+    os->writeU8(b);
+  } else {
+    os->writeU8(b | 0x80);
+    b = value >> 7 & 0x7F;
+    if (value <= 0x3FFF) {
+      os->writeU8(b);
+    } else {
+      os->writeU8(b | 0x80);
+      os->writeU8(value >> 14 & 0xFF);
+    }
+  }
+}

diff --git a/common/rfb/TightEncoder.h b/common/rfb/TightEncoder.h
index a876b6f6d04ff1bdf74fafc7219dbbcae67b671e..b633512fe2776db82d30f9a9db48f5e8780ccd15 100644 (file)
--- a/common/rfb/TightEncoder.h
+++ b/common/rfb/TightEncoder.h
@@ -74,6 +74,8 @@ namespace rfb {
     void sendRectSimple(const Rect& r);
     void writeSubrect(const Rect& r, bool forceSolid = false);
 
+    void writeCompact(rdr::OutStream* os, rdr::U32 value);
+
     void compressData(const void *buf, unsigned int length,
                       rdr::ZlibOutStream *zos, int zlibLevel,
                       rdr::OutStream *os);

diff --git a/common/rfb/ZRLEDecoder.cxx b/common/rfb/ZRLEDecoder.cxx
index 20fe853c62b1d04af9c36a06dd2231e8ad17faf2..ffc24e3c3baf7560e7cac6c89244a8f18f074607 100644 (file)
--- a/common/rfb/ZRLEDecoder.cxx
+++ b/common/rfb/ZRLEDecoder.cxx
@@ -21,6 +21,26 @@
 
 using namespace rfb;
 
+static inline rdr::U32 readOpaque24A(rdr::InStream* is)
+{
+  is->check(3);
+  rdr::U32 r=0;
+  ((rdr::U8*)&r)[0] = is->readU8();
+  ((rdr::U8*)&r)[1] = is->readU8();
+  ((rdr::U8*)&r)[2] = is->readU8();
+  return r;
+
+}
+static inline rdr::U32 readOpaque24B(rdr::InStream* is)
+{
+  is->check(3);
+  rdr::U32 r=0;
+  ((rdr::U8*)&r)[1] = is->readU8();
+  ((rdr::U8*)&r)[2] = is->readU8();
+  ((rdr::U8*)&r)[3] = is->readU8();
+  return r;
+}
+
 #define EXTRA_ARGS CMsgHandler* handler
 #define FILL_RECT(r, p) handler->fillRect(r, p)
 #define IMAGE_RECT(r, p) handler->imageRect(r, p)

diff --git a/common/rfb/ZRLEEncoder.cxx b/common/rfb/ZRLEEncoder.cxx
index df7cfbdb5c9f4f16c7e922c456e20dde967ea16d..840af6be9ab73af09edf248de1a431020a82516b 100644 (file)
--- a/common/rfb/ZRLEEncoder.cxx
+++ b/common/rfb/ZRLEEncoder.cxx
@@ -28,6 +28,21 @@ using namespace rfb;
 
 IntParameter zlibLevel("ZlibLevel","Zlib compression level",-1);
 
+static inline void writeOpaque24A(rdr::OutStream* os, rdr::U32 u)
+{
+  os->check(3);
+  os->writeU8(((rdr::U8*)&u)[0]);
+  os->writeU8(((rdr::U8*)&u)[1]);
+  os->writeU8(((rdr::U8*)&u)[2]);
+}
+static inline void writeOpaque24B(rdr::OutStream* os, rdr::U32 u)
+{
+  os->check(3);
+  os->writeU8(((rdr::U8*)&u)[1]);
+  os->writeU8(((rdr::U8*)&u)[2]);
+  os->writeU8(((rdr::U8*)&u)[3]);
+}
+
 #define EXTRA_ARGS ImageGetter* ig
 #define GET_IMAGE_INTO_BUF(r,buf) ig->getImage(buf, r);
 #define BPP 8

diff --git a/common/rfb/tightDecode.h b/common/rfb/tightDecode.h
index 06c84775c454136e1771dd3b02bcd4a3d2345b77..e13994315c8c05029664c0697757f0e39eec5167 100644 (file)
--- a/common/rfb/tightDecode.h
+++ b/common/rfb/tightDecode.h
@@ -141,7 +141,7 @@ void TIGHT_DECODE (const Rect& r)
   if (dataSize < TIGHT_MIN_TO_COMPRESS) {
     input = is;
   } else {
-    int length = is->readCompactLength();
+    int length = readCompact(is);
     streamId = comp_ctl & 0x03;
     zis[streamId].setUnderlying(is, length);
     input = &zis[streamId];
@@ -242,7 +242,7 @@ void
 DECOMPRESS_JPEG_RECT(const Rect& r)
 {
   // Read length
-  int compressedLen = is->readCompactLength();
+  int compressedLen = readCompact(is);
   if (compressedLen <= 0) {
       throw Exception("Incorrect data received from the server.\n");
   }

diff --git a/common/rfb/tightEncode.h b/common/rfb/tightEncode.h
index 62665300372aeaad6ce6d039b5c1d2a1beed181d..1fd0f530c6a3a1bd0faffcb13d50706386d726bf 100644 (file)
--- a/common/rfb/tightEncode.h
+++ b/common/rfb/tightEncode.h
@@ -76,7 +76,7 @@ void TightEncoder::compressData(const void *buf, unsigned int length,
     zos->writeBytes(buf, length);
     zos->flush();
     zos->setUnderlying(NULL);
-    os->writeCompactLength(mem_os.length());
+    writeCompact(os, mem_os.length());
     os->writeBytes(mem_os.data(), mem_os.length());
   }
 }
@@ -336,7 +336,7 @@ void ENCODE_JPEG_RECT (PIXEL_T *buf, int stride, const Rect& r,
   jc.compress((rdr::U8 *)buf, stride, r, clientpf,
     jpegQuality, jpegSubsampling);
   os->writeU8(0x09 << 4);
-  os->writeCompactLength(jc.length());
+  writeCompact(os, jc.length());
   os->writeBytes(jc.data(), jc.length());
 }
 #endif  // #if (BPP != 8)

diff --git a/common/rfb/zrleDecode.h b/common/rfb/zrleDecode.h
index d26d4d3eae35df902e4e801c37346789f83925c9..207a6c74174353c00e3f60a9bbd618f0ad9ed646 100644 (file)
--- a/common/rfb/zrleDecode.h
+++ b/common/rfb/zrleDecode.h
@@ -41,11 +41,11 @@ namespace rfb {
 
 #ifdef CPIXEL
 #define PIXEL_T rdr::CONCAT2E(U,BPP)
-#define READ_PIXEL CONCAT2E(readOpaque,CPIXEL)
+#define READ_PIXEL(is) CONCAT2E(readOpaque,CPIXEL)(is)
 #define ZRLE_DECODE CONCAT2E(zrleDecode,CPIXEL)
 #else
 #define PIXEL_T rdr::CONCAT2E(U,BPP)
-#define READ_PIXEL CONCAT2E(readOpaque,BPP)
+#define READ_PIXEL(is) is->CONCAT2E(readOpaque,BPP)()
 #define ZRLE_DECODE CONCAT2E(zrleDecode,BPP)
 #endif
 
@@ -74,7 +74,7 @@ void ZRLE_DECODE (const Rect& r, rdr::InStream* is,
       PIXEL_T palette[128];
 
       for (int i = 0; i < palSize; i++) {
-        palette[i] = zis->READ_PIXEL();
+        palette[i] = READ_PIXEL(zis);
       }
 
       if (palSize == 1) {
@@ -90,7 +90,7 @@ void ZRLE_DECODE (const Rect& r, rdr::InStream* is,
 
 #ifdef CPIXEL
           for (PIXEL_T* ptr = buf; ptr < buf+t.area(); ptr++) {
-            *ptr = zis->READ_PIXEL();
+            *ptr = READ_PIXEL(zis);
           }
 #else
           zis->readBytes(buf, t.area() * (BPP / 8));
@@ -130,7 +130,7 @@ void ZRLE_DECODE (const Rect& r, rdr::InStream* is,
           PIXEL_T* ptr = buf;
           PIXEL_T* end = ptr + t.area();
           while (ptr < end) {
-            PIXEL_T pix = zis->READ_PIXEL();
+            PIXEL_T pix = READ_PIXEL(zis);
             int len = 1;
             int b;
             do {

diff --git a/common/rfb/zrleEncode.h b/common/rfb/zrleEncode.h
index 34b5c675aa73181144f92a3a4436fbcb3019c304..cfc2a4694c353dc0ee013fb803cee78cb8e7558e 100644 (file)
--- a/common/rfb/zrleEncode.h
+++ b/common/rfb/zrleEncode.h
@@ -45,13 +45,13 @@ namespace rfb {
 
 #ifdef CPIXEL
 #define PIXEL_T rdr::CONCAT2E(U,BPP)
-#define WRITE_PIXEL CONCAT2E(writeOpaque,CPIXEL)
+#define WRITE_PIXEL(os, u) CONCAT2E(writeOpaque,CPIXEL)(os, u)
 #define ZRLE_ENCODE CONCAT2E(zrleEncode,CPIXEL)
 #define ZRLE_ENCODE_TILE CONCAT2E(zrleEncodeTile,CPIXEL)
 #define BPPOUT 24
 #else
 #define PIXEL_T rdr::CONCAT2E(U,BPP)
-#define WRITE_PIXEL CONCAT2E(writeOpaque,BPP)
+#define WRITE_PIXEL(os, u) os->CONCAT2E(writeOpaque,BPP)(u)
 #define ZRLE_ENCODE CONCAT2E(zrleEncode,BPP)
 #define ZRLE_ENCODE_TILE CONCAT2E(zrleEncodeTile,BPP)
 #define BPPOUT BPP
@@ -129,7 +129,7 @@ void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, rdr::OutStream* os)
 
   if (palette.size() == 1) {
     os->writeU8(1);
-    os->WRITE_PIXEL(palette.getColour(0));
+    WRITE_PIXEL(os, palette.getColour(0));
     return;
   }
 
@@ -176,7 +176,7 @@ void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, rdr::OutStream* os)
   os->writeU8((useRle ? 128 : 0) | palette.size());
 
   for (int i = 0; i < palette.size(); i++) {
-    os->WRITE_PIXEL(palette.getColour(i));
+    WRITE_PIXEL(os, palette.getColour(i));
   }
 
   if (useRle) {
@@ -202,7 +202,7 @@ void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, rdr::OutStream* os)
         int index = palette.lookup(pix);
         os->writeU8(index | 128);
       } else {
-        os->WRITE_PIXEL(pix);
+        WRITE_PIXEL(os, pix);
       }
       len -= 1;
       while (len >= 255) {
@@ -253,7 +253,7 @@ void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, rdr::OutStream* os)
 
 #ifdef CPIXEL
       for (PIXEL_T* ptr = data; ptr < data+w*h; ptr++) {
-        os->WRITE_PIXEL(*ptr);
+        WRITE_PIXEL(os, *ptr);
       }
 #else
       os->writeBytes(data, w*h*(BPP/8));