QRfbRawEncoder Class Reference

#include <qscreenvnc_p.h>

Inheritance diagram for QRfbRawEncoder:

Public Functions
	QRfbRawEncoder (QVNCServer *s)
	QRfbRawEncoder (QVNCServer *s)
void	write ()
void	write ()
Public Functions inherited from QRfbEncoder
	QRfbEncoder (QVNCServer *s)
	QRfbEncoder (QVNCServer *s)
virtual	~QRfbEncoder ()
virtual	~QRfbEncoder ()

Properties
QByteArray	buffer

Additional Inherited Members
Protected Variables inherited from QRfbEncoder
QVNCServer *	server

Detailed Description

Definition at line 278 of file qscreenvnc_p.h.

Constructors and Destructors

QRfbRawEncoder() [1/2]

QRfbRawEncoder::QRfbRawEncoder ( QVNCServer *  s )

inline

Definition at line 281 of file qscreenvnc_p.h.

: QRfbEncoder(s) {}

QRfbRawEncoder() [2/2]

QRfbRawEncoder::QRfbRawEncoder ( QVNCServer *  s )

inline

Definition at line 287 of file qvncserver.h.

: QRfbEncoder(s) {}

Functions

write() [1/2]

void QRfbRawEncoder::write ( )

virtual

Implements QRfbEncoder.

Definition at line 1898 of file qscreenvnc_qws.cpp.

Referenced by QVNCDirtyMap::QVNCDirtyMap().

{
    QWSDisplay::grab(false);

    QVNCDirtyMap *map = server->dirtyMap();
    QTcpSocket *socket = server->clientSocket();

    const int bytesPerPixel = server->clientBytesPerPixel();

    // create a region from the dirty rects and send the region's merged rects.
    QRegion rgn;
    if (map) {
        for (int y = 0; y < map->mapHeight; ++y) {
            for (int x = 0; x < map->mapWidth; ++x) {
                if (!map->dirty(x, y))
                    continue;
                rgn += QRect(x * MAP_TILE_SIZE, y * MAP_TILE_SIZE,
                             MAP_TILE_SIZE, MAP_TILE_SIZE);
                map->setClean(x, y);
            }
        }

        rgn &= QRect(0, 0, server->screen()->deviceWidth(),
                     server->screen()->deviceHeight());
    }
    const QVector<QRect> rects = rgn.rects();

    {
        const char tmp[2] = { 0, 0 }; // msg type, padding
        socket->write(tmp, sizeof(tmp));
    }

    {
        const quint16 count = htons(rects.size());
        socket->write((char *)&count, sizeof(count));
    }

    if (rects.size() <= 0) {
        QWSDisplay::ungrab();
        return;
    }

    const QImage screenImage = server->screenImage();

    for (int i = 0; i < rects.size(); ++i) {
        const QRect tileRect = rects.at(i);
        const QRfbRect rect(tileRect.x(), tileRect.y(),
                            tileRect.width(), tileRect.height());
        rect.write(socket);

        const quint32 encoding = htonl(0); // raw encoding
        socket->write((char *)&encoding, sizeof(encoding));

        int linestep = screenImage.bytesPerLine();
        const uchar *screendata = screenImage.scanLine(rect.y)
                                  + rect.x * screenImage.depth() / 8;

#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 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 (server->doPixelConversion()) {
            const int bufferSize = rect.w * rect.h * bytesPerPixel;
            if (bufferSize > buffer.size())
                buffer.resize(bufferSize);

            // convert pixels
            char *b = buffer.data();
            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(), bufferSize);
        } else {
            for (int i = 0; i < rect.h; ++i) {
                socket->write((const char*)screendata, rect.w * bytesPerPixel);
                screendata += linestep;
            }
        }
        if (socket->state() == QAbstractSocket::UnconnectedState)
            break;
    }
    socket->flush();

    QWSDisplay::ungrab();
}

write() [2/2]

void QRfbRawEncoder::write ( )

virtual

Implements QRfbEncoder.

Properties

buffer

QByteArray QRfbRawEncoder::buffer

private

Definition at line 286 of file qscreenvnc_p.h.

---

The documentation for this class was generated from the following files:

• /src/plugins/gfxdrivers/vnc/qscreenvnc_p.h
• /src/plugins/platforms/vnc/qvncserver.h
• /src/plugins/gfxdrivers/vnc/qscreenvnc_qws.cpp
• /src/plugins/platforms/vnc/qvncserver.cpp