From: Pierre Ossman <ossman@cendio.se>
Date: Fri, 31 Jan 2014 11:37:32 +0000 (+0100)
Subject: Encoders/decoders should track the connection object
X-Git-Tag: v1.3.90~45^2~6
X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=668468b3d43d5ea1562ebc0be8de0c98c5601a60;p=tigervnc.git

Encoders/decoders should track the connection object

The connection object is a much more appropriate object for the
decoders and encoders to keep track of. Besides the streams, it also
contains state like connection parameters.
---

diff --git a/common/rfb/CMsgReader.cxx b/common/rfb/CMsgReader.cxx
index 37612ea3..04846ef4 100644
--- a/common/rfb/CMsgReader.cxx
+++ b/common/rfb/CMsgReader.cxx
@@ -262,8 +262,3 @@ rdr::U8* CMsgReader::getImageBuf(int required, int requested, int* nPixels)
     *nPixels = imageBufSize / (handler->cp.pf().bpp / 8);
   return imageBuf;
 }
-
-int CMsgReader::bpp()
-{
-  return handler->cp.pf().bpp;
-}
diff --git a/common/rfb/CMsgReader.h b/common/rfb/CMsgReader.h
index 97b57ce7..3592ef87 100644
--- a/common/rfb/CMsgReader.h
+++ b/common/rfb/CMsgReader.h
@@ -47,7 +47,6 @@ namespace rfb {
 
     rdr::InStream* getInStream() { return is; }
     rdr::U8* getImageBuf(int required, int requested=0, int* nPixels=0);
-    int bpp();
 
     int imageBufIdealSize;
 
diff --git a/common/rfb/CMsgWriter.h b/common/rfb/CMsgWriter.h
index fb18cdf7..06ecbe7d 100644
--- a/common/rfb/CMsgWriter.h
+++ b/common/rfb/CMsgWriter.h
@@ -53,9 +53,6 @@ namespace rfb {
 
     void writeFence(rdr::U32 flags, unsigned len, const char data[]);
 
-    ConnParams* getConnParams() { return cp; }
-    rdr::OutStream* getOutStream() { return os; }
-
     // InputHandler implementation
 
     virtual void keyEvent(rdr::U32 key, bool down);
diff --git a/common/rfb/CopyRectDecoder.cxx b/common/rfb/CopyRectDecoder.cxx
index 4c835832..bb3084fd 100644
--- a/common/rfb/CopyRectDecoder.cxx
+++ b/common/rfb/CopyRectDecoder.cxx
@@ -16,14 +16,14 @@
  * USA.
  */
 #include <rdr/InStream.h>
-#include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/PixelBuffer.h>
 #include <rfb/CopyRectDecoder.h>
 
 using namespace rfb;
 
-CopyRectDecoder::CopyRectDecoder(CMsgReader* reader) : Decoder(reader)
+CopyRectDecoder::CopyRectDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -33,7 +33,7 @@ CopyRectDecoder::~CopyRectDecoder()
 
 void CopyRectDecoder::readRect(const Rect& r, CMsgHandler* handler)
 {
-  int srcX = reader->getInStream()->readU16();
-  int srcY = reader->getInStream()->readU16();
+  int srcX = conn->getInStream()->readU16();
+  int srcY = conn->getInStream()->readU16();
   handler->copyRect(r, srcX, srcY);
 }
diff --git a/common/rfb/CopyRectDecoder.h b/common/rfb/CopyRectDecoder.h
index e265ee42..5932066b 100644
--- a/common/rfb/CopyRectDecoder.h
+++ b/common/rfb/CopyRectDecoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class CopyRectDecoder : public Decoder {
   public:
-    CopyRectDecoder(CMsgReader* reader);
+    CopyRectDecoder(CConnection* conn);
     virtual ~CopyRectDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
   };
diff --git a/common/rfb/Decoder.cxx b/common/rfb/Decoder.cxx
index f774f28c..3faa9753 100644
--- a/common/rfb/Decoder.cxx
+++ b/common/rfb/Decoder.cxx
@@ -28,7 +28,7 @@
 
 using namespace rfb;
 
-Decoder::Decoder(CMsgReader* reader_) : reader(reader_)
+Decoder::Decoder(CConnection* conn_) : conn(conn_)
 {
 }
 
@@ -51,21 +51,21 @@ bool Decoder::supported(int encoding)
   }
 }
 
-Decoder* Decoder::createDecoder(int encoding, CMsgReader* reader)
+Decoder* Decoder::createDecoder(int encoding, CConnection* conn)
 {
   switch (encoding) {
   case encodingRaw:
-    return new RawDecoder(reader);
+    return new RawDecoder(conn);
   case encodingCopyRect:
-    return new CopyRectDecoder(reader);
+    return new CopyRectDecoder(conn);
   case encodingRRE:
-    return new RREDecoder(reader);
+    return new RREDecoder(conn);
   case encodingHextile:
-    return new HextileDecoder(reader);
+    return new HextileDecoder(conn);
   case encodingZRLE:
-    return new ZRLEDecoder(reader);
+    return new ZRLEDecoder(conn);
   case encodingTight:
-    return new TightDecoder(reader);
+    return new TightDecoder(conn);
   default:
     return NULL;
   }
diff --git a/common/rfb/Decoder.h b/common/rfb/Decoder.h
index 842491fb..870fa80e 100644
--- a/common/rfb/Decoder.h
+++ b/common/rfb/Decoder.h
@@ -22,19 +22,19 @@
 #include <rfb/Rect.h>
 
 namespace rfb {
-  class CMsgReader;
+  class CConnection;
   class CMsgHandler;
 
   class Decoder {
   public:
-    Decoder(CMsgReader* reader);
+    Decoder(CConnection* conn);
     virtual ~Decoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler)=0;
 
     static bool supported(int encoding);
-    static Decoder* createDecoder(int encoding, CMsgReader* reader);
+    static Decoder* createDecoder(int encoding, CConnection* conn);
   protected:
-    CMsgReader* reader;
+    CConnection* conn;
   };
 }
 
diff --git a/common/rfb/Encoder.cxx b/common/rfb/Encoder.cxx
index 6b2321c4..89a5f149 100644
--- a/common/rfb/Encoder.cxx
+++ b/common/rfb/Encoder.cxx
@@ -25,11 +25,11 @@
 #include <rfb/HextileEncoder.h>
 #include <rfb/ZRLEEncoder.h>
 #include <rfb/TightEncoder.h>
-#include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 
 using namespace rfb;
 
-Encoder::Encoder(SMsgWriter* writer_) : writer(writer_)
+Encoder::Encoder(SConnection *conn_) : conn(conn_)
 {
 }
 
@@ -51,19 +51,19 @@ bool Encoder::supported(int encoding)
   }
 }
 
-Encoder* Encoder::createEncoder(int encoding, SMsgWriter* writer)
+Encoder* Encoder::createEncoder(int encoding, SConnection* conn)
 {
   switch (encoding) {
   case encodingRaw:
-    return new RawEncoder(writer);
+    return new RawEncoder(conn);
   case encodingRRE:
-    return new RREEncoder(writer);
+    return new RREEncoder(conn);
   case encodingHextile:
-    return new HextileEncoder(writer);
+    return new HextileEncoder(conn);
   case encodingZRLE:
-    return new ZRLEEncoder(writer);
+    return new ZRLEEncoder(conn);
   case encodingTight:
-    return new TightEncoder(writer);
+    return new TightEncoder(conn);
   default:
     return NULL;
   }
diff --git a/common/rfb/Encoder.h b/common/rfb/Encoder.h
index 485b850c..2897f9f8 100644
--- a/common/rfb/Encoder.h
+++ b/common/rfb/Encoder.h
@@ -24,12 +24,12 @@
 #include <rfb/TransImageGetter.h>
 
 namespace rfb {
-  class SMsgWriter;
+  class SConnection;
   class TransImageGetter;
 
   class Encoder {
   public:
-    Encoder(SMsgWriter* writer);
+    Encoder(SConnection* conn);
     virtual ~Encoder();
 
     virtual void setCompressLevel(int level) {};
@@ -43,10 +43,10 @@ namespace rfb {
     virtual void writeRect(const Rect& r, TransImageGetter* ig)=0;
 
     static bool supported(int encoding);
-    static Encoder* createEncoder(int encoding, SMsgWriter* writer);
+    static Encoder* createEncoder(int encoding, SConnection* conn);
 
   protected:
-    SMsgWriter* writer;
+    SConnection* conn;
   };
 }
 
diff --git a/common/rfb/HextileDecoder.cxx b/common/rfb/HextileDecoder.cxx
index dbf75c94..9b335fe9 100644
--- a/common/rfb/HextileDecoder.cxx
+++ b/common/rfb/HextileDecoder.cxx
@@ -16,6 +16,7 @@
  * USA.
  */
 #include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/HextileDecoder.h>
 
@@ -31,7 +32,7 @@ using namespace rfb;
 #include <rfb/hextileDecode.h>
 #undef BPP
 
-HextileDecoder::HextileDecoder(CMsgReader* reader) : Decoder(reader)
+HextileDecoder::HextileDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -41,9 +42,9 @@ HextileDecoder::~HextileDecoder()
 
 void HextileDecoder::readRect(const Rect& r, CMsgHandler* handler)
 {
-  rdr::InStream* is = reader->getInStream();
-  rdr::U8* buf = reader->getImageBuf(16 * 16 * 4);
-  switch (reader->bpp()) {
+  rdr::InStream* is = conn->getInStream();
+  rdr::U8* buf = conn->reader()->getImageBuf(16 * 16 * 4);
+  switch (conn->cp.pf().bpp) {
   case 8:  hextileDecode8 (r, is, (rdr::U8*) buf, handler); break;
   case 16: hextileDecode16(r, is, (rdr::U16*)buf, handler); break;
   case 32: hextileDecode32(r, is, (rdr::U32*)buf, handler); break;
diff --git a/common/rfb/HextileDecoder.h b/common/rfb/HextileDecoder.h
index 287b49d5..67dc791a 100644
--- a/common/rfb/HextileDecoder.h
+++ b/common/rfb/HextileDecoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class HextileDecoder : public Decoder {
   public:
-    HextileDecoder(CMsgReader* reader);
+    HextileDecoder(CConnection* conn);
     virtual ~HextileDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
   };
diff --git a/common/rfb/HextileEncoder.cxx b/common/rfb/HextileEncoder.cxx
index 69b522f8..aa1b218a 100644
--- a/common/rfb/HextileEncoder.cxx
+++ b/common/rfb/HextileEncoder.cxx
@@ -19,6 +19,7 @@
 #include <rfb/TransImageGetter.h>
 #include <rfb/encodings.h>
 #include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 #include <rfb/HextileEncoder.h>
 #include <rfb/Configuration.h>
 
@@ -43,7 +44,7 @@ BoolParameter improvedHextile("ImprovedHextile",
 #include <rfb/hextileEncodeBetter.h>
 #undef BPP
 
-HextileEncoder::HextileEncoder(SMsgWriter* writer_) : Encoder(writer_)
+HextileEncoder::HextileEncoder(SConnection* conn) : Encoder(conn)
 {
 }
 
@@ -53,9 +54,9 @@ HextileEncoder::~HextileEncoder()
 
 void HextileEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
-  writer->startRect(r, encodingHextile);
-  rdr::OutStream* os = writer->getOutStream();
-  switch (writer->bpp()) {
+  conn->writer()->startRect(r, encodingHextile);
+  rdr::OutStream* os = conn->getOutStream();
+  switch (conn->cp.pf().bpp) {
   case 8:
     if (improvedHextile) {
       hextileEncodeBetter8(r, os, ig);
@@ -78,5 +79,5 @@ void HextileEncoder::writeRect(const Rect& r, TransImageGetter* ig)
     }
     break;
   }
-  writer->endRect();
+  conn->writer()->endRect();
 }
diff --git a/common/rfb/HextileEncoder.h b/common/rfb/HextileEncoder.h
index 705cbc6f..723f5391 100644
--- a/common/rfb/HextileEncoder.h
+++ b/common/rfb/HextileEncoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class HextileEncoder : public Encoder {
   public:
-    HextileEncoder(SMsgWriter* writer);
+    HextileEncoder(SConnection* conn);
     virtual ~HextileEncoder();
     virtual void writeRect(const Rect& r, TransImageGetter* ig);
   };
diff --git a/common/rfb/RREDecoder.cxx b/common/rfb/RREDecoder.cxx
index b7808421..ecc97136 100644
--- a/common/rfb/RREDecoder.cxx
+++ b/common/rfb/RREDecoder.cxx
@@ -16,6 +16,7 @@
  * USA.
  */
 #include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/RREDecoder.h>
 
@@ -31,7 +32,7 @@ using namespace rfb;
 #include <rfb/rreDecode.h>
 #undef BPP
 
-RREDecoder::RREDecoder(CMsgReader* reader) : Decoder(reader)
+RREDecoder::RREDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -41,8 +42,8 @@ RREDecoder::~RREDecoder()
 
 void RREDecoder::readRect(const Rect& r, CMsgHandler* handler)
 {
-  rdr::InStream* is = reader->getInStream();
-  switch (reader->bpp()) {
+  rdr::InStream* is = conn->getInStream();
+  switch (conn->cp.pf().bpp) {
   case 8:  rreDecode8 (r, is, handler); break;
   case 16: rreDecode16(r, is, handler); break;
   case 32: rreDecode32(r, is, handler); break;
diff --git a/common/rfb/RREDecoder.h b/common/rfb/RREDecoder.h
index bee634fb..7b6cc458 100644
--- a/common/rfb/RREDecoder.h
+++ b/common/rfb/RREDecoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class RREDecoder : public Decoder {
   public:
-    RREDecoder(CMsgReader* reader);
+    RREDecoder(CConnection* conn);
     virtual ~RREDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
   };
diff --git a/common/rfb/RREEncoder.cxx b/common/rfb/RREEncoder.cxx
index dc2d74ed..a7af25db 100644
--- a/common/rfb/RREEncoder.cxx
+++ b/common/rfb/RREEncoder.cxx
@@ -19,6 +19,7 @@
 #include <rfb/TransImageGetter.h>
 #include <rfb/encodings.h>
 #include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 #include <rfb/RREEncoder.h>
 
 using namespace rfb;
@@ -33,7 +34,7 @@ using namespace rfb;
 #include <rfb/rreEncode.h>
 #undef BPP
 
-RREEncoder::RREEncoder(SMsgWriter* writer) : RawEncoder(writer)
+RREEncoder::RREEncoder(SConnection* conn) : RawEncoder(conn)
 {
 }
 
@@ -45,13 +46,13 @@ void RREEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
   int w = r.width();
   int h = r.height();
-  rdr::U8* imageBuf = writer->getImageBuf(w*h);
+  rdr::U8* imageBuf = conn->writer()->getImageBuf(w*h);
   ig->getImage(imageBuf, r);
 
   mos.clear();
 
   int nSubrects = -1;
-  switch (writer->bpp()) {
+  switch (conn->cp.pf().bpp) {
   case 8:  nSubrects = rreEncode8(imageBuf, w, h, &mos);  break;
   case 16: nSubrects = rreEncode16(imageBuf, w, h, &mos); break;
   case 32: nSubrects = rreEncode32(imageBuf, w, h, &mos); break;
@@ -62,9 +63,9 @@ void RREEncoder::writeRect(const Rect& r, TransImageGetter* ig)
     return;
   }
 
-  writer->startRect(r, encodingRRE);
-  rdr::OutStream* os = writer->getOutStream();
+  conn->writer()->startRect(r, encodingRRE);
+  rdr::OutStream* os = conn->getOutStream();
   os->writeU32(nSubrects);
   os->writeBytes(mos.data(), mos.length());
-  writer->endRect();
+  conn->writer()->endRect();
 }
diff --git a/common/rfb/RREEncoder.h b/common/rfb/RREEncoder.h
index b263967e..487344f2 100644
--- a/common/rfb/RREEncoder.h
+++ b/common/rfb/RREEncoder.h
@@ -25,7 +25,7 @@ namespace rfb {
 
   class RREEncoder : public RawEncoder {
   public:
-    RREEncoder(SMsgWriter* writer);
+    RREEncoder(SConnection* conn);
     virtual ~RREEncoder();
     virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
diff --git a/common/rfb/RawDecoder.cxx b/common/rfb/RawDecoder.cxx
index eab92e53..6ca02026 100644
--- a/common/rfb/RawDecoder.cxx
+++ b/common/rfb/RawDecoder.cxx
@@ -17,12 +17,13 @@
  */
 #include <rdr/InStream.h>
 #include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/RawDecoder.h>
 
 using namespace rfb;
 
-RawDecoder::RawDecoder(CMsgReader* reader) : Decoder(reader)
+RawDecoder::RawDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -37,12 +38,12 @@ void RawDecoder::readRect(const Rect& r, CMsgHandler* handler)
   int w = r.width();
   int h = r.height();
   int nPixels;
-  rdr::U8* imageBuf = reader->getImageBuf(w, w*h, &nPixels);
-  int bytesPerRow = w * (reader->bpp() / 8);
+  rdr::U8* imageBuf = conn->reader()->getImageBuf(w, w*h, &nPixels);
+  int bytesPerRow = w * (conn->cp.pf().bpp / 8);
   while (h > 0) {
     int nRows = nPixels / w;
     if (nRows > h) nRows = h;
-    reader->getInStream()->readBytes(imageBuf, nRows * bytesPerRow);
+    conn->getInStream()->readBytes(imageBuf, nRows * bytesPerRow);
     handler->imageRect(Rect(x, y, x+w, y+nRows), imageBuf);
     h -= nRows;
     y += nRows;
diff --git a/common/rfb/RawDecoder.h b/common/rfb/RawDecoder.h
index 9d0dc300..ca7c4017 100644
--- a/common/rfb/RawDecoder.h
+++ b/common/rfb/RawDecoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class RawDecoder : public Decoder {
   public:
-    RawDecoder(CMsgReader* reader);
+    RawDecoder(CConnection* conn);
     virtual ~RawDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
   };
diff --git a/common/rfb/RawEncoder.cxx b/common/rfb/RawEncoder.cxx
index 2fc5741c..f7a4f3b8 100644
--- a/common/rfb/RawEncoder.cxx
+++ b/common/rfb/RawEncoder.cxx
@@ -19,11 +19,12 @@
 #include <rfb/TransImageGetter.h>
 #include <rfb/encodings.h>
 #include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 #include <rfb/RawEncoder.h>
 
 using namespace rfb;
 
-RawEncoder::RawEncoder(SMsgWriter* writer) : Encoder(writer)
+RawEncoder::RawEncoder(SConnection* conn) : Encoder(conn)
 {
 }
 
@@ -38,16 +39,16 @@ void RawEncoder::writeRect(const Rect& r, TransImageGetter* ig)
   int w = r.width();
   int h = r.height();
   int nPixels;
-  rdr::U8* imageBuf = writer->getImageBuf(w, w*h, &nPixels);
-  int bytesPerRow = w * (writer->bpp() / 8);
-  writer->startRect(r, encodingRaw);
+  rdr::U8* imageBuf = conn->writer()->getImageBuf(w, w*h, &nPixels);
+  int bytesPerRow = w * (conn->cp.pf().bpp / 8);
+  conn->writer()->startRect(r, encodingRaw);
   while (h > 0) {
     int nRows = nPixels / w;
     if (nRows > h) nRows = h;
     ig->getImage(imageBuf, Rect(x, y, x+w, y+nRows));
-    writer->getOutStream()->writeBytes(imageBuf, nRows * bytesPerRow);
+    conn->getOutStream()->writeBytes(imageBuf, nRows * bytesPerRow);
     h -= nRows;
     y += nRows;
   }
-  writer->endRect();
+  conn->writer()->endRect();
 }
diff --git a/common/rfb/RawEncoder.h b/common/rfb/RawEncoder.h
index 42d38508..59e3a6de 100644
--- a/common/rfb/RawEncoder.h
+++ b/common/rfb/RawEncoder.h
@@ -24,7 +24,7 @@ namespace rfb {
 
   class RawEncoder : public Encoder {
   public:
-    RawEncoder(SMsgWriter* writer);
+    RawEncoder(SConnection* conn);
     virtual ~RawEncoder();
     virtual void writeRect(const Rect& r, TransImageGetter* ig);
   };
diff --git a/common/rfb/SMsgWriter.cxx b/common/rfb/SMsgWriter.cxx
index 67590fe6..40e6d7f6 100644
--- a/common/rfb/SMsgWriter.cxx
+++ b/common/rfb/SMsgWriter.cxx
@@ -320,7 +320,7 @@ void SMsgWriter::startRect(const Rect& r, int encoding)
   currentEncoding = encoding;
   lenBeforeRect = os->length();
   if (encoding != encodingCopyRect)
-    rawBytesEquivalent += 12 + r.width() * r.height() * (bpp()/8);
+    rawBytesEquivalent += 12 + r.width() * r.height() * (cp->pf().bpp/8);
 
   os->writeS16(r.tl.x);
   os->writeS16(r.tl.y);
@@ -357,11 +357,6 @@ rdr::U8* SMsgWriter::getImageBuf(int required, int requested, int* nPixels)
   return imageBuf;
 }
 
-int SMsgWriter::bpp()
-{
-  return cp->pf().bpp;
-}
-
 void SMsgWriter::startMsg(int type)
 {
   os->writeU8(type);
diff --git a/common/rfb/SMsgWriter.h b/common/rfb/SMsgWriter.h
index ccc8f803..c3ee4577 100644
--- a/common/rfb/SMsgWriter.h
+++ b/common/rfb/SMsgWriter.h
@@ -120,10 +120,7 @@ namespace rfb {
     void startRect(const Rect& r, int enc);
     void endRect();
 
-    ConnParams* getConnParams() { return cp; }
-    rdr::OutStream* getOutStream() { return os; }
     rdr::U8* getImageBuf(int required, int requested=0, int* nPixels=0);
-    int bpp();
 
     int getUpdatesSent()           { return updatesSent; }
     int getRectsSent(int encoding) { return rectsSent[encoding]; }
diff --git a/common/rfb/TightDecoder.cxx b/common/rfb/TightDecoder.cxx
index a317d250..bfc3352b 100644
--- a/common/rfb/TightDecoder.cxx
+++ b/common/rfb/TightDecoder.cxx
@@ -18,6 +18,7 @@
  * USA.
  */
 #include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/TightDecoder.h>
 
@@ -35,7 +36,7 @@ using namespace rfb;
 #include <rfb/tightDecode.h>
 #undef BPP
 
-TightDecoder::TightDecoder(CMsgReader* reader) : Decoder(reader)
+TightDecoder::TightDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -45,7 +46,7 @@ TightDecoder::~TightDecoder()
 
 void TightDecoder::readRect(const Rect& r, CMsgHandler* handler)
 {
-  is = reader->getInStream();
+  is = conn->getInStream();
   this->handler = handler;
   clientpf = handler->getPreferredPF();
   serverpf = handler->cp.pf();
diff --git a/common/rfb/TightDecoder.h b/common/rfb/TightDecoder.h
index 18b01f8a..2ca4ecd6 100644
--- a/common/rfb/TightDecoder.h
+++ b/common/rfb/TightDecoder.h
@@ -28,7 +28,7 @@ namespace rfb {
   class TightDecoder : public Decoder {
 
   public:
-    TightDecoder(CMsgReader* reader);
+    TightDecoder(CConnection* conn);
     virtual ~TightDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
 
diff --git a/common/rfb/TightEncoder.cxx b/common/rfb/TightEncoder.cxx
index 800d3316..c3f87dab 100644
--- a/common/rfb/TightEncoder.cxx
+++ b/common/rfb/TightEncoder.cxx
@@ -22,6 +22,7 @@
 #include <rfb/encodings.h>
 #include <rfb/ConnParams.h>
 #include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 #include <rfb/TightEncoder.h>
 
 using namespace rfb;
@@ -93,7 +94,7 @@ const int TightEncoder::defaultCompressLevel = 2;
 #include <rfb/tightEncode.h>
 #undef BPP
 
-TightEncoder::TightEncoder(SMsgWriter* writer) : Encoder(writer)
+TightEncoder::TightEncoder(SConnection* conn) : Encoder(conn)
 {
   setCompressLevel(defaultCompressLevel);
   setQualityLevel(-1);
@@ -226,7 +227,7 @@ void TightEncoder::extendSolidArea(const Rect& r, rdr::U32 colorValue,
 
 int TightEncoder::getNumRects(const Rect &r)
 {
-  ConnParams* cp = writer->getConnParams();
+  ConnParams* cp = &conn->cp;
   const unsigned int w = r.width();
   const unsigned int h = r.height();
 
@@ -290,7 +291,7 @@ void TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig)
 {
   ig = _ig;
   serverpf = ig->getPixelBuffer()->getPF();
-  ConnParams* cp = writer->getConnParams();
+  ConnParams* cp = &conn->cp;
   clientpf = cp->pf();
 
   // Shortcuts to rectangle coordinates and dimensions.
@@ -405,10 +406,10 @@ void TightEncoder::writeSubrect(const Rect& r, bool forceSolid)
     tightEncode32(r, &mos, forceSolid); break;
   }
 
-  writer->startRect(r, encodingTight);
-  rdr::OutStream* os = writer->getOutStream();
+  conn->writer()->startRect(r, encodingTight);
+  rdr::OutStream* os = conn->getOutStream();
   os->writeBytes(mos.data(), mos.length());
-  writer->endRect();
+  conn->writer()->endRect();
 }
 
 void TightEncoder::writeCompact(rdr::OutStream* os, rdr::U32 value)
diff --git a/common/rfb/TightEncoder.h b/common/rfb/TightEncoder.h
index b633512f..8a58985e 100644
--- a/common/rfb/TightEncoder.h
+++ b/common/rfb/TightEncoder.h
@@ -58,7 +58,7 @@ namespace rfb {
   
   class TightEncoder : public Encoder {
   public:
-    TightEncoder(SMsgWriter* writer);
+    TightEncoder(SConnection* conn);
     virtual ~TightEncoder();
 
     virtual void setCompressLevel(int level);
diff --git a/common/rfb/VNCSConnectionST.cxx b/common/rfb/VNCSConnectionST.cxx
index 0000c1ea..a4b704a4 100644
--- a/common/rfb/VNCSConnectionST.cxx
+++ b/common/rfb/VNCSConnectionST.cxx
@@ -1074,7 +1074,7 @@ void VNCSConnectionST::writeFramebufferUpdate()
     encoding = cp.currentEncoding();
 
     if (!encoders[encoding])
-      encoders[encoding] = Encoder::createEncoder(encoding, writer());
+      encoders[encoding] = Encoder::createEncoder(encoding, this);
 
     encoders[encoding]->setCompressLevel(cp.compressLevel);
     encoders[encoding]->setQualityLevel(cp.qualityLevel);
diff --git a/common/rfb/ZRLEDecoder.cxx b/common/rfb/ZRLEDecoder.cxx
index d4d3444d..7e933a8f 100644
--- a/common/rfb/ZRLEDecoder.cxx
+++ b/common/rfb/ZRLEDecoder.cxx
@@ -16,6 +16,7 @@
  * USA.
  */
 #include <rfb/CMsgReader.h>
+#include <rfb/CConnection.h>
 #include <rfb/CMsgHandler.h>
 #include <rfb/ZRLEDecoder.h>
 
@@ -57,7 +58,7 @@ static inline rdr::U32 readOpaque24B(rdr::InStream* is)
 #undef CPIXEL
 #undef BPP
 
-ZRLEDecoder::ZRLEDecoder(CMsgReader* reader) : Decoder(reader)
+ZRLEDecoder::ZRLEDecoder(CConnection* conn) : Decoder(conn)
 {
 }
 
@@ -67,9 +68,9 @@ ZRLEDecoder::~ZRLEDecoder()
 
 void ZRLEDecoder::readRect(const Rect& r, CMsgHandler* handler)
 {
-  rdr::InStream* is = reader->getInStream();
-  rdr::U8* buf = reader->getImageBuf(64 * 64 * 4);
-  switch (reader->bpp()) {
+  rdr::InStream* is = conn->getInStream();
+  rdr::U8* buf = conn->reader()->getImageBuf(64 * 64 * 4);
+  switch (conn->cp.pf().bpp) {
   case 8:  zrleDecode8 (r, is, &zis, (rdr::U8*) buf, handler); break;
   case 16: zrleDecode16(r, is, &zis, (rdr::U16*)buf, handler); break;
   case 32:
diff --git a/common/rfb/ZRLEDecoder.h b/common/rfb/ZRLEDecoder.h
index dee20685..e7e2b8cb 100644
--- a/common/rfb/ZRLEDecoder.h
+++ b/common/rfb/ZRLEDecoder.h
@@ -25,7 +25,7 @@ namespace rfb {
 
   class ZRLEDecoder : public Decoder {
   public:
-    ZRLEDecoder(CMsgReader* reader);
+    ZRLEDecoder(CConnection* conn);
     virtual ~ZRLEDecoder();
     virtual void readRect(const Rect& r, CMsgHandler* handler);
   private:
diff --git a/common/rfb/ZRLEEncoder.cxx b/common/rfb/ZRLEEncoder.cxx
index 5a65703d..968edcfb 100644
--- a/common/rfb/ZRLEEncoder.cxx
+++ b/common/rfb/ZRLEEncoder.cxx
@@ -21,6 +21,7 @@
 #include <rfb/encodings.h>
 #include <rfb/ConnParams.h>
 #include <rfb/SMsgWriter.h>
+#include <rfb/SConnection.h>
 #include <rfb/ZRLEEncoder.h>
 #include <rfb/Configuration.h>
 
@@ -59,8 +60,8 @@ static inline void writeOpaque24B(rdr::OutStream* os, rdr::U32 u)
 #undef CPIXEL
 #undef BPP
 
-ZRLEEncoder::ZRLEEncoder(SMsgWriter* writer)
-  : Encoder(writer), zos(0,0,zlibLevel), mos(129*1024)
+ZRLEEncoder::ZRLEEncoder(SConnection* conn)
+  : Encoder(conn), zos(0,0,zlibLevel), mos(129*1024)
 {
 }
 
@@ -70,10 +71,10 @@ ZRLEEncoder::~ZRLEEncoder()
 
 void ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
-  rdr::U8* imageBuf = writer->getImageBuf(64 * 64 * 4 + 4);
+  rdr::U8* imageBuf = conn->writer()->getImageBuf(64 * 64 * 4 + 4);
   mos.clear();
 
-  switch (writer->bpp()) {
+  switch (conn->cp.pf().bpp) {
   case 8:
     zrleEncode8(r, &mos, &zos, imageBuf, ig);
     break;
@@ -82,7 +83,7 @@ void ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig)
     break;
   case 32:
     {
-      const PixelFormat& pf = writer->getConnParams()->pf();
+      const PixelFormat& pf = conn->cp.pf();
 
       Pixel maxPixel = pf.pixelFromRGB((rdr::U16)-1, (rdr::U16)-1, (rdr::U16)-1);
       bool fitsInLS3Bytes = maxPixel < (1<<24);
@@ -106,9 +107,9 @@ void ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig)
     }
   }
 
-  writer->startRect(r, encodingZRLE);
-  rdr::OutStream* os = writer->getOutStream();
+  conn->writer()->startRect(r, encodingZRLE);
+  rdr::OutStream* os = conn->getOutStream();
   os->writeU32(mos.length());
   os->writeBytes(mos.data(), mos.length());
-  writer->endRect();
+  conn->writer()->endRect();
 }
diff --git a/common/rfb/ZRLEEncoder.h b/common/rfb/ZRLEEncoder.h
index 9679887a..d285967e 100644
--- a/common/rfb/ZRLEEncoder.h
+++ b/common/rfb/ZRLEEncoder.h
@@ -26,7 +26,7 @@ namespace rfb {
 
   class ZRLEEncoder : public Encoder {
   public:
-    ZRLEEncoder(SMsgWriter* writer);
+    ZRLEEncoder(SConnection* conn);
     virtual ~ZRLEEncoder();
     virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
diff --git a/common/rfb/tightDecode.h b/common/rfb/tightDecode.h
index 1c7cf5e5..a5963119 100644
--- a/common/rfb/tightDecode.h
+++ b/common/rfb/tightDecode.h
@@ -154,7 +154,7 @@ void TIGHT_DECODE (const Rect& r)
   PIXEL_T *buf;
   int stride = r.width();
   if (directDecode) buf = (PIXEL_T *)handler->getRawBufferRW(r, &stride);
-  else buf = (PIXEL_T *)reader->getImageBuf(r.area());
+  else buf = (PIXEL_T *)conn->reader()->getImageBuf(r.area());
 
   if (palSize == 0) {
     // Truecolor data
diff --git a/common/rfb/tightEncode.h b/common/rfb/tightEncode.h
index 3f0647de..5d32cce3 100644
--- a/common/rfb/tightEncode.h
+++ b/common/rfb/tightEncode.h
@@ -147,14 +147,14 @@ void TIGHT_ENCODE (const Rect& r, rdr::OutStream *os, bool forceSolid)
       // JPEG can read from the raw buffer, but for the other methods, we need
       // to translate the raw pixels into an intermediate buffer.
       if(palette.size() != 0 || jpegQuality == -1) {
-        pixels = (PIXEL_T *)writer->getImageBuf(r.area());
+        pixels = (PIXEL_T *)conn->writer()->getImageBuf(r.area());
         stride = r.width();
         ig->getImage(pixels, r);
       }
     } else {
       // Pixel translation will be required, so create an intermediate buffer,
       // translate the raw pixels into it, and count its colors.
-      pixels = (PIXEL_T *)writer->getImageBuf(r.area());
+      pixels = (PIXEL_T *)conn->writer()->getImageBuf(r.area());
       stride = r.width();
       ig->getImage(pixels, r);
 
diff --git a/vncviewer/CConn.cxx b/vncviewer/CConn.cxx
index f5420629..db1a08a5 100644
--- a/vncviewer/CConn.cxx
+++ b/vncviewer/CConn.cxx
@@ -399,7 +399,7 @@ void CConn::dataRect(const Rect& r, int encoding)
   }
 
   if (!decoders[encoding]) {
-    decoders[encoding] = Decoder::createDecoder(encoding, reader());
+    decoders[encoding] = Decoder::createDecoder(encoding, this);
     if (!decoders[encoding]) {
       fprintf(stderr, "Unknown rect encoding %d\n", encoding);
       throw Exception("Unknown rect encoding");