Remove partial update functionality

Get rid of the ability of encoders to only send part of the
rectangle they are given as we don't want partial updates
anyway.

diff --git a/common/rfb/Encoder.h b/common/rfb/Encoder.h
index 26d579630fbdacac0cf7acf62e1767a638b526fc..8712c09ade2a2122a500de2c195e7c5d121ef768 100644 (file)
--- a/common/rfb/Encoder.h
+++ b/common/rfb/Encoder.h
@@ -36,11 +36,10 @@ namespace rfb {
     virtual void setFineQualityLevel(int quality, int subsampling) {};
     virtual int getNumRects(const Rect &r) { return 1; }
 
-    // writeRect() tries to write the given rectangle.  If it is unable to
-    // write the whole rectangle it returns false and sets actual to the actual
-    // rectangle which was updated.
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig,
-                           Rect* actual)=0;
+    // writeRect() is the main interface that encodes the given rectangle
+    // with data from the ImageGetter onto the SMsgWriter given at
+    // encoder creation.
+    virtual void writeRect(const Rect& r, TransImageGetter* ig)=0;
 
     static bool supported(int encoding);
     static Encoder* createEncoder(int encoding, SMsgWriter* writer);

diff --git a/common/rfb/HextileEncoder.cxx b/common/rfb/HextileEncoder.cxx
index 0907bab8c4fddf4b420545dd3098cfb12fd2436c..19fb1a3effb6fa5f79e3a38a9b16272683788120 100644 (file)
--- a/common/rfb/HextileEncoder.cxx
+++ b/common/rfb/HextileEncoder.cxx
@@ -53,8 +53,7 @@ HextileEncoder::~HextileEncoder()
 {
 }
 
-bool HextileEncoder::writeRect(const Rect& r, TransImageGetter* ig,
-                               Rect* actual)
+void HextileEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
   writer->startRect(r, encodingHextile);
   rdr::OutStream* os = writer->getOutStream();
@@ -82,5 +81,4 @@ bool HextileEncoder::writeRect(const Rect& r, TransImageGetter* ig,
     break;
   }
   writer->endRect();
-  return true;
 }

diff --git a/common/rfb/HextileEncoder.h b/common/rfb/HextileEncoder.h
index 0c475a8e6e7868e99ab8b4274a50c1eec00488e6..5540c642f7b3bb2687d9574523a5f2390b1afd97 100644 (file)
--- a/common/rfb/HextileEncoder.h
+++ b/common/rfb/HextileEncoder.h
@@ -26,7 +26,7 @@ namespace rfb {
   public:
     HextileEncoder(SMsgWriter* writer);
     virtual ~HextileEncoder();
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
+    virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
     SMsgWriter* writer;
   };

diff --git a/common/rfb/RREEncoder.cxx b/common/rfb/RREEncoder.cxx
index 36d4695514003ad8cf1a92d89b06bede51d79720..09702cf7fe2c918c0f2654c9a922c9c3d972fd77 100644 (file)
--- a/common/rfb/RREEncoder.cxx
+++ b/common/rfb/RREEncoder.cxx
@@ -41,7 +41,7 @@ RREEncoder::~RREEncoder()
 {
 }
 
-bool RREEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
+void RREEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
   int w = r.width();
   int h = r.height();
@@ -58,7 +58,8 @@ bool RREEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
   }
   
   if (nSubrects < 0) {
-    return writer->writeRect(r, encodingRaw, ig, actual);
+    writer->writeRect(r, encodingRaw, ig);
+    return;
   }
 
   writer->startRect(r, encodingRRE);
@@ -66,5 +67,4 @@ bool RREEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
   os->writeU32(nSubrects);
   os->writeBytes(mos.data(), mos.length());
   writer->endRect();
-  return true;
 }

diff --git a/common/rfb/RREEncoder.h b/common/rfb/RREEncoder.h
index f7d576ebcd759b45961a49a1e800e5a5d15fde89..4b990f5b7d6ee0c7643865708d0fff3fefc0e35b 100644 (file)
--- a/common/rfb/RREEncoder.h
+++ b/common/rfb/RREEncoder.h
@@ -27,7 +27,7 @@ namespace rfb {
   public:
     RREEncoder(SMsgWriter* writer);
     virtual ~RREEncoder();
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
+    virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
     SMsgWriter* writer;
     rdr::MemOutStream mos;

diff --git a/common/rfb/RawEncoder.cxx b/common/rfb/RawEncoder.cxx
index 4b8de6ba2ce255ace2f96855a84a1f9d245f2449..b4e38dbf07d1b405140a6b4811c5570a3421b044 100644 (file)
--- a/common/rfb/RawEncoder.cxx
+++ b/common/rfb/RawEncoder.cxx
@@ -31,7 +31,7 @@ RawEncoder::~RawEncoder()
 {
 }
 
-bool RawEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
+void RawEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
   int x = r.tl.x;
   int y = r.tl.y;
@@ -50,5 +50,4 @@ bool RawEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
     y += nRows;
   }
   writer->endRect();
-  return true;
 }

diff --git a/common/rfb/RawEncoder.h b/common/rfb/RawEncoder.h
index 22d45dbf1a3078e5980c529bb574363c2ba7dd39..628f32fdade043a0b4a20c90211d8b86ce9d3560 100644 (file)
--- a/common/rfb/RawEncoder.h
+++ b/common/rfb/RawEncoder.h
@@ -26,7 +26,7 @@ namespace rfb {
   public:
     RawEncoder(SMsgWriter* writer);
     virtual ~RawEncoder();
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
+    virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
     SMsgWriter* writer;
   };

diff --git a/common/rfb/SMsgWriter.cxx b/common/rfb/SMsgWriter.cxx
index 2a31f03e094ca5ff374b354d668c06f6248f7004..615eaa9315bf2eb4366a31684c3ac030d23e949e 100644 (file)
--- a/common/rfb/SMsgWriter.cxx
+++ b/common/rfb/SMsgWriter.cxx
@@ -291,26 +291,18 @@ void SMsgWriter::writeNoDataUpdate()
   writeFramebufferUpdateEnd();
 }
 
-void SMsgWriter::writeRects(const UpdateInfo& ui, TransImageGetter* ig,
-                            Region* updatedRegion)
+void SMsgWriter::writeRects(const UpdateInfo& ui, TransImageGetter* ig)
 {
   std::vector<Rect> rects;
   std::vector<Rect>::const_iterator i;
-  updatedRegion->copyFrom(ui.changed);
-  updatedRegion->assign_union(ui.copied);
 
   ui.copied.get_rects(&rects, ui.copy_delta.x <= 0, ui.copy_delta.y <= 0);
   for (i = rects.begin(); i != rects.end(); i++)
     writeCopyRect(*i, i->tl.x - ui.copy_delta.x, i->tl.y - ui.copy_delta.y);
 
   ui.changed.get_rects(&rects);
-  for (i = rects.begin(); i != rects.end(); i++) {
-    Rect actual;
-    if (!writeRect(*i, ig, &actual)) {
-      updatedRegion->assign_subtract(*i);
-      updatedRegion->assign_union(actual);
-    }
-  }
+  for (i = rects.begin(); i != rects.end(); i++)
+    writeRect(*i, ig);
 }
 
 void SMsgWriter::writeFramebufferUpdateStart(int nRects)
@@ -355,19 +347,18 @@ void SMsgWriter::writeFramebufferUpdateEnd()
   endMsg();
 }
 
-bool SMsgWriter::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
+void SMsgWriter::writeRect(const Rect& r, TransImageGetter* ig)
 {
-  return writeRect(r, cp->currentEncoding(), ig, actual);
+  writeRect(r, cp->currentEncoding(), ig);
 }
 
-bool SMsgWriter::writeRect(const Rect& r, int encoding,
-                           TransImageGetter* ig, Rect* actual)
+void SMsgWriter::writeRect(const Rect& r, int encoding, TransImageGetter* ig)
 {
   if (!encoders[encoding]) {
     encoders[encoding] = Encoder::createEncoder(encoding, this);
     assert(encoders[encoding]);
   }
-  return encoders[encoding]->writeRect(r, ig, actual);
+  encoders[encoding]->writeRect(r, ig);
 }
 
 void SMsgWriter::writeCopyRect(const Rect& r, int srcX, int srcY)

diff --git a/common/rfb/SMsgWriter.h b/common/rfb/SMsgWriter.h
index 01141af342ce95b31057caa8c6a2b2ec1d886b36..5d45411dd27dc5b3ac5d7ff7a404ef9236707a7a 100644 (file)
--- a/common/rfb/SMsgWriter.h
+++ b/common/rfb/SMsgWriter.h
@@ -122,10 +122,8 @@ namespace rfb {
     // ImageGetter to fetch pixels from.  It then calls writeCopyRect() and
     // writeRect() as appropriate.  writeFramebufferUpdateStart() must be used
     // before the first writeRects() call and writeFrameBufferUpdateEnd() after
-    // the last one.  It returns the actual region sent to the client, which
-    // may be smaller than the update passed in.
-    void writeRects(const UpdateInfo& update, TransImageGetter* ig,
-                    Region* updatedRegion);
+    // the last one.
+    void writeRects(const UpdateInfo& update, TransImageGetter* ig);
 
     // To construct a framebuffer update you can call
     // writeFramebufferUpdateStart(), followed by a number of writeCopyRect()s
@@ -133,12 +131,10 @@ namespace rfb {
     void writeFramebufferUpdateStart(int nRects);
     void writeFramebufferUpdateEnd();
 
-    // writeRect() tries to write the given rectangle.  If it is unable to
-    // write the whole rectangle it returns false and sets actual to the actual
-    // rectangle which was updated.
-    bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
-    bool writeRect(const Rect& r, int encoding,
-                   TransImageGetter* ig, Rect* actual);
+    // writeRect() writers the given rectangle using either the preferred
+    // encoder, or the one explicitly given.
+    void writeRect(const Rect& r, TransImageGetter* ig);
+    void writeRect(const Rect& r, int encoding, TransImageGetter* ig);
 
     void writeCopyRect(const Rect& r, int srcX, int srcY);
 

diff --git a/common/rfb/TightEncoder.cxx b/common/rfb/TightEncoder.cxx
index 1cff7a604b4b8f06d91136753221cb0e655b8d96..f4633f88b93e30a4d4d159d59fdd184a357f4930 100644 (file)
--- a/common/rfb/TightEncoder.cxx
+++ b/common/rfb/TightEncoder.cxx
@@ -286,8 +286,7 @@ void TightEncoder::sendRectSimple(const Rect& r)
   }
 }
 
-bool TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig,
-                             Rect* actual)
+void TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig)
 {
   ig = _ig;
   serverpf = ig->getPixelBuffer()->getPF();
@@ -304,7 +303,7 @@ bool TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig,
   // Encode small rects as is.
   if (!cp->supportsLastRect || w * h < TIGHT_MIN_SPLIT_RECT_SIZE) {
     sendRectSimple(r);
-    return true;
+    return;
   }
 
   // Split big rects into separately encoded subrects.
@@ -366,7 +365,7 @@ bool TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig,
         }
         if (bestr.tl.x != x) {
           sr.setXYWH(x, bestr.tl.y, bestr.tl.x - x, bestr.height());
-          writeRect(sr, _ig, NULL);
+          writeRect(sr, _ig);
         }
 
         // Send solid-color rectangle.
@@ -376,21 +375,21 @@ bool TightEncoder::writeRect(const Rect& _r, TransImageGetter* _ig,
         if (bestr.br.x != r.br.x) {
           sr.setXYWH(bestr.br.x, bestr.tl.y, r.br.x - bestr.br.x,
             bestr.height());
-          writeRect(sr, _ig, NULL);
+          writeRect(sr, _ig);
         }
         if (bestr.br.y != r.br.y) {
           sr.setXYWH(x, bestr.br.y, w, r.br.y - bestr.br.y);
-          writeRect(sr, _ig, NULL);
+          writeRect(sr, _ig);
         }
 
-        return true;
+        return;
       }
     }
   }
 
   // No suitable solid-color rectangles found.
   sendRectSimple(r);
-  return true;
+  return;
 }
 
 void TightEncoder::writeSubrect(const Rect& r, bool forceSolid)

diff --git a/common/rfb/TightEncoder.h b/common/rfb/TightEncoder.h
index 3632539dddbf060f91a449b596e3dc3eb55724cf..a499783d08b61c458cd8dc859ecbcbcfe2ed94d2 100644 (file)
--- a/common/rfb/TightEncoder.h
+++ b/common/rfb/TightEncoder.h
@@ -86,7 +86,7 @@ namespace rfb {
     virtual void setQualityLevel(int level);
     virtual void setFineQualityLevel(int quality, int subsampling);
     virtual int getNumRects(const Rect &r);
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
+    virtual void writeRect(const Rect& r, TransImageGetter* ig);
 
   private:
     bool checkSolidTile(Rect& r, rdr::U32* colorPtr, bool needSameColor);

diff --git a/common/rfb/VNCSConnectionST.cxx b/common/rfb/VNCSConnectionST.cxx
index 381ee21614ff1bd429e27a53865016bca76005cd..9b6b594bd7a3916fcbb66b7991702ae91bb98a3e 100644 (file)
--- a/common/rfb/VNCSConnectionST.cxx
+++ b/common/rfb/VNCSConnectionST.cxx
@@ -1102,9 +1102,8 @@ void VNCSConnectionST::writeFramebufferUpdate()
     
     writer()->writeFramebufferUpdateStart(nRects);
 
-    Region updatedRegion;
-    writer()->writeRects(ui, &image_getter, &updatedRegion);
-    updates.subtract(updatedRegion);
+    writer()->writeRects(ui, &image_getter);
+    updates.clear();
 
     if (drawRenderedCursor)
       writeRenderedCursorRect();
@@ -1129,8 +1128,7 @@ void VNCSConnectionST::writeRenderedCursorRect()
   image_getter.setPixelBuffer(&server->renderedCursor);
   image_getter.setOffset(server->renderedCursorTL);
 
-  Rect actual;
-  writer()->writeRect(renderedCursorRect, &image_getter, &actual);
+  writer()->writeRect(renderedCursorRect, &image_getter);
 
   image_getter.setPixelBuffer(server->pb);
   image_getter.setOffset(Point(0,0));

diff --git a/common/rfb/ZRLEEncoder.cxx b/common/rfb/ZRLEEncoder.cxx
index e70706b57ba22230a46a941902ceb90cbc3c54e4..7e00fad28a64d52d504b79a41b29851ae3670323 100644 (file)
--- a/common/rfb/ZRLEEncoder.cxx
+++ b/common/rfb/ZRLEEncoder.cxx
@@ -55,19 +55,17 @@ ZRLEEncoder::~ZRLEEncoder()
 {
 }
 
-bool ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
+void ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig)
 {
   rdr::U8* imageBuf = writer->getImageBuf(64 * 64 * 4 + 4);
   mos.clear();
-  bool wroteAll = true;
-  *actual = r;
 
   switch (writer->bpp()) {
   case 8:
-    wroteAll = zrleEncode8(r, &mos, &zos, imageBuf, actual, ig);
+    zrleEncode8(r, &mos, &zos, imageBuf, ig);
     break;
   case 16:
-    wroteAll = zrleEncode16(r, &mos, &zos, imageBuf, actual, ig);
+    zrleEncode16(r, &mos, &zos, imageBuf, ig);
     break;
   case 32:
     {
@@ -80,25 +78,24 @@ bool ZRLEEncoder::writeRect(const Rect& r, TransImageGetter* ig, Rect* actual)
       if ((fitsInLS3Bytes && pf.isLittleEndian()) ||
           (fitsInMS3Bytes && pf.isBigEndian()))
       {
-        wroteAll = zrleEncode24A(r, &mos, &zos, imageBuf, actual, ig);
+        zrleEncode24A(r, &mos, &zos, imageBuf, ig);
       }
       else if ((fitsInLS3Bytes && pf.isBigEndian()) ||
                (fitsInMS3Bytes && pf.isLittleEndian()))
       {
-        wroteAll = zrleEncode24B(r, &mos, &zos, imageBuf, actual, ig);
+        zrleEncode24B(r, &mos, &zos, imageBuf, ig);
       }
       else
       {
-        wroteAll = zrleEncode32(r, &mos, &zos, imageBuf, actual, ig);
+        zrleEncode32(r, &mos, &zos, imageBuf, ig);
       }
       break;
     }
   }
 
-  writer->startRect(*actual, encodingZRLE);
+  writer->startRect(r, encodingZRLE);
   rdr::OutStream* os = writer->getOutStream();
   os->writeU32(mos.length());
   os->writeBytes(mos.data(), mos.length());
   writer->endRect();
-  return wroteAll;
 }

diff --git a/common/rfb/ZRLEEncoder.h b/common/rfb/ZRLEEncoder.h
index e3517c135f3d823e1affec818429cff2ec7df591..acc6d362def66769ef4ea4238d30fe4ece157d8d 100644 (file)
--- a/common/rfb/ZRLEEncoder.h
+++ b/common/rfb/ZRLEEncoder.h
@@ -28,7 +28,7 @@ namespace rfb {
   public:
     ZRLEEncoder(SMsgWriter* writer);
     virtual ~ZRLEEncoder();
-    virtual bool writeRect(const Rect& r, TransImageGetter* ig, Rect* actual);
+    virtual void writeRect(const Rect& r, TransImageGetter* ig);
   private:
     SMsgWriter* writer;
     rdr::ZlibOutStream zos;

diff --git a/common/rfb/zrleEncode.h b/common/rfb/zrleEncode.h
index 0c622b8883ffca8a15b81d6ed717176beee1af52..928ce9678910116bd8be8a976fabb9eb985d203c 100644 (file)
--- a/common/rfb/zrleEncode.h
+++ b/common/rfb/zrleEncode.h
@@ -114,8 +114,8 @@ public:
 
 void ZRLE_ENCODE_TILE (PIXEL_T* data, int w, int h, rdr::OutStream* os);
 
-bool ZRLE_ENCODE (const Rect& r, rdr::OutStream* os,
-                  rdr::ZlibOutStream* zos, void* buf, Rect* actual
+void ZRLE_ENCODE (const Rect& r, rdr::OutStream* os,
+                  rdr::ZlibOutStream* zos, void* buf
 #ifdef EXTRA_ARGS
                   , EXTRA_ARGS
 #endif
@@ -132,16 +132,6 @@ bool ZRLE_ENCODE (const Rect& r, rdr::OutStream* os,
 
     t.br.y = __rfbmin(r.br.y, t.tl.y + 64);
 
-    // enough for width 16384 32-bit pixels
-    if (os->length() + worstCaseLine > 4097 * 1024) {
-      if (t.tl.y == r.tl.y)
-        throw Exception("ZRLE: not enough space for first line?");
-      actual->tl = r.tl;
-      actual->br.x = r.br.x;
-      actual->br.y = t.tl.y;
-      return false;
-    }
-
     for (t.tl.x = r.tl.x; t.tl.x < r.br.x; t.tl.x += 64) {
 
       t.br.x = __rfbmin(r.br.x, t.tl.x + 64);
@@ -153,7 +143,6 @@ bool ZRLE_ENCODE (const Rect& r, rdr::OutStream* os,
 
     zos->flush();
   }
-  return true;
 }