Now rfb_win32::ScaledDIBSectionBuffer is an universal class which consist

of source image buffer and destination (scaled) image buffer. It automatically
scale the image data from source buffer to destination when data was
changed in the input buffer.
Overrided methods in the ScaledDIBSectionBuffer class: fillRect(), imageRect(),
copyRect(), maskRect().


git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@516 3789f03b-4d11-0410-bbf8-ca57d06f2519

2 files changed, 89 insertions, 12 deletions

diff --git a/rfb_win32/ScaledDIBSectionBuffer.cxx b/rfb_win32/ScaledDIBSectionBuffer.cxx
index 5b6f248c..e6c15b8e 100644
--- a/rfb_win32/ScaledDIBSectionBuffer.cxx
+++ b/rfb_win32/ScaledDIBSectionBuffer.cxx
@@ -29,27 +29,46 @@ using namespace rfb;
 using namespace win32;
 
 ScaledDIBSectionBuffer::ScaledDIBSectionBuffer(HWND window) 
-  : DIBSectionBuffer(window) {
+  : src_buffer(0), scaling(false), DIBSectionBuffer(window) {
   scaled_data = data;
 }
 
-void ScaledDIBSectionBuffer::setSrcPixelBuffer(U8 **src_data_, int w, int h, PixelFormat pf) {
-  src_data = src_data_;
-  src_width  = w;
-  src_height = h;
-  scaled_width  = width_  = (int)ceil(src_width  * scale_ratio);
-  scaled_height = height_ = (int)ceil(src_height * scale_ratio);
-  setPF(pf);
+ScaledDIBSectionBuffer::~ScaledDIBSectionBuffer() {
+  if (src_buffer) delete src_buffer;
+}
+
+void ScaledDIBSectionBuffer::setScale(int scale_) {
+  if (scale_ == getScale()) return;
+
+  if (src_buffer) {
+    delete src_buffer;
+    src_buffer = 0;
+  }
+  if (scale_ != 100) {
+    scaling = true;
+    src_buffer = new ManagedPixelBuffer(format, src_width, src_height);
+    src_data = &(src_buffer->data);
+  } else {
+    scaling = false;
+  }
+  ScaledPixelBuffer::setScale(scale_);
 }
 
 void ScaledDIBSectionBuffer::setPF(const PixelFormat &pf) {
+  if (scaling) src_buffer->setPF(pf);
   DIBSectionBuffer::setPF(pf);
+  scaled_data = data;
 }
 
 void ScaledDIBSectionBuffer::setSize(int src_width_, int src_height_) {
   src_width = src_width_;
   src_height = src_height_;
-  setScale(scale_ratio * 100);
+  if (scaling) {
+    src_buffer->setSize(src_width, src_height);
+  }
+  calculateScaledBufferSize();
+  recreateScaledBuffer();
+  scaled_data = data;
 }
 
 void ScaledDIBSectionBuffer::recreateScaledBuffer() {
@@ -58,3 +77,48 @@ void ScaledDIBSectionBuffer::recreateScaledBuffer() {
   DIBSectionBuffer::recreateBuffer();
   scaled_data = data;
 }
+
+void ScaledDIBSectionBuffer::fillRect(const Rect &dest, Pixel pix) {
+  if (scaling) {
+    src_buffer->fillRect(dest, pix);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::fillRect(dest, pix);
+  }
+}
+
+void ScaledDIBSectionBuffer::imageRect(const Rect &dest, const void* pixels, int stride) {
+  if (scaling) {
+    src_buffer->imageRect(dest, pixels, stride);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::imageRect(dest, pixels, stride);
+  }
+}
+
+void ScaledDIBSectionBuffer::copyRect(const Rect &dest, const Point &move_by_delta) {
+  if (scaling) {
+    src_buffer->copyRect(dest, move_by_delta);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::copyRect(dest, move_by_delta);
+  }
+}
+      
+void ScaledDIBSectionBuffer::maskRect(const Rect& r, const void* pixels, const void* mask_) {
+  if (scaling) {
+    src_buffer->maskRect(r, pixels, mask_);
+    scaleRect(r);
+  } else {
+    DIBSectionBuffer::maskRect(r, pixels, mask_);
+  }
+}
+
+void ScaledDIBSectionBuffer::maskRect(const Rect& r, Pixel pixel, const void* mask_) {
+  if (scaling) {
+    src_buffer->maskRect(r, pixel, mask_);
+    scaleRect(r);
+  } else {
+    DIBSectionBuffer::maskRect(r, pixel, mask_);
+  }
+}
diff --git a/rfb_win32/ScaledDIBSectionBuffer.h b/rfb_win32/ScaledDIBSectionBuffer.h
index c0dd5868..3cc267b2 100644
--- a/rfb_win32/ScaledDIBSectionBuffer.h
+++ b/rfb_win32/ScaledDIBSectionBuffer.h
@@ -36,18 +36,30 @@ namespace rfb {
     // -=- ScaledDIBSectionBuffer
     //
 
-    class ScaledDIBSectionBuffer : public ScaledPixelBuffer, DIBSectionBuffer {
+    class ScaledDIBSectionBuffer : public ScaledPixelBuffer, public DIBSectionBuffer {
     public:
       ScaledDIBSectionBuffer(HWND window);
-      virtual ~ScaledDIBSectionBuffer() {};
+      virtual ~ScaledDIBSectionBuffer();
 
       int width()  const { return scaled_width; }
       int height() const { return scaled_height; }
       bool isScaling() const { return scaling; }
 
-      virtual void setSrcPixelBuffer(U8 **src_data, int w, int h, PixelFormat pf=PixelFormat());
       virtual void setPF(const PixelFormat &pf);
       virtual void setSize(int w, int h);
+      virtual void setScale(int scale);
+
+      Rect getRect() const { return ScaledPixelBuffer::getRect(); }
+      Rect getRect(const Point& pos) const { return ScaledPixelBuffer::getRect(pos); }
+
+      // -=- Overrides basic rendering operations of 
+      //     FullFramePixelBuffer class
+
+      virtual void fillRect(const Rect &dest, Pixel pix);
+      virtual void imageRect(const Rect &dest, const void* pixels, int stride=0);
+      virtual void copyRect(const Rect &dest, const Point &move_by_delta);
+      virtual void maskRect(const Rect& r, const void* pixels, const void* mask_);
+      virtual void maskRect(const Rect& r, Pixel pixel, const void* mask_);
 
     protected:
       virtual void recreateScaledBuffer();
@@ -55,6 +67,7 @@ namespace rfb {
         recreateScaledBuffer();
       };
 
+      ManagedPixelBuffer *src_buffer;
       bool scaling;
     };