#include <qscreenvnc_p.h>

Inheritance diagram for QRfbHextileEncoder< SRC >:

Public Functions
	QRfbHextileEncoder (QVNCServer *s)

	QRfbHextileEncoder (QVNCServer *s)

void	write ()

void	write ()

Public Functions inherited from QRfbEncoder
	QRfbEncoder (QVNCServer *s)

	QRfbEncoder (QVNCServer *s)

virtual	~QRfbEncoder ()

virtual	~QRfbEncoder ()

Private Types
enum	SubEncoding { Raw = 1, BackgroundSpecified = 2, ForegroundSpecified = 4, AnySubrects = 8, SubrectsColoured = 16, Raw = 1, BackgroundSpecified = 2, ForegroundSpecified = 4, AnySubrects = 8, SubrectsColoured = 16 }

enum	SubEncoding { Raw = 1, BackgroundSpecified = 2, ForegroundSpecified = 4, AnySubrects = 8, SubrectsColoured = 16, Raw = 1, BackgroundSpecified = 2, ForegroundSpecified = 4, AnySubrects = 8, SubrectsColoured = 16 }

Properties
SRC	bg

QByteArray	buffer

QRfbDualColorHextile< SRC >	dualColorHextile

SRC	fg

QRfbMultiColorHextile< SRC >	multiColorHextile

bool	newBg

bool	newFg

QRfbSingleColorHextile< SRC >	singleColorHextile

Friends
class	QRfbDualColorHextile< SRC >

class	QRfbMultiColorHextile< SRC >

class	QRfbSingleColorHextile< SRC >

Additional Inherited Members
Protected Variables inherited from QRfbEncoder
QVNCServer *	server

Detailed Description

template<class SRC>
class QRfbHextileEncoder< SRC >

Definition at line 289 of file qscreenvnc_p.h.

Enumerations

◆ SubEncoding [1/2]

template<class SRC>

enum QRfbHextileEncoder::SubEncoding

private

Enumerator
Raw
BackgroundSpecified
ForegroundSpecified
AnySubrects
SubrectsColoured
Raw
BackgroundSpecified
ForegroundSpecified
AnySubrects
SubrectsColoured

Definition at line 408 of file qscreenvnc_p.h.

                      {
         Raw = 1,
         BackgroundSpecified = 2,
         ForegroundSpecified = 4,
         AnySubrects = 8,
         SubrectsColoured = 16
     };

◆ SubEncoding [2/2]

template<class SRC>

enum QRfbHextileEncoder::SubEncoding

private

Enumerator
Raw
BackgroundSpecified
ForegroundSpecified
AnySubrects
SubrectsColoured
Raw
BackgroundSpecified
ForegroundSpecified
AnySubrects
SubrectsColoured

Definition at line 414 of file qvncserver.h.

                      {
         Raw = 1,
         BackgroundSpecified = 2,
         ForegroundSpecified = 4,
         AnySubrects = 8,
         SubrectsColoured = 16
     };

Constructors and Destructors

◆ QRfbHextileEncoder() [1/2]

template<class SRC >

QRfbHextileEncoder< SRC >::QRfbHextileEncoder ( QVNCServer * s )

Definition at line 1773 of file qscreenvnc_qws.cpp.

Referenced by QVNCDirtyMap::QVNCDirtyMap().

     : QRfbEncoder(s),
       singleColorHextile(this), dualColorHextile(this), multiColorHextile(this)
 {
 }

◆ QRfbHextileEncoder() [2/2]

template<class SRC>

QRfbHextileEncoder< SRC >::QRfbHextileEncoder ( QVNCServer * s )

Functions

◆ write() [1/2]

template<class SRC >

void QRfbHextileEncoder< SRC >::write ( )

virtual

Implements QRfbEncoder.

Definition at line 1784 of file qscreenvnc_qws.cpp.

Referenced by QVNCDirtyMap::QVNCDirtyMap().

 {
     QWSDisplay::grab(true);
 
     QVNCDirtyMap *map = server->dirtyMap();
     QTcpSocket *socket = server->clientSocket();
 
     const quint32 encoding = htonl(5); // hextile encoding
     const int bytesPerPixel = server->clientBytesPerPixel();
 
     {
         const char tmp[2] = { 0, 0 }; // msg type, padding
         socket->write(tmp, sizeof(tmp));
     }
     {
         const quint16 count = htons(map->numDirty);
         socket->write((char *)&count, sizeof(count));
     }
 
     if (map->numDirty <= 0) {
         QWSDisplay::ungrab();
         return;
     }
 
     newBg = true;
     newFg = true;
 
     const QImage screenImage = server->screenImage();
     QRfbRect rect(0, 0, MAP_TILE_SIZE, MAP_TILE_SIZE);
 
     for (int y = 0; y < map->mapHeight; ++y) {
         if (rect.y + MAP_TILE_SIZE > server->screen()->height())
             rect.h = server->screen()->height() - rect.y;
         rect.w = MAP_TILE_SIZE;
         for (int x = 0; x < map->mapWidth; ++x) {
             if (!map->dirty(x, y))
                 continue;
             map->setClean(x, y);
 
             rect.x = x * MAP_TILE_SIZE;
             if (rect.x + MAP_TILE_SIZE > server->screen()->deviceWidth())
                 rect.w = server->screen()->deviceWidth() - rect.x;
             rect.write(socket);
 
             socket->write((char *)&encoding, sizeof(encoding));
 
             const uchar *screendata = screenImage.scanLine(rect.y)
                                       + rect.x * screenImage.depth() / 8;
             int linestep = screenImage.bytesPerLine();
 
 #ifndef QT_NO_QWS_CURSOR
             // hardware cursors must be blended with the screen memory
             const bool doBlendCursor = qt_screencursor
                                        && !server->hasClientCursor()
                                        && qt_screencursor->isAccelerated();
             QImage tileImage;
             if (doBlendCursor) {
                 const QRect tileRect(rect.x, rect.y, rect.w, rect.h);
                 const QRect cursorRect = qt_screencursor->boundingRect()
                                          .translated(-server->screen()->offset());
                 if (tileRect.intersects(cursorRect)) {
                     tileImage = screenImage.copy(tileRect);
                     blendCursor(tileImage,
                                 tileRect.translated(server->screen()->offset()));
                     screendata = tileImage.bits();
                     linestep = tileImage.bytesPerLine();
                 }
             }
 #endif // QT_NO_QWS_CURSOR
 
             if (singleColorHextile.read(screendata, rect.w, rect.h, linestep)) {
                 singleColorHextile.write(socket);
             } else if (dualColorHextile.read(screendata, rect.w, rect.h, linestep)) {
                 dualColorHextile.write(socket);
             } else if (multiColorHextile.read(screendata, rect.w, rect.h, linestep)) {
                 multiColorHextile.write(socket);
             } else if (server->doPixelConversion()) {
                 const int bufferSize = rect.w * rect.h * bytesPerPixel + 1;
                 const int padding = sizeof(quint32) - sizeof(char);
                 buffer.resize(bufferSize + padding);
 
                 buffer[padding] = 1; // Raw subencoding
 
                 // convert pixels
                 char *b = buffer.data() + padding + 1;
                 const int bstep = rect.w * bytesPerPixel;
                 for (int i = 0; i < rect.h; ++i) {
                     server->convertPixels(b, (const char*)screendata, rect.w);
                     screendata += linestep;
                     b += bstep;
                 }
                 socket->write(buffer.constData() + padding, bufferSize);
             } else {
                 quint8 subenc = 1; // Raw subencoding
                 socket->write((char *)&subenc, 1);
 
                 // send pixels
                 for (int i = 0; i < rect.h; ++i) {
                     socket->write((const char*)screendata,
                                   rect.w * bytesPerPixel);
                     screendata += linestep;
                 }
             }
         }
         if (socket->state() == QAbstractSocket::UnconnectedState)
             break;
         rect.y += MAP_TILE_SIZE;
     }
     socket->flush();
     Q_ASSERT(map->numDirty == 0);
 
     QWSDisplay::ungrab();
 }