Be more consistent in referring to pixel byte streams as buffers

diff --git a/common/rfb/CMsgHandler.h b/common/rfb/CMsgHandler.h
index d69d4f212bc820c541e6fee1c3daf6bd30b35486..d7ffd65b66b32700ed74a71f8b225cf9a77a8be1 100644 (file)
--- a/common/rfb/CMsgHandler.h
+++ b/common/rfb/CMsgHandler.h
@@ -71,8 +71,8 @@ namespace rfb {
     virtual void imageRect(const Rect& r, void* pixels) = 0;
     virtual void copyRect(const Rect& r, int srcX, int srcY) = 0;
 
-    virtual rdr::U8* getRawPixelsRW(const Rect& r, int* stride) = 0;
-    virtual void releaseRawPixels(const Rect& r) = 0;
+    virtual rdr::U8* getRawBufferRW(const Rect& r, int* stride) = 0;
+    virtual void releaseRawBuffer(const Rect& r) = 0;
 
     virtual const PixelFormat &getPreferredPF(void) = 0;
 

diff --git a/common/rfb/ComparingUpdateTracker.cxx b/common/rfb/ComparingUpdateTracker.cxx
index 1c2bd38307b5d2554a5bebf27c5c52312ab5b045..8d4311a19916d00e6c434109a5cde0220e948e7a 100644 (file)
--- a/common/rfb/ComparingUpdateTracker.cxx
+++ b/common/rfb/ComparingUpdateTracker.cxx
@@ -53,7 +53,7 @@ bool ComparingUpdateTracker::compare()
     for (int y=0; y<fb->height(); y+=BLOCK_SIZE) {
       Rect pos(0, y, fb->width(), __rfbmin(fb->height(), y+BLOCK_SIZE));
       int srcStride;
-      const rdr::U8* srcData = fb->getPixelsR(pos, &srcStride);
+      const rdr::U8* srcData = fb->getBuffer(pos, &srcStride);
       oldFb.imageRect(pos, srcData, srcStride);
     }
 
@@ -106,7 +106,7 @@ void ComparingUpdateTracker::compareRect(const Rect& r, Region* newChanged)
 
   int bytesPerPixel = fb->getPF().bpp/8;
   int oldStride;
-  rdr::U8* oldData = oldFb.getPixelsRW(r, &oldStride);
+  rdr::U8* oldData = oldFb.getBufferRW(r, &oldStride);
   int oldStrideBytes = oldStride * bytesPerPixel;
 
   std::vector<Rect> changedBlocks;
@@ -116,7 +116,7 @@ void ComparingUpdateTracker::compareRect(const Rect& r, Region* newChanged)
     // Get a strip of the source buffer
     Rect pos(r.tl.x, blockTop, r.br.x, __rfbmin(r.br.y, blockTop+BLOCK_SIZE));
     int fbStride;
-    const rdr::U8* newBlockPtr = fb->getPixelsR(pos, &fbStride);
+    const rdr::U8* newBlockPtr = fb->getBuffer(pos, &fbStride);
     int newStrideBytes = fbStride * bytesPerPixel;
 
     rdr::U8* oldBlockPtr = oldData;

diff --git a/common/rfb/PixelBuffer.cxx b/common/rfb/PixelBuffer.cxx
index 293403b65d35e45f873fba1a94522a0a92df00de..9d151b973aafb11fc19263eb80b0e8758829e94d 100644 (file)
--- a/common/rfb/PixelBuffer.cxx
+++ b/common/rfb/PixelBuffer.cxx
@@ -48,7 +48,7 @@ ColourMap* PixelBuffer::getColourMap() const {return colourmap;}
 void
 PixelBuffer::getImage(void* imageBuf, const Rect& r, int outStride) {
   int inStride;
-  const U8* data = getPixelsR(r, &inStride);
+  const U8* data = getBuffer(r, &inStride);
   // We assume that the specified rectangle is pre-clipped to the buffer
   int bytesPerPixel = format.bpp/8;
   int inBytesPerRow = inStride * bytesPerPixel;
@@ -154,7 +154,7 @@ void FullFramePixelBuffer::setPF(const PixelFormat &pf) {
 
 int FullFramePixelBuffer::getStride() const { return width(); }
 
-rdr::U8* FullFramePixelBuffer::getPixelsRW(const Rect& r, int* stride)
+rdr::U8* FullFramePixelBuffer::getBufferRW(const Rect& r, int* stride)
 {
   *stride = getStride();
   return &data[(r.tl.x + (r.tl.y * *stride)) * format.bpp/8];
@@ -163,14 +163,14 @@ rdr::U8* FullFramePixelBuffer::getPixelsRW(const Rect& r, int* stride)
 
 void FullFramePixelBuffer::fillRect(const Rect& r, Pixel pix) {
   int stride;
-  U8 *buf = getPixelsRW(r, &stride);
+  U8 *buf = getBufferRW(r, &stride);
   fillRectFn(buf, stride, r, pix);
 }
 
 void FullFramePixelBuffer::imageRect(const Rect& r, const void* pixels, int srcStride) {
   int bytesPerPixel = getPF().bpp/8;
   int destStride;
-  U8* dest = getPixelsRW(r, &destStride);
+  U8* dest = getBufferRW(r, &destStride);
   int bytesPerDestRow = bytesPerPixel * destStride;
   if (!srcStride) srcStride = r.width();
   int bytesPerSrcRow = bytesPerPixel * srcStride;
@@ -188,7 +188,7 @@ void FullFramePixelBuffer::maskRect(const Rect& r, const void* pixels, const voi
   Rect cr = getRect().intersect(r);
   if (cr.is_empty()) return;
   int stride;
-  U8* data = getPixelsRW(cr, &stride);
+  U8* data = getBufferRW(cr, &stride);
   U8* mask = (U8*) mask_;
   int w = cr.width();
   int h = cr.height();
@@ -226,7 +226,7 @@ void FullFramePixelBuffer::maskRect(const Rect& r, Pixel pixel, const void* mask
   Rect cr = getRect().intersect(r);
   if (cr.is_empty()) return;
   int stride;
-  U8* data = getPixelsRW(cr, &stride);
+  U8* data = getBufferRW(cr, &stride);
   U8* mask = (U8*) mask_;
   int w = cr.width();
   int h = cr.height();
@@ -286,7 +286,7 @@ void FullFramePixelBuffer::copyRect(const Rect &rect, const Point &move_by_delta
   if (srect.is_empty())
     return;
 
-  data = getPixelsRW(getRect(), &stride);
+  data = getBufferRW(getRect(), &stride);
   bytesPerPixel = getPF().bpp/8;
   bytesPerRow = stride * bytesPerPixel;
   bytesPerMemCpy = drect.width() * bytesPerPixel;

diff --git a/common/rfb/PixelBuffer.h b/common/rfb/PixelBuffer.h
index 0d1526357af000efffcd41a464a6037b33559abb..5c4f9666b1e34ededd43dfa2b4b6a024da38b442 100644 (file)
--- a/common/rfb/PixelBuffer.h
+++ b/common/rfb/PixelBuffer.h
@@ -70,8 +70,8 @@ namespace rfb {
     // Get a pointer into the buffer
     //   The pointer is to the top-left pixel of the specified Rect.
     //   The buffer stride (in pixels) is returned.
-    virtual const rdr::U8* getPixelsR(const Rect& r, int* stride) = 0;
-    virtual rdr::U8* getPixelsRW(const Rect& r, int* stride) = 0;
+    virtual const rdr::U8* getBuffer(const Rect& r, int* stride) = 0;
+    virtual rdr::U8* getBufferRW(const Rect& r, int* stride) = 0;
 
     // Get pixel data for a given part of the buffer
     //   Data is copied into the supplied buffer, with the specified
@@ -111,10 +111,10 @@ namespace rfb {
     virtual int getStride() const;
 
     // Get a pointer to specified pixel data
-    rdr::U8* getPixelsRW(const Rect& r, int* stride);
-    virtual const rdr::U8* getPixelsR(const Rect& r, int* stride) {
-      return getPixelsRW(r, stride);
+    virtual const rdr::U8* getBuffer(const Rect& r, int* stride) {
+      return getBufferRW(r, stride);
     }
+    virtual rdr::U8* getBufferRW(const Rect& r, int* stride);
 
     ///////////////////////////////////////////////
     // Basic rendering operations

diff --git a/common/rfb/TransImageGetter.cxx b/common/rfb/TransImageGetter.cxx
index c1add1ced6a7628d0c26d450e4137e3510fd3988..3900d065b614d0bfefd3a24e7a3b440c0dd71321 100644 (file)
--- a/common/rfb/TransImageGetter.cxx
+++ b/common/rfb/TransImageGetter.cxx
@@ -56,18 +56,18 @@ void TransImageGetter::setColourMapEntries(int firstCol, int nCols)
   PixelTransformer::setColourMapEntries(firstCol, nCols);
 }
 
-const rdr::U8 *TransImageGetter::getRawPixelsR(const Rect &r, int *stride)
+const rdr::U8 *TransImageGetter::getRawBufferR(const Rect &r, int *stride)
 {
   if (!offset.equals(Point(0, 0)))
-    return pb->getPixelsR(r.translate(offset.negate()), stride);
+    return pb->getBuffer(r.translate(offset.negate()), stride);
   else
-    return pb->getPixelsR(r, stride);
+    return pb->getBuffer(r, stride);
 }
 
 void TransImageGetter::getImage(void* outPtr, const Rect& r, int outStride)
 {
   int inStride;
-  const rdr::U8* inPtr = pb->getPixelsR(r.translate(offset.negate()), &inStride);
+  const rdr::U8* inPtr = pb->getBuffer(r.translate(offset.negate()), &inStride);
 
   if (!outStride) outStride = r.width();
 

diff --git a/common/rfb/TransImageGetter.h b/common/rfb/TransImageGetter.h
index f2b35b45c148085ab0232b1ab7d9a3468b5ef2bf..b241b83ce61807f89ba690b25b0a7e0539226844 100644 (file)
--- a/common/rfb/TransImageGetter.h
+++ b/common/rfb/TransImageGetter.h
@@ -72,11 +72,11 @@ namespace rfb {
     // padding will be outStride-r.width() pixels).
     void getImage(void* outPtr, const Rect& r, int outStride=0);
 
-    // getRawPixelsR() gets the given rectangle of data directly from the
+    // getRawBufferR() gets the given rectangle of data directly from the
     // underlying PixelBuffer, bypassing the translation logic. Only use
     // this when doing something that's independent of the client's pixel
     // format.
-    const rdr::U8 *getRawPixelsR(const Rect &r, int *stride);
+    const rdr::U8 *getRawBufferR(const Rect &r, int *stride);
 
     // setPixelBuffer() changes the pixel buffer to be used.  The new pixel
     // buffer MUST have the same pixel format as the old one - if not you

diff --git a/common/rfb/tightDecode.h b/common/rfb/tightDecode.h
index e9f5f6ba6eba15cfeb88a02e96e669f5b739fa1b..fb39d996a631f33934359c25a787341c1ff47363 100644 (file)
--- a/common/rfb/tightDecode.h
+++ b/common/rfb/tightDecode.h
@@ -156,7 +156,7 @@ void TIGHT_DECODE (const Rect& r)
 
   PIXEL_T *buf;
   int stride = r.width();
-  if (directDecode) buf = (PIXEL_T *)handler->getRawPixelsRW(r, &stride);
+  if (directDecode) buf = (PIXEL_T *)handler->getRawBufferRW(r, &stride);
   else buf = (PIXEL_T *)reader->getImageBuf(r.area());
 
   if (palSize == 0) {
@@ -228,7 +228,7 @@ void TIGHT_DECODE (const Rect& r)
     }
   }
 
-  if (directDecode) handler->releaseRawPixels(r);
+  if (directDecode) handler->releaseRawBuffer(r);
   else IMAGE_RECT(r, buf);
 
   delete [] netbuf;
@@ -256,10 +256,10 @@ DECOMPRESS_JPEG_RECT(const Rect& r)
 
   // We always use direct decoding with JPEG images
   int stride;
-  rdr::U8 *buf = handler->getRawPixelsRW(r, &stride);
+  rdr::U8 *buf = handler->getRawBufferRW(r, &stride);
   jd.decompress(netbuf, compressedLen, buf, stride * clientpf.bpp / 8, r,
                 clientpf);
-  handler->releaseRawPixels(r);
+  handler->releaseRawBuffer(r);
 
   delete [] netbuf;
 }

diff --git a/common/rfb/tightEncode.h b/common/rfb/tightEncode.h
index 8f900b580713d681d3fb0fba4693b2f722f18a8b..0c616f5358fe1121673d3cd4d01e101ff01aec2f 100644 (file)
--- a/common/rfb/tightEncode.h
+++ b/common/rfb/tightEncode.h
@@ -191,7 +191,7 @@ void TIGHT_ENCODE (const Rect& r, rdr::OutStream *os, bool forceSolid)
 {
   int stride;
   rdr::U32 solidColor;
-  const PIXEL_T *rawPixels = (const PIXEL_T *)ig->getRawPixelsR(r, &stride);
+  const PIXEL_T *rawPixels = (const PIXEL_T *)ig->getRawBufferR(r, &stride);
   PIXEL_T *pixels = NULL;
   bool grayScaleJPEG = (jpegSubsampling == SUBSAMP_GRAY && jpegQuality != -1);
 
@@ -650,7 +650,7 @@ bool CHECK_SOLID_TILE(Rect& r, rdr::U32 *colorPtr, bool needSameColor)
   int w = r.width(), h = r.height();
 
   int stride = w;
-  buf = (const PIXEL_T *)ig->getRawPixelsR(r, &stride);
+  buf = (const PIXEL_T *)ig->getRawBufferR(r, &stride);
 
   colorValue = *buf;
   if (needSameColor && (rdr::U32)colorValue != *colorPtr)

diff --git a/vncviewer/CConn.cxx b/vncviewer/CConn.cxx
index f97b0f4c1714efcdc668734cfe46288252201463..7265062de05af05fbd4a1c0181b39e76b64a74b6 100644 (file)
--- a/vncviewer/CConn.cxx
+++ b/vncviewer/CConn.cxx
@@ -443,10 +443,10 @@ void CConn::fence(rdr::U32 flags, unsigned len, const char data[])
   }
 }
 
-rdr::U8* CConn::getRawPixelsRW(const rfb::Rect& r, int* stride) {
-  return desktop->getPixelsRW(r, stride);
+rdr::U8* CConn::getRawBufferRW(const rfb::Rect& r, int* stride) {
+  return desktop->getBufferRW(r, stride);
 }
-void CConn::releaseRawPixels(const rfb::Rect& r) {
+void CConn::releaseRawBuffer(const rfb::Rect& r) {
   desktop->damageRect(r);
 }
 

diff --git a/vncviewer/CConn.h b/vncviewer/CConn.h
index 24fbbab4a63357ae5d031a0d13c9b8fa1d42875f..33dcf4abb6630967425860aee92e6f56b231cc45 100644 (file)
--- a/vncviewer/CConn.h
+++ b/vncviewer/CConn.h
@@ -67,8 +67,8 @@ public:
   void imageRect(const rfb::Rect& r, void* p);
   void copyRect(const rfb::Rect& r, int sx, int sy);
 
-  rdr::U8* getRawPixelsRW(const rfb::Rect& r, int* stride);
-  void releaseRawPixels(const rfb::Rect& r);
+  rdr::U8* getRawBufferRW(const rfb::Rect& r, int* stride);
+  void releaseRawBuffer(const rfb::Rect& r);
 
   const rfb::PixelFormat &getPreferredPF() { return fullColourPF; }
 

diff --git a/vncviewer/DesktopWindow.h b/vncviewer/DesktopWindow.h
index 78d9bf79c63f8ffe2ff82a20acf2c7ea44a221ba..fefdd35bd89563c50f3ebf6fa03695c354df1c74 100644 (file)
--- a/vncviewer/DesktopWindow.h
+++ b/vncviewer/DesktopWindow.h
@@ -62,8 +62,8 @@ public:
     viewport->copyRect(r, srcX, srcY);
   }
 
-  rdr::U8* getPixelsRW(const rfb::Rect& r, int* stride) {
-    return viewport->getPixelsRW(r, stride);
+  rdr::U8* getBufferRW(const rfb::Rect& r, int* stride) {
+    return viewport->getBufferRW(r, stride);
   }
   void damageRect(const rfb::Rect& r) {
     viewport->damageRect(r);

diff --git a/vncviewer/Viewport.h b/vncviewer/Viewport.h
index 748981ac4659a902f55d345614dd7ad247e941f8..59839dcbf900b80f0a099cd17c55ac96f85433e0 100644 (file)
--- a/vncviewer/Viewport.h
+++ b/vncviewer/Viewport.h
@@ -94,8 +94,8 @@ public:
     damageRect(r);
   }
 
-  rdr::U8* getPixelsRW(const rfb::Rect& r, int* stride) {
-    return frameBuffer->getPixelsRW(r, stride);
+  rdr::U8* getBufferRW(const rfb::Rect& r, int* stride) {
+    return frameBuffer->getBufferRW(r, stride);
   }
 
   void damageRect(const rfb::Rect& r) {