Skip to content

Ludmány Balázs / thin-client

Go to a project

A prog2-höz tartozó friss repo anyagok itt elérhetőek: https://git.iit.bme.hu/

Commit 36bd0aa2 by Ludmány Balázs
Options

Refactor

parent 14d916c7
Showing with 664 additions and 540 deletions
ThinClient.pro
...@@ -29,12 +29,11 @@ HEADERS += \ ...@@ -29,12 +29,11 @@ HEADERS += \
jpegdecoder.h \ jpegdecoder.h \
qvnc.h \ qvnc.h \
uploader.h \ uploader.h \
dispatcher.h dispatcher.h \
concurrentqueue.h
DISTFILES += \ DISTFILES += \
draw_shader.fsh \ draw_shader.fsh \
draw_shader.vsh \ draw_shader.vsh \
fill_shader.vsh \
fill_shader.fsh \
copy_shader.vsh \ copy_shader.vsh \
copy_shader.fsh copy_shader.fsh
ThinClient.pro.user
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject> <!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 3.5.1, 2016-07-11T16:48:08. --> <!-- Written by QtCreator 3.5.1, 2016-07-19T13:32:08. -->
<qtcreator> <qtcreator>
<data> <data>
<variable>EnvironmentId</variable> <variable>EnvironmentId</variable>
...@@ -61,7 +61,7 @@ ...@@ -61,7 +61,7 @@
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{9fe100e5-65f5-4993-908d-e24f092a1cff}</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{9fe100e5-65f5-4993-908d-e24f092a1cff}</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value> <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value> <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value> <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0"> <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
...@@ -237,7 +237,9 @@ ...@@ -237,7 +237,9 @@
<value type="int">14</value> <value type="int">14</value>
</valuelist> </valuelist>
<value type="int" key="PE.EnvironmentAspect.Base">2</value> <value type="int" key="PE.EnvironmentAspect.Base">2</value>
<valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/> <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes">
<value type="QString">QML_SHOW_FRAMERATE=1</value>
</valuelist>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">ThinClient</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">ThinClient</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration:/media/ldmnyblzs/files/Projects/ThinClient/ThinClient.pro</value> <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration:/media/ldmnyblzs/files/Projects/ThinClient/ThinClient.pro</value>
...@@ -247,11 +249,11 @@ ...@@ -247,11 +249,11 @@
<value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value> <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value> <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value> <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">false</value> <value type="bool" key="RunConfiguration.UseCppDebugger">true</value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value> <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">false</value>
<value type="bool" key="RunConfiguration.UseMultiProcess">false</value> <value type="bool" key="RunConfiguration.UseMultiProcess">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value> <value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value> <value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">false</value>
</valuemap> </valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value> <value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap> </valuemap>
......
concurrentqueue.h 0 → 100644
#ifndef CONCURRENTQUEUE_H
#define CONCURRENTQUEUE_H
#include <QSemaphore>
template <class T, const unsigned short S>
class ConcurrentQueue
{
public:
ConcurrentQueue();
void enqueue(const T &t);
T dequeue();
bool isEmpty() const;
private:
T m_buffer[S];
unsigned short m_next;
unsigned short m_first;
QSemaphore m_free;
QSemaphore m_used;
};
template <class T, const unsigned short S>
ConcurrentQueue<T, S>::ConcurrentQueue() :
m_next(0), m_first(0), m_free(S), m_used(0)
{
}
template <class T, const unsigned short S>
void ConcurrentQueue<T, S>::enqueue(const T &t)
{
m_free.acquire();
m_buffer[m_next] = t;
m_next = (m_next + 1) % S;
m_used.release();
}
template <class T, const unsigned short S>
T ConcurrentQueue<T, S>::dequeue()
{
T temp;
m_used.acquire();
temp = m_buffer[m_first];
m_first = (m_first + 1) % S;
m_free.release();
return temp;
}
template <class T, const unsigned short S>
bool ConcurrentQueue<T, S>::isEmpty() const
{
return (m_first == m_next);
}
#endif // CONCURRENTQUEUE_H
dispatcher.cpp
#include "dispatcher.h" #include "dispatcher.h"
Dispatcher::Dispatcher(QObject *parent) : QObject(parent), m_uploader(this) Dispatcher::Dispatcher(Uploader *uploader, QObject *parent) :
QObject(parent), m_client(NULL), m_uploader(uploader)
{ {
} }
...@@ -14,7 +15,7 @@ rfbBool Dispatcher::MallocFrameBuffer(rfbClient *client) ...@@ -14,7 +15,7 @@ rfbBool Dispatcher::MallocFrameBuffer(rfbClient *client)
void Dispatcher::GotCopyRect(rfbClient *client, int src_x, int src_y, int w, int h, int dest_x, int dest_y) void Dispatcher::GotCopyRect(rfbClient *client, int src_x, int src_y, int w, int h, int dest_x, int dest_y)
{ {
Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0); Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0);
dispatcher->uploader().gotCopyRect(src_x, src_y, w, h, dest_x, dest_y); dispatcher->uploader()->gotCopy(src_x, src_y, w, h, dest_x, dest_y);
} }
void Dispatcher::GotFillRect(rfbClient *client, int x, int y, int w, int h, uint32_t colour) void Dispatcher::GotFillRect(rfbClient *client, int x, int y, int w, int h, uint32_t colour)
...@@ -23,138 +24,68 @@ void Dispatcher::GotFillRect(rfbClient *client, int x, int y, int w, int h, uint ...@@ -23,138 +24,68 @@ void Dispatcher::GotFillRect(rfbClient *client, int x, int y, int w, int h, uint
int red = (colour >> client->format.redShift) & client->format.redMax; int red = (colour >> client->format.redShift) & client->format.redMax;
int green = (colour >> client->format.greenShift) & client->format.greenMax; int green = (colour >> client->format.greenShift) & client->format.greenMax;
int blue = (colour >> client->format.blueShift) & client->format.blueMax; int blue = (colour >> client->format.blueShift) & client->format.blueMax;
dispatcher->uploader().gotFillRect(x, y, w, h, red, green, blue); dispatcher->uploader()->gotFill(x, y, w, h, red, green, blue);
} }
void Dispatcher::GotBitmap(rfbClient *client, const uint8_t *buffer, int x, int y, int w, int h) void Dispatcher::GotBitmap(rfbClient *client, const uint8_t *buffer, int x, int y, int w, int h)
{ {
QImage img;
Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0); Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0);
switch(dispatcher->bitsPerPixel()) {
case 8:
img = QImage(buffer, w, h, QImage::Format_Grayscale8);
break;
case 16:
img = QImage(buffer, w, h, QImage::Format_RGB16);
break;
case 32:
img = QImage(buffer, w, h, QImage::Format_RGBX8888);
break;
default:
emit dispatcher->error();
return;
}
// We have to make a deep copy because libvnc might free the buffer as soon as this function returns // We have to make a deep copy because libvnc might free the buffer as soon as this function returns
dispatcher->uploader().gotBitmap(img.copy(), x, y, w, h); dispatcher->uploader()->gotBitmap(QByteArray((const char *) buffer, w * h * (dispatcher->bitsPerPixel() / 8)), x, y, w, h, GL_BGRA_EXT, GL_UNSIGNED_BYTE);
} }
rfbBool Dispatcher::GotJpeg(rfbClient *client, const uint8_t *buffer, int length, int x, int y, int w, int h) rfbBool Dispatcher::GotJpeg(rfbClient *client, const uint8_t *buffer, int length, int x, int y, int w, int h)
{ {
Dispatcher *dispatcher = static_cast<Dispatcher *>(rfbClientGetClientData(client, 0)); Dispatcher *dispatcher = static_cast<Dispatcher *>(rfbClientGetClientData(client, 0));
Jpeg *jpeg = new Jpeg(QByteArray::fromRawData((const char *) buffer, length),
QByteArray jpeg; dispatcher->uploader()->gotJpeg(x, y, w, h));
jpeg.setRawData((const char*) buffer, length); dispatcher->queue()->enqueue(jpeg);
JpegDecoder *decoder = new JpegDecoder(jpeg, x, y, w, h);
dispatcher->incrementDecoderCount();
connect(decoder, &JpegDecoder::finished, dispatcher, &Dispatcher::decodingFinished, Qt::QueuedConnection);
QThreadPool::globalInstance()->start(decoder);
return TRUE; return TRUE;
} }
void Dispatcher::FinishedFrameBufferUpdate(rfbClient *client) void Dispatcher::FinishedFrameBufferUpdate(rfbClient *client)
{ {
Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0); Dispatcher *dispatcher = (Dispatcher *) rfbClientGetClientData(client, 0);
dispatcher->setFinished(true); dispatcher->uploader()->finishedUpdate();
if(dispatcher->decoderCount() == 0) {
dispatcher->uploader().finishedUpdate();
emit dispatcher->updateFramebuffer();
}
} }
void Dispatcher::setMouse(int x, int y, bool left, bool middle, bool right) bool Dispatcher::mouseEvent(const int x, const int y, const bool left, const bool middle, const bool right, const bool up, const bool down)
{ {
if(m_client == NULL) if(m_client == NULL)
return; return false;
int buttonMask = 0; int buttonMask = 0;
if(left) buttonMask |= rfbButton1Mask; if(left) buttonMask |= rfbButton1Mask;
if(middle) buttonMask |= rfbButton2Mask; if(right) buttonMask |= rfbButton2Mask;
if(right) buttonMask |= rfbButton3Mask; if(middle) buttonMask |= rfbButton3Mask;
if(up) buttonMask |= rfbButton4Mask;
if(down) buttonMask |= rfbButton5Mask;
SendPointerEvent(m_client, x, y, buttonMask); SendPointerEvent(m_client, x, y, buttonMask);
} return true;
unsigned int Dispatcher::decoderCount() const
{
return m_decoderCount;
}
unsigned int Dispatcher::incrementDecoderCount()
{
return ++m_decoderCount;
}
unsigned int Dispatcher::decrementDecoderCount()
{
return --m_decoderCount;
} }
int Dispatcher::bitsPerPixel() int Dispatcher::bitsPerPixel()
{ {
return m_client->format.bitsPerPixel; if(m_client == NULL)
}
Uploader &Dispatcher::uploader()
{
return m_uploader;
}
void Dispatcher::setFinished(bool finished)
{
m_finished = finished;
}
bool Dispatcher::finished() const
{
return m_finished;
}
unsigned int Dispatcher::fill_count()
{
if(m_finished && m_decoderCount == 0)
return m_uploader.fill_count();
else
return 0;
}
unsigned int Dispatcher::copy_count()
{
if(m_finished && m_decoderCount == 0)
return m_uploader.copy_count();
else
return 0;
}
unsigned int Dispatcher::draw_count()
{
if(m_finished && m_decoderCount == 0)
return m_uploader.draw_count();
else
return 0; return 0;
return m_client->format.bitsPerPixel;
} }
QVector3D Dispatcher::colorMax() const QVector3D Dispatcher::colorMax() const
{ {
if(m_client == NULL) if(m_client == NULL)
return QVector3D(); return QVector3D();
return QVector3D(m_client->format.redMax, m_client->format.greenMax, m_client->format.blueMax); return QVector3D(m_client->format.redMax, m_client->format.greenMax, m_client->format.blueMax);
} }
void Dispatcher::create_context(QOpenGLContext *context) ConcurrentQueue<Jpeg *, 64u> *Dispatcher::queue()
{ {
m_uploader.create_context(context); return &m_queue;
}
Uploader *Dispatcher::uploader() const
{
return m_uploader;
} }
void Dispatcher::open(QString host, int port) void Dispatcher::open(QString host, int port)
...@@ -174,13 +105,51 @@ void Dispatcher::open(QString host, int port) ...@@ -174,13 +105,51 @@ void Dispatcher::open(QString host, int port)
m_client->FinishedFrameBufferUpdate = Dispatcher::FinishedFrameBufferUpdate; m_client->FinishedFrameBufferUpdate = Dispatcher::FinishedFrameBufferUpdate;
m_client->appData.useRemoteCursor = TRUE; m_client->appData.useRemoteCursor = TRUE;
// Set the format requested by the user
m_client->width = 1024;
m_client->height = 768;
m_client->appData.compressLevel = 0;
m_client->appData.qualityLevel = 0;
#ifdef __BIG_ENDIAN__
m_client->format.bigEndian = TRUE;
#else
m_client->format.bigEndian = FALSE;
#endif
// The Raspberry Pi supports 8 bit paletted images and RGB422 too but only through extensions
m_client->format.trueColour = TRUE;
m_client->format.bitsPerPixel = 32;
rfbClientSetClientData(m_client, 0, this); rfbClientSetClientData(m_client, 0, this);
if(!rfbInitClient(m_client, NULL, NULL)) { if(!rfbInitClient(m_client, NULL, NULL)) {
emit error(); emit error();
return; return;
} }
emit colorMaxChanged(colorMax());
// Stick to the format sent by the server if we can render it easily, set a new one otherwise
//
// Formats OpenGL ES 2.0 can (should be able to) handle:
// Internal Format External Format Type Bytes per Pixel
// --------------- --------------- ---- ---------------
// RGBA RGBA UNSIGNED_BYTE 4
// RGB RGB UNSIGNED_BYTE 3
// RGBA RGBA UNSIGNED_SHORT_4_4_4_4 2
// RGBA RGBA UNSIGNED_SHORT_5_5_5_1 2
// RGB RGB UNSIGNED_SHORT_5_6_5 2
// The Raspberry Pi supports BGRA too but only through extensions
//
// JPEG is RGB UNSIGNED_BYTE
// Supported raw formats:
// 32 bit: RGB888
// 16 bit: RGB444, RGB555, RGB565
/*int message = WaitForMessage(m_client, 1000);
if(message < 0) {
terminate();
emit error();
return;
}*/
refresh(); refresh();
} }
void Dispatcher::refresh() void Dispatcher::refresh()
...@@ -188,25 +157,27 @@ void Dispatcher::refresh() ...@@ -188,25 +157,27 @@ void Dispatcher::refresh()
if(m_client == NULL) if(m_client == NULL)
return; return;
setFinished(false); m_uploader->cleanup();
m_uploader.startedUpdate();
int message = 0; int message = 0;
if(!HandleRFBServerMessage(m_client)) {
terminate();
emit error();
return;
}
// Don't block uploading!
// Wait until we get something // Wait until we get something
while(message == 0) { while(message == 0) {
message = WaitForMessage(m_client, 10000); QCoreApplication::processEvents();
message = WaitForMessage(m_client, 1000);
if(message < 0) { if(message < 0) {
terminate(); terminate();
emit error(); emit error();
return; return;
} }
if (message) {
if(!HandleRFBServerMessage(m_client)) {
terminate();
emit error();
return;
}
}
} }
} }
...@@ -217,12 +188,3 @@ void Dispatcher::terminate() ...@@ -217,12 +188,3 @@ void Dispatcher::terminate()
rfbClientCleanup(m_client); rfbClientCleanup(m_client);
} }
void Dispatcher::decodingFinished(const QImage &bitmap, const int x, const int y, const int w, const int h)
{
m_uploader.gotBitmap(bitmap, x, y, w, h);
if(m_finished && decrementDecoderCount() == 0) {
m_uploader.finishedUpdate();
emit updateFramebuffer();
}
}
dispatcher.h
...@@ -21,7 +21,7 @@ class Dispatcher : public QObject ...@@ -21,7 +21,7 @@ class Dispatcher : public QObject
Q_OBJECT Q_OBJECT
public: public:
Dispatcher(QObject *parent = 0); Dispatcher(Uploader *uploader, QObject *parent = Q_NULLPTR);
// libvnc hooks // libvnc hooks
static rfbBool MallocFrameBuffer(rfbClient* client); static rfbBool MallocFrameBuffer(rfbClient* client);
...@@ -31,37 +31,34 @@ public: ...@@ -31,37 +31,34 @@ public:
static rfbBool GotJpeg(rfbClient* client, const uint8_t* buffer, int length, int x, int y, int w, int h); static rfbBool GotJpeg(rfbClient* client, const uint8_t* buffer, int length, int x, int y, int w, int h);
static void FinishedFrameBufferUpdate(rfbClient* client); static void FinishedFrameBufferUpdate(rfbClient* client);
void setMouse(int x, int y, bool left, bool middle, bool right); // input events
bool mouseEvent(const int x, const int y, const bool left, const bool middle, const bool right, const bool up, const bool down);
unsigned int decoderCount() const; // parameters of the VNC connection
unsigned int incrementDecoderCount();
unsigned int decrementDecoderCount();
int bitsPerPixel(); int bitsPerPixel();
Uploader &uploader();
void setFinished(bool finished);
bool finished() const;
unsigned int fill_count();
unsigned int copy_count();
unsigned int draw_count();
QVector3D colorMax() const; QVector3D colorMax() const;
// getters
ConcurrentQueue<Jpeg *, 64>* queue();
Uploader *uploader() const;
private: private:
rfbClient *m_client; rfbClient *m_client;
unsigned int m_decoderCount; Uploader *m_uploader;
bool m_finished; ConcurrentQueue<Jpeg*, 64> m_queue;
// TODO: move this to QVnc
Uploader m_uploader;
signals: signals:
// libvnc events
void gotCopy(const int src_x, const int src_y, const int width, const int height, const int dest_x, const int dest_y);
void gotFill(const int x, const int y, const int width, const int height, const float red, const float green, const float blue);
void gotBitmap(const QImage &image, const quint32 x, const quint32 y, const quint32 width, const quint32 height);
void finishedUpdate();
void resizeFramebuffer(const QSize &size); void resizeFramebuffer(const QSize &size);
void updateFramebuffer(); void colorMaxChanged(const QVector3D &colorMax);
void error(); void error();
public slots: public slots:
void create_context(QOpenGLContext *context); // manage VNC connection
void open(QString host, int port); void open(QString host, int port);
void refresh(); void refresh();
void terminate(); void terminate();
void decodingFinished(const QImage &bitmap, const int x, const int y, const int w, const int h);
}; };
#endif // RFBDISPATCH_H #endif // RFBDISPATCH_H
draw_shader.fsh
uniform sampler2D texture; uniform sampler2D texture;
varying lowp vec2 vartexcoord; varying highp vec2 vartexcoord;
varying lowp vec3 varcolor; varying highp vec3 varcolor;
void main(void) void main(void)
{ {
gl_FragColor = vec4(texture2D(texture, vartexcoord).rgb + varcolor, 1.0); gl_FragColor = vec4(texture2D(texture, vartexcoord).bgr + varcolor, 1.0);
} }
draw_shader.vsh
uniform highp mat4 ortho; uniform highp mat4 ortho;
uniform lowp vec3 colormax; uniform lowp vec3 colormax;
attribute highp vec2 position; attribute highp vec2 position;
attribute lowp vec3 color; attribute highp vec3 color;
attribute lowp vec2 texcoord; attribute highp vec2 texcoord;
varying lowp vec3 varcolor; varying highp vec3 varcolor;
varying lowp vec2 vartexcoord; varying highp vec2 vartexcoord;
void main(void) void main(void)
{ {
gl_Position = ortho * vec4(position, 0.0, 1.0); gl_Position = ortho * vec4(position, 0.0, 1.0);
varcolor = color / colormax; varcolor = color / colormax;
// varcolor = vec3(1.0, 1.0, 0.0);
vartexcoord = texcoord; vartexcoord = texcoord;
} }
fill_shader.fsh deleted 100644 → 0
varying highp vec3 varcolor;
void main(void)
{
gl_FragColor = vec4(varcolor, 1.0);
}
fill_shader.vsh deleted 100644 → 0
uniform highp mat4 ortho;
uniform highp vec3 colormax;
attribute highp vec2 position;
attribute highp vec3 color;
varying highp vec3 varcolor;
void main(void)
{
gl_Position = ortho * vec4(position, 0.0, 1.0);
varcolor = color / colormax;
}
jpegdecoder.cpp
#include "jpegdecoder.h" #include "jpegdecoder.h"
JpegDecoder::JpegDecoder(const QByteArray &jpeg, const int x, const int y, const int w, const int h, QObject *parent) : JpegDecoder::JpegDecoder(ConcurrentQueue<Jpeg *, 64u> *queue, QObject *parent) :
QObject(parent), QRunnable(), m_jpeg(jpeg), m_x(x), m_y(y), m_w(w), m_h(h) QObject(parent), m_queue(queue)
{ {
} }
void JpegDecoder::run() void JpegDecoder::operate()
{ {
m_image.loadFromData(m_jpeg, "JPG"); Jpeg *jpeg;
emit finished(m_image, m_x, m_y, m_w, m_h); forever {
jpeg = m_queue->dequeue();
QImage image;
image.loadFromData(jpeg->data, "JPEG");
emit finished(image, image.width(), image.height(), jpeg->index);
delete jpeg;
}
} }
jpegdecoder.h
...@@ -3,30 +3,45 @@ ...@@ -3,30 +3,45 @@
#include <QObject> #include <QObject>
#include <QByteArray> #include <QByteArray>
#include <QRunnable>
#include <QPoint> #include <QPoint>
#include <QSize> #include <QSize>
#include <QImage> #include <QImage>
#include <QDebug> #include <QDebug>
#include "concurrentqueue.h"
struct Jpeg {
Jpeg(const QByteArray &d, const int i) :
data(d), index(i)
{
}
~Jpeg()
{
// QByteArray::fromRawData: " QByteArray does not take ownership of data,
// so the QByteArray destructor will never delete the raw data,
// even when the last QByteArray referring to data is destroyed."
delete[] data.constData();
}
QByteArray data;
int index;
};
/*! /*!
* \brief Loads JPEG files on a separate thread * \brief Loads JPEG images
*
* Consumes
*/ */
class JpegDecoder : public QObject, public QRunnable class JpegDecoder : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
JpegDecoder(const QByteArray &jpeg, const int x, const int y, const int w, const int h, QObject *parent = 0); JpegDecoder(ConcurrentQueue<Jpeg*, 64u> *queue, QObject *parent = 0);
void run(); ConcurrentQueue<Jpeg*, 64u> *m_queue;
signals: signals:
void finished(const QImage &image, const int x, const int y, const int w, const int h); void finished(const QImage &image, const int width, const int height, const int index);
private: public slots:
QByteArray m_jpeg; void operate();
QImage m_image;
int m_x;
int m_y;
int m_w;
int m_h;
}; };
#endif // JPEGDECODER_H #endif // JPEGDECODER_H
main.qml
...@@ -29,31 +29,5 @@ ApplicationWindow { ...@@ -29,31 +29,5 @@ ApplicationWindow {
port: 10495 port: 10495
width: 1024 width: 1024
height: 768 height: 768
/* Keys {
onPressed:
}*/
MouseArea {
anchors.fill: parent
// cursorShape: Qt.BlankCursor
hoverEnabled: true
acceptedButtons: Qt.LeftButton | Qt.MiddleButton | Qt.RightButton
onPositionChanged: vnc.setMouse(mouse.x,
mouse.y,
mouse.buttons & Qt.LeftButton,
mouse.buttons & Qt.MiddleButton,
mouse.buttons & Qt.RightButton)
onPressed: vnc.setMouse(mouse.x,
mouse.y,
mouse.buttons & Qt.LeftButton,
mouse.buttons & Qt.MiddleButton,
mouse.buttons & Qt.RightButton)
onReleased: vnc.setMouse(mouse.x,
mouse.y,
mouse.buttons & Qt.LeftButton,
mouse.buttons & Qt.MiddleButton,
mouse.buttons & Qt.RightButton)
}
} }
} }
qvnc.cpp
#include "qvnc.h" #include "qvnc.h"
QVnc::QVnc() QVnc::QVnc(QQuickItem *parent) :
QQuickFramebufferObject(parent), m_decoders(DECODER_COUNT), m_threads(DECODER_COUNT + 1)
{ {
setAcceptedMouseButtons(Qt::AllButtons);
setAcceptHoverEvents(true);
setTextureFollowsItemSize(false);
for(int i = 0; i < m_threads.length(); i++)
m_threads[i] = new QThread(this);
connect(this, &QVnc::windowChanged, this, &QVnc::winChanged); connect(this, &QVnc::windowChanged, this, &QVnc::winChanged);
// Don't let Qt change the size of the OpenGL framebuffer m_uploader = new Uploader;
setTextureFollowsItemSize(false); m_uploader->moveToThread(m_threads[0]);
m_dispatcher = new Dispatcher; connect(m_threads[0], &QThread::finished, m_uploader, &QObject::deleteLater);
m_dispatcher->moveToThread(&m_dispatcher_thread); connect(m_uploader, &Uploader::uploadFinished, this, &QVnc::update);
connect(&m_dispatcher_thread, &QThread::finished, m_dispatcher, &QObject::deleteLater); m_dispatcher = new Dispatcher(m_uploader);
m_dispatcher->moveToThread(m_threads[0]);
connect(m_threads[0], &QThread::finished, m_dispatcher, &QObject::deleteLater);
connect(this, &QVnc::open_connection, m_dispatcher, &Dispatcher::open); connect(this, &QVnc::open_connection, m_dispatcher, &Dispatcher::open);
connect(this, &QVnc::terminate_connection, m_dispatcher, &Dispatcher::terminate); connect(this, &QVnc::terminate_connection, m_dispatcher, &Dispatcher::terminate);
connect(m_dispatcher, &Dispatcher::updateFramebuffer, this, &QVnc::update);
connect(m_dispatcher, &Dispatcher::error, this, &QVnc::dispatch_error); connect(m_dispatcher, &Dispatcher::error, this, &QVnc::dispatch_error);
// QThreadPool::globalInstance()->reserveThread(); int i = 1;
qDebug() << QThreadPool::globalInstance()->maxThreadCount(); foreach(JpegDecoder* d, m_decoders) {
m_dispatcher_thread.start(); d = new JpegDecoder(m_dispatcher->queue());
d->moveToThread(m_threads[i]);
connect(m_threads[i], &QThread::finished, d, &QObject::deleteLater);
connect(d, &JpegDecoder::finished, m_uploader, &Uploader::finishedJpeg);
connect(this, &QVnc::operate, d, &JpegDecoder::operate);
i++;
}
for(int i = 0; i < m_threads.length(); i++)
m_threads.at(i)->start();
emit operate();
} }
QVnc::~QVnc() QVnc::~QVnc()
{ {
m_dispatcher_thread.quit(); foreach(QThread* t, m_threads) {
m_dispatcher_thread.wait(); t->quit();
t->wait();
}
} }
void QVnc::open() void QVnc::open()
...@@ -57,11 +78,6 @@ void QVnc::setPort(int port) ...@@ -57,11 +78,6 @@ void QVnc::setPort(int port)
emit portChanged(port); emit portChanged(port);
} }
void QVnc::setMouse(int x, int y, bool left, bool middle, bool right)
{
m_dispatcher->setMouse(x, y, left, middle, right);
}
void QVnc::dispatch_error() void QVnc::dispatch_error()
{ {
qDebug() << "error"; qDebug() << "error";
...@@ -70,22 +86,17 @@ void QVnc::dispatch_error() ...@@ -70,22 +86,17 @@ void QVnc::dispatch_error()
void QVnc::winChanged(QQuickWindow *window) void QVnc::winChanged(QQuickWindow *window)
{ {
if(window != NULL) if(window != NULL)
connect(window, &QQuickWindow::openglContextCreated, m_dispatcher, &Dispatcher::create_context, Qt::BlockingQueuedConnection); connect(window, &QQuickWindow::openglContextCreated, m_uploader, &Uploader::createContext, Qt::BlockingQueuedConnection);
}
Dispatcher *QVnc::dispatcher() const
{
return m_dispatcher;
} }
QQuickFramebufferObject::Renderer *QVnc::createRenderer() const QQuickFramebufferObject::Renderer *QVnc::createRenderer() const
{ {
VncRenderer *renderer = new VncRenderer(window(), VncRenderer *renderer = new VncRenderer(window(),
m_dispatcher->uploader().vertices(), m_uploader->vertices(),
m_dispatcher->uploader().copy_textures(), m_uploader->textures());
m_dispatcher->uploader().draw_textures()); connect(m_dispatcher, &Dispatcher::colorMaxChanged, renderer, &VncRenderer::setColorMax);
connect(renderer, &VncRenderer::finishedRendering, m_dispatcher, &Dispatcher::refresh); connect(renderer, &VncRenderer::finishedRendering, m_dispatcher, &Dispatcher::refresh);
connect(renderer, &VncRenderer::FBOTextureChanged, &(m_dispatcher->uploader()), &Uploader::changeFBOTexture); connect(renderer, &VncRenderer::FBOTextureChanged, m_uploader, &Uploader::changeFBOTexture);
return renderer; return renderer;
} }
...@@ -98,3 +109,97 @@ int QVnc::port() const ...@@ -98,3 +109,97 @@ int QVnc::port() const
{ {
return m_port; return m_port;
} }
void QVnc::mousePressEvent(QMouseEvent *event)
{
Qt::MouseButtons buttons = event->buttons();
m_lastMouseEvent = event->timestamp();
if(m_dispatcher->mouseEvent(event->x(),
event->y(),
buttons & Qt::LeftButton,
buttons & Qt::MiddleButton,
buttons & Qt::RightButton,
false,
false))
event->accept();
else
event->ignore();
}
void QVnc::mouseReleaseEvent(QMouseEvent *event)
{
Qt::MouseButtons buttons = event->buttons();
m_lastMouseEvent = event->timestamp();
if(m_dispatcher->mouseEvent(event->x(),
event->y(),
buttons & Qt::LeftButton,
buttons & Qt::MiddleButton,
buttons & Qt::RightButton,
false,
false))
event->accept();
else
event->ignore();
}
void QVnc::wheelEvent(QWheelEvent *event)
{
Qt::MouseButtons buttons = event->buttons();
QPoint rotated = event->angleDelta();
m_lastMouseEvent = event->timestamp();
if(m_dispatcher->mouseEvent(event->x(),
event->y(),
buttons & Qt::LeftButton,
buttons & Qt::MiddleButton,
buttons & Qt::RightButton,
rotated.x() > 0,
rotated.x() < 0))
event->accept();
else
event->ignore();
}
void QVnc::mouseMoveEvent(QMouseEvent *event)
{
// Filter mouse move events, we don't need 100+ of them in a second
if((event->timestamp() - m_lastMouseEvent) > 33) {
Qt::MouseButtons buttons = event->buttons();
m_lastMouseEvent = event->timestamp();
if(m_dispatcher->mouseEvent(event->x(),
event->y(),
buttons & Qt::LeftButton,
buttons & Qt::MiddleButton,
buttons & Qt::RightButton,
false,
false))
event->accept();
else
event->ignore();
}
}
void QVnc::hoverMoveEvent(QHoverEvent *event)
{
// Qt bug: timestamp is zero for QHoverEvent
// if((event->timestamp() - m_lastMouseEvent) > 33) {
// m_lastMouseEvent = event->timestamp();
QPoint position = event->pos();
if(m_dispatcher->mouseEvent(position.x(),
position.y(),
false,
false,
false,
false,
false))
event->accept();
else
event->ignore();
// }
}
void QVnc::keyPressEvent(QKeyEvent *event)
{
}
void QVnc::keyReleaseEvent(QKeyEvent *event)
{
}
qvnc.h
#ifndef VNC_H #ifndef VNC_H
#define VNC_H #define VNC_H
#define DECODER_COUNT 2
#include <QQuickWindow> #include <QQuickWindow>
#include <QObject> #include <QObject>
#include <QQuickFramebufferObject> #include <QQuickFramebufferObject>
...@@ -22,35 +24,47 @@ class QVnc : public QQuickFramebufferObject ...@@ -22,35 +24,47 @@ class QVnc : public QQuickFramebufferObject
Q_PROPERTY(int port READ port WRITE setPort NOTIFY portChanged) Q_PROPERTY(int port READ port WRITE setPort NOTIFY portChanged)
public: public:
explicit QVnc(); explicit QVnc(QQuickItem *parent = Q_NULLPTR);
~QVnc(); ~QVnc();
Renderer *createRenderer() const; Renderer *createRenderer() const;
QString host() const; QString host() const;
int port() const; int port() const;
Dispatcher *dispatcher() const; protected:
void mousePressEvent(QMouseEvent *event);
void mouseReleaseEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);
void keyPressEvent(QKeyEvent *event);
void keyReleaseEvent(QKeyEvent *event);
void wheelEvent(QWheelEvent *event);
void hoverMoveEvent(QHoverEvent *event);
private:
Dispatcher *m_dispatcher;
Uploader *m_uploader;
QVector<JpegDecoder*> m_decoders;
VncRenderer *m_renderer;
QVector<QThread*> m_threads;
QString m_host;
int m_port;
ulong m_lastMouseEvent;
signals: signals:
void open_connection(QString host, int port); void open_connection(QString host, int port);
void terminate_connection(); void terminate_connection();
void hostChanged(QString host); void hostChanged(QString host);
void portChanged(int port); void portChanged(int port);
void operate();
public slots: public slots:
void open(); void open();
void terminate(); void terminate();
void setHost(QString host); void setHost(QString host);
void setPort(int port); void setPort(int port);
void setMouse(int x, int y, bool left, bool middle, bool right);
void dispatch_error(); void dispatch_error();
private:
Dispatcher *m_dispatcher;
QThread m_dispatcher_thread;
QString m_host;
int m_port;
private slots: private slots:
void winChanged(QQuickWindow *window); void winChanged(QQuickWindow *window);
}; };
......
uploader.cpp
#include "uploader.h" #include "uploader.h"
#include <cstring> #include <cstring>
Uploader::Uploader(QObject *parent) : QObject(parent), m_uploader_context(this), m_copyProgram(this) Uploader::Uploader(QObject *parent) : QObject(parent), m_context(this), m_allocated(0), m_program(this), m_jpegs(0)
{ {
// "applications must ensure that create() is only called on the main (GUI) thread" // "applications must ensure that create() is only called on the main (GUI) thread"
m_surface.create(); m_surface.create();
m_copy_textures = QSharedPointer<QVector<GLuint>>(new QVector<GLuint>); m_textures = QSharedPointer<QVector<GLuint>>(new QVector<GLuint>);
m_draw_textures = QSharedPointer<QVector<QOpenGLTexture*>>(new QVector<QOpenGLTexture*>);
// A single rectangle takes 20 float values to describe (4 vertices * (2 coordinate + 3 color)) // reserve space for 10 rectangles
m_fill_data.reserve(100); m_data.reserve(280);
m_draw_data.reserve(100); m_textures->reserve(10);
m_copy_data.reserve(5);
m_copy_textures->reserve(5);
m_draw_textures->reserve(5);
m_vertices = QSharedPointer<QOpenGLBuffer>(new QOpenGLBuffer);
} }
Uploader::~Uploader() Uploader::~Uploader()
{ {
m_copyProgram.release(); m_program.release();
} }
void Uploader::create_context(QOpenGLContext *context) void Uploader::createContext(QOpenGLContext *context)
{ {
static const float position[] = {-1.0f, -1.0f, static const float position[] = {-1.0f, -1.0f,
-1.0f, 1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f, -1.0f,
1.0f, 1.0f}; 1.0f, 1.0f};
m_uploader_context.setShareContext(context); m_context.setShareContext(context);
m_uploader_context.create(); m_context.create();
m_uploader_context.makeCurrent(&m_surface); m_context.makeCurrent(&m_surface);
m_functions = m_uploader_context.functions(); m_functions = m_context.functions();
m_copyProgram.addShaderFromSourceFile(QOpenGLShader::Vertex, "copy_shader.vsh"); m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, "copy_shader.vsh");
m_copyProgram.addShaderFromSourceFile(QOpenGLShader::Fragment, "copy_shader.fsh"); m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, "copy_shader.fsh");
m_copyProgram.bind(); m_program.bind();
m_functions->glActiveTexture(GL_TEXTURE0); m_functions->glActiveTexture(GL_TEXTURE0);
m_copyProgram.setUniformValue("texture", 0); m_program.setUniformValue("texture", 0);
m_copyProgram.enableAttributeArray("position"); m_program.enableAttributeArray("position");
m_copyProgram.enableAttributeArray("texcoord"); m_program.enableAttributeArray("texcoord");
m_copyProgram.setAttributeArray("position", GL_FLOAT, position, 2); m_program.setAttributeArray("position", GL_FLOAT, position, 2);
m_vertices->create(); m_vertices.create();
m_vertices->setUsagePattern(QOpenGLBuffer::DynamicDraw); m_vertices.setUsagePattern(QOpenGLBuffer::DynamicDraw);
} }
void Uploader::startedUpdate() void Uploader::cleanup()
{ {
// Clean up the data from the previous round m_data.clear();
m_fill_data.clear(); m_functions->glDeleteTextures(m_textures->size(), m_textures->constData());
m_fill_count = 0; m_textures->clear();
m_finished = false;
m_functions->glDeleteTextures(m_copy_count, m_copy_textures->constData()); }
m_copy_textures->clear();
m_copy_data.clear();
m_copy_count = 0;
for(unsigned int i = 0; i < m_draw_count; i++) {
m_draw_textures->at(i)->destroy();
delete m_draw_textures->at(i);
}
m_draw_textures->clear();
m_draw_data.clear();
m_draw_count = 0;
void Uploader::gotFill(const int x, const int y, const int width, const int height, const float red, const float green, const float blue)
{
m_textures->append(0);
// NOTE: -coordinates are transformed to normalized device coordinates in the vertex shader
// -coordinates and colors are extended to vec4 in the vertex shader
// -OpenGL ES 2.0 does not support integer values as input,
// thus we need to cast to float on the CPU side :(
// bottom left
m_data.append((float) x);
m_data.append((float) (y + height));
m_data.append(red);
m_data.append(green);
m_data.append(blue);
m_data.append(0.0f);
m_data.append(0.0f);
// top left
m_data.append((float) x);
m_data.append((float) y);
m_data.append(red);
m_data.append(green);
m_data.append(blue);
m_data.append(0.0f);
m_data.append(0.0f);
// bottom right
m_data.append((float) (x + width));
m_data.append((float) (y + height));
m_data.append(red);
m_data.append(green);
m_data.append(blue);
m_data.append(0.0f);
m_data.append(0.0f);
// top right
m_data.append((float) (x + width));
m_data.append((float) y);
m_data.append(red);
m_data.append(green);
m_data.append(blue);
m_data.append(0.0f);
m_data.append(0.0f);
} }
void Uploader::gotCopyRect(const int src_x, const int src_y, const int width, const int height, const int dest_x, const int dest_y) void Uploader::gotCopy(const int src_x, const int src_y, const int width, const int height, const int dest_x, const int dest_y)
{ {
float texcoord[] = {(float) src_x, (float) (src_y + height), float texcoord[] = {(float) src_x, (float) (src_y + height),
(float) src_x, (float) src_y, (float) src_x, (float) src_y,
...@@ -79,229 +102,227 @@ void Uploader::gotCopyRect(const int src_x, const int src_y, const int width, co ...@@ -79,229 +102,227 @@ void Uploader::gotCopyRect(const int src_x, const int src_y, const int width, co
QOpenGLFramebufferObject fbo(width, height); QOpenGLFramebufferObject fbo(width, height);
fbo.bind(); fbo.bind();
m_functions->glViewport(0, 0, width, height); m_functions->glViewport(0, 0, width, height);
m_copyProgram.setAttributeArray("texcoord", GL_FLOAT, texcoord, 2); m_program.setAttributeArray("texcoord", GL_FLOAT, texcoord, 2);
m_functions->glBindTexture(GL_TEXTURE_2D, m_FBOTexture); m_functions->glBindTexture(GL_TEXTURE_2D, m_FBOTexture);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
m_functions->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); m_functions->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
m_copy_textures->append(fbo.takeTexture()); m_textures->append(fbo.takeTexture());
m_functions->glBindTexture(GL_TEXTURE_2D, 0);
// bottom left // bottom left
m_copy_data.append((float) dest_x); m_data.append((float) dest_x);
m_copy_data.append((float) (dest_y + height)); m_data.append((float) (dest_y + height));
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
// top left // top left
m_copy_data.append((float) dest_x); m_data.append((float) dest_x);
m_copy_data.append((float) dest_y); m_data.append((float) dest_y);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(1.0f); m_data.append(1.0f);
// bottom right // bottom right
m_copy_data.append((float) (dest_x + width)); m_data.append((float) (dest_x + width));
m_copy_data.append((float) (dest_y + height)); m_data.append((float) (dest_y + height));
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
m_copy_data.append(1.0f); m_data.append(1.0f);
m_copy_data.append(0.0f); m_data.append(0.0f);
// top right // top right
m_copy_data.append((float) (dest_x + width)); m_data.append((float) (dest_x + width));
m_copy_data.append((float) dest_y); m_data.append((float) dest_y);
m_copy_data.append(0.0f);
m_copy_data.append(0.0f);
m_copy_data.append(0.0f);
m_copy_data.append(1.0f); m_data.append(0.0f);
m_copy_data.append(1.0f); m_data.append(0.0f);
m_data.append(0.0f);
m_copy_count++; m_data.append(1.0f);
m_data.append(1.0f);
} }
void Uploader::gotFillRect(const int x, const int y, const int width, const int height, const float red, const float green, const float blue) void Uploader::gotBitmap(const QByteArray &bitmap, const quint32 x, const quint32 y,
const quint32 width, const quint32 height, const GLenum format, const GLenum type)
{ {
// |---|---|---|---|---| quint32 real_width = qNextPowerOfTwo(width - 1);
// | X | Y | R | G | B | quint32 real_height = qNextPowerOfTwo(height - 1);
// |---|---|---|---|---|
// NOTE: -coordinates are transformed to normalized device coordinates in the vertex shader GLuint id;
// -coordinates and colors are extended to vec4 in the vertex shader m_functions->glGenTextures(1, &id);
// -OpenGL ES 2.0 does not support integer values as input, m_functions->glBindTexture(GL_TEXTURE_2D, id);
// thus we need to cast to float on the CPU side :( m_functions->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, real_width, real_height, 0, format, type, NULL);
m_functions->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, bitmap.constData());
m_textures->append(id);
float bottom = (float) height / (float) real_height;
float right = (float) width / (float) real_width;
// bottom left // bottom left
m_fill_data.append((float) x); m_data.append((float) x);
m_fill_data.append((float) (y + height)); m_data.append((float) (y + height));
m_fill_data.append(red);
m_fill_data.append(green); m_data.append(0.0f);
m_fill_data.append(blue); m_data.append(0.0f);
m_fill_data.append(0.0f); m_data.append(0.0f);
m_fill_data.append(0.0f);
m_data.append(0.0f);
m_data.append(bottom);
// top left // top left
m_fill_data.append((float) x); m_data.append((float) x);
m_fill_data.append((float) y); m_data.append((float) y);
m_fill_data.append(red);
m_fill_data.append(green); m_data.append(0.0f);
m_fill_data.append(blue); m_data.append(0.0f);
m_fill_data.append(0.0f); m_data.append(0.0f);
m_fill_data.append(0.0f);
m_data.append(0.0f);
m_data.append(0.0f);
// bottom right // bottom right
m_fill_data.append((float) (x + width)); m_data.append((float) (x + width));
m_fill_data.append((float) (y + height)); m_data.append((float) (y + height));
m_fill_data.append(red);
m_fill_data.append(green); m_data.append(0.0f);
m_fill_data.append(blue); m_data.append(0.0f);
m_fill_data.append(0.0f); m_data.append(0.0f);
m_fill_data.append(0.0f);
m_data.append(right);
m_data.append(bottom);
// top right // top right
m_fill_data.append((float) (x + width)); m_data.append((float) (x + width));
m_fill_data.append((float) y); m_data.append((float) y);
m_fill_data.append(red);
m_fill_data.append(green); m_data.append(0.0f);
m_fill_data.append(blue); m_data.append(0.0f);
m_fill_data.append(0.0f); m_data.append(0.0f);
m_fill_data.append(0.0f);
m_data.append(right);
m_fill_count++; m_data.append(0.0f);
} }
void Uploader::gotBitmap(const QImage &image, const quint32 x, const quint32 y, const quint32 width, const quint32 height) // Allocate storage for the image
int Uploader::gotJpeg(const quint32 x, const quint32 y, const quint32 width, const quint32 height)
{ {
QImage img = image.convertToFormat(QImage::Format_RGBA8888); m_jpegs++;
// "This function returns the nearest power of two greater than value." // "This function returns the nearest power of two greater than value."
// We need greater than or equal // We need greater than or equal
quint32 real_width = qNextPowerOfTwo(width - 1); quint32 real_width = qNextPowerOfTwo(width - 1);
quint32 real_height = qNextPowerOfTwo(height - 1); quint32 real_height = qNextPowerOfTwo(height - 1);
GLuint id;
m_functions->glGenTextures(1, &id);
m_functions->glBindTexture(GL_TEXTURE_2D, id);
m_functions->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, real_width, real_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
m_textures->append(id);
float bottom = (float) height / (float) real_height; float bottom = (float) height / (float) real_height;
float right = (float) width / (float) real_width; float right = (float) width / (float) real_width;
m_functions->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
QOpenGLTexture * tex = new QOpenGLTexture(QOpenGLTexture::Target2D);
tex->setSize(real_width, real_height);
tex->setMipLevels(1);
tex->setFormat(QOpenGLTexture::RGBAFormat);
tex->setMinMagFilters(QOpenGLTexture::Nearest, QOpenGLTexture::Nearest);
tex->setWrapMode(QOpenGLTexture::ClampToEdge);
tex->allocateStorage(QOpenGLTexture::RGBA, QOpenGLTexture::UInt8);
tex->bind();
m_functions->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, img.constBits());
tex->release();
// TODO: use a single texture
m_draw_textures->append(tex);
// bottom left // bottom left
m_draw_data.append((float) x); m_data.append((float) x);
m_draw_data.append((float) (y + height)); m_data.append((float) (y + height));
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(bottom); m_data.append(bottom);
// top left // top left
m_draw_data.append((float) x); m_data.append((float) x);
m_draw_data.append((float) y); m_data.append((float) y);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
// bottom right // bottom right
m_draw_data.append((float) (x + width)); m_data.append((float) (x + width));
m_draw_data.append((float) (y + height)); m_data.append((float) (y + height));
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(right); m_data.append(right);
m_draw_data.append(bottom); m_data.append(bottom);
// top right // top right
m_draw_data.append((float) (x + width)); m_data.append((float) (x + width));
m_draw_data.append((float) y); m_data.append((float) y);
m_data.append(0.0f);
m_data.append(0.0f);
m_data.append(0.0f);
m_draw_data.append(0.0f); m_data.append(right);
m_draw_data.append(0.0f); m_data.append(0.0f);
m_draw_data.append(0.0f);
m_draw_data.append(right); return m_textures->size() - 1;
m_draw_data.append(0.0f); }
m_draw_count++; void Uploader::finishedJpeg(const QImage &image, const quint32 width, const quint32 height, const int index)
{
m_jpegs--;
m_functions->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
m_functions->glBindTexture(GL_TEXTURE_2D, m_textures->at(index));
m_functions->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, image.constBits());
if(m_jpegs == 0 && m_finished) {
m_functions->glBindTexture(GL_TEXTURE_2D, 0);
m_functions->glFinish();
emit uploadFinished();
}
} }
void Uploader::finishedUpdate() void Uploader::finishedUpdate()
{ {
unsigned int fillSize = m_fill_data.size() * sizeof(float); unsigned int size = m_data.size() * sizeof(float);
unsigned int copySize = m_copy_data.size() * sizeof(float); unsigned int nextPowerOfTwo = qNextPowerOfTwo(size);
unsigned int drawSize = m_draw_data.size() * sizeof(float);
unsigned int sumSize = fillSize + copySize + drawSize;
m_vertices->bind(); m_vertices.bind();
if(sumSize > m_allocated) { if(nextPowerOfTwo > m_allocated) {
m_vertices->allocate(sumSize); m_vertices.allocate(nextPowerOfTwo);
m_allocated = sumSize; m_allocated = nextPowerOfTwo;
} }
if(fillSize > 0) m_vertices.write(0, m_data.constData(), size);
m_vertices->write(0, m_fill_data.constData(), fillSize);
if(copySize > 0)
m_vertices->write(fillSize, m_copy_data.constData(), copySize);
if(drawSize > 0)
m_vertices->write(fillSize + copySize, m_draw_data.constData(), drawSize);
m_functions->glGetError();
m_vertices->release(); m_vertices.release();
m_functions->glFinish();
}
unsigned int Uploader::fill_count() const
{
return m_fill_count;
}
unsigned int Uploader::copy_count() const if(m_jpegs == 0) {
{ m_functions->glBindTexture(GL_TEXTURE_2D, 0);
return m_copy_count; emit uploadFinished();
} } else {
m_finished = true;
unsigned int Uploader::draw_count() const }
{
return m_draw_count;
} }
QSharedPointer<QVector<GLuint>> Uploader::copy_textures() void Uploader::swapBuffers()
{ {
return m_copy_textures; // This thread should finish uploading
// The other thread should finish rendering from the other thread
m_functions->glFinish();
} }
QSharedPointer<QVector<QOpenGLTexture *>> Uploader::draw_textures() QSharedPointer<QVector<GLuint>> Uploader::textures() const
{ {
return m_draw_textures; return m_textures;
} }
QSharedPointer<QOpenGLBuffer> Uploader::vertices() const QOpenGLBuffer Uploader::vertices() const
{ {
return m_vertices; return m_vertices;
} }
...@@ -309,5 +330,5 @@ QSharedPointer<QOpenGLBuffer> Uploader::vertices() const ...@@ -309,5 +330,5 @@ QSharedPointer<QOpenGLBuffer> Uploader::vertices() const
void Uploader::changeFBOTexture(const unsigned int FBOTexture, const QMatrix4x4 &ortho) void Uploader::changeFBOTexture(const unsigned int FBOTexture, const QMatrix4x4 &ortho)
{ {
m_FBOTexture = FBOTexture; m_FBOTexture = FBOTexture;
m_copyProgram.setUniformValue("ortho", ortho); m_program.setUniformValue("ortho", ortho);
} }
uploader.h
...@@ -17,7 +17,15 @@ ...@@ -17,7 +17,15 @@
#include <QtAlgorithms> #include <QtAlgorithms>
#include <QSharedPointer> #include <QSharedPointer>
#include <QtMath> #include <QtMath>
// #include <GLES/gl2ext.h>
class Bitmap {
public:
QByteArray data;
int x;
int y;
int width;
int height;
};
class Uploader : public QObject class Uploader : public QObject
{ {
...@@ -25,51 +33,43 @@ class Uploader : public QObject ...@@ -25,51 +33,43 @@ class Uploader : public QObject
public: public:
Uploader(QObject *parent = Q_NULLPTR); Uploader(QObject *parent = Q_NULLPTR);
~Uploader(); ~Uploader();
void create_context(QOpenGLContext *context);
void startedUpdate();
void gotCopyRect(const int src_x, const int src_y, const int width, const int height, const int dest_x, const int dest_y);
void gotFillRect(const int x, const int y, const int width, const int height, const float red, const float green, const float blue);
void gotBitmap(const QImage &image, const quint32 x, const quint32 y, const quint32 width, const quint32 height);
void finishedUpdate();
void setFramebufferHeight(int framebufferHeight);
unsigned int fill_count() const;
unsigned int copy_count() const;
unsigned int draw_count() const;
QSharedPointer<QVector<GLuint>> copy_textures(); QOpenGLBuffer vertices() const;
QSharedPointer<QVector<QOpenGLTexture *>> draw_textures(); QSharedPointer<QVector<GLuint>> textures() const;
QSharedPointer<QOpenGLBuffer> vertices() const; // VNC events
void gotCopy(const int src_x, const int src_y, const int width, const int height, const int dest_x, const int dest_y);
void gotFill(const int x, const int y, const int width, const int height, const float red, const float green, const float blue);
int gotJpeg(const quint32 x, const quint32 y, const quint32 width, const quint32 height);
void gotBitmap(const QByteArray &bitmap, const quint32 x, const quint32 y, const quint32 width, const quint32 height, const GLenum format, const GLenum type);
void finishedUpdate();
private: private:
int m_framebufferHeight;
QOffscreenSurface m_surface; QOffscreenSurface m_surface;
QOpenGLContext m_uploader_context; QOpenGLContext m_context;
QOpenGLFunctions *m_functions; QOpenGLFunctions *m_functions;
QSharedPointer<QOpenGLBuffer> m_vertices; QOpenGLBuffer m_vertices;
unsigned int m_allocated; unsigned int m_allocated;
QSharedPointer<QVector<GLuint>> m_textures;
QOpenGLShaderProgram m_copyProgram; QOpenGLShaderProgram m_program;
GLuint m_FBOTexture; GLuint m_FBOTexture;
unsigned int m_fill_count; QVector<float> m_data;
QVector<float> m_fill_data; QVector<Bitmap *> m_bitmaps;
int m_jpegs;
unsigned int m_copy_count; bool m_finished;
QVector<float> m_copy_data;
QSharedPointer<QVector<GLuint>> m_copy_textures;
unsigned int m_draw_count;
QVector<float> m_draw_data;
QSharedPointer<QVector<QOpenGLTexture*>> m_draw_textures;
uchar m_decoders_running;
void swapBuffers();
signals:
void uploadFinished();
public slots: public slots:
void changeFBOTexture(const unsigned int FBOTexture, const QMatrix4x4 &ortho); void changeFBOTexture(const unsigned int FBOTexture, const QMatrix4x4 &ortho);
void createContext(QOpenGLContext *context);
void cleanup();
void finishedJpeg(const QImage &image, const quint32 width, const quint32 height, int index);
}; };
#endif // UPLOADER_H #endif // UPLOADER_H
vncrenderer.cpp
...@@ -2,12 +2,12 @@ ...@@ -2,12 +2,12 @@
#include <cstring> #include <cstring>
VncRenderer::VncRenderer(QQuickWindow *window, VncRenderer::VncRenderer(QQuickWindow *window,
QSharedPointer<QOpenGLBuffer> vertices, QOpenGLBuffer vertices,
QSharedPointer<QVector<GLuint>> copy_textures, QSharedPointer<QVector<GLuint>> textures,
QSharedPointer<QVector<QOpenGLTexture*>> draw_textures,
QObject *parent) : QObject *parent) :
QObject(parent), m_clear(true), m_window(window), m_vertices(vertices), m_copy_textures(copy_textures), m_draw_textures(draw_textures) QObject(parent), m_window(window), m_vertices(vertices), m_textures(textures), m_rendered(false)
{ {
connect(m_window, &QQuickWindow::frameSwapped, this, &VncRenderer::frameSwapped);
m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, "draw_shader.vsh"); m_program.addShaderFromSourceFile(QOpenGLShader::Vertex, "draw_shader.vsh");
m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, "draw_shader.fsh"); m_program.addShaderFromSourceFile(QOpenGLShader::Fragment, "draw_shader.fsh");
m_program.bind(); m_program.bind();
...@@ -20,19 +20,13 @@ VncRenderer::VncRenderer(QQuickWindow *window, ...@@ -20,19 +20,13 @@ VncRenderer::VncRenderer(QQuickWindow *window,
void VncRenderer::render() void VncRenderer::render()
{ {
/*if(m_frameCount == 0) static QTime frameTime;
m_time.start(); qDebug() << qRound(1000.0 / frameTime.elapsed());
else frameTime.restart();
qDebug() << (float(m_frameCount) / (float(m_time.elapsed()) / 1000.0f));
m_frameCount++;*/
if(m_clear) {
m_functions->glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
m_functions->glClear(GL_COLOR_BUFFER_BIT);
m_clear = false;
}
m_program.bind(); m_program.bind();
m_vertices->bind(); m_vertices.bind();
m_program.setAttributeBuffer("position", GL_FLOAT, 0 * sizeof(float), 2, 7 * sizeof(float)); m_program.setAttributeBuffer("position", GL_FLOAT, 0 * sizeof(float), 2, 7 * sizeof(float));
m_program.setAttributeBuffer("color", GL_FLOAT, 2 * sizeof(float), 3, 7 * sizeof(float)); m_program.setAttributeBuffer("color", GL_FLOAT, 2 * sizeof(float), 3, 7 * sizeof(float));
m_program.setAttributeBuffer("texcoord", GL_FLOAT, 5 * sizeof(float), 2, 7 * sizeof(float)); m_program.setAttributeBuffer("texcoord", GL_FLOAT, 5 * sizeof(float), 2, 7 * sizeof(float));
...@@ -40,28 +34,18 @@ void VncRenderer::render() ...@@ -40,28 +34,18 @@ void VncRenderer::render()
m_program.enableAttributeArray("color"); m_program.enableAttributeArray("color");
m_program.enableAttributeArray("texcoord"); m_program.enableAttributeArray("texcoord");
for(unsigned int i = 0; i < m_fill_count; i++) for(int i = 0; i < m_textures->length(); i++) {
m_functions->glBindTexture(GL_TEXTURE_2D, m_textures->at(i));
if(m_textures->at(i) != 0) {
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
m_functions->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
m_functions->glDrawArrays(GL_TRIANGLE_STRIP, i * 4, 4); m_functions->glDrawArrays(GL_TRIANGLE_STRIP, i * 4, 4);
for(unsigned int i = 0; i < m_copy_count; i++) {
m_functions->glBindTexture(GL_TEXTURE_2D, m_copy_textures->at(i));
m_functions->glDrawArrays(GL_TRIANGLE_STRIP, (m_fill_count + i) * 4, 4);
}
for(unsigned int i = 0; i < m_draw_count; i++) {
m_draw_textures->at(i)->bind();
m_functions->glDrawArrays(GL_TRIANGLE_STRIP, (m_fill_count + m_copy_count + i) * 4, 4);
m_draw_textures->at(i)->release();
} }
m_vertices->release();
m_program.release();
m_functions->glFlush();
m_window->resetOpenGLState(); m_window->resetOpenGLState();
m_rendered = true;
emit finishedRendering();
} }
QOpenGLFramebufferObject *VncRenderer::createFramebufferObject(const QSize &size) QOpenGLFramebufferObject *VncRenderer::createFramebufferObject(const QSize &size)
...@@ -72,20 +56,33 @@ QOpenGLFramebufferObject *VncRenderer::createFramebufferObject(const QSize &size ...@@ -72,20 +56,33 @@ QOpenGLFramebufferObject *VncRenderer::createFramebufferObject(const QSize &size
m_program.setUniformValue("ortho", ortho); m_program.setUniformValue("ortho", ortho);
m_program.release(); m_program.release();
QOpenGLFramebufferObject *framebufferObject = new QOpenGLFramebufferObject(size); QOpenGLFramebufferObjectFormat format;
/* format.setTextureTarget(GL_TEXTURE_2D);
#ifdef GL_RGB8
format.setInternalTextureFormat(GL_RGB8);
#ifdef GL_RGB8_OES
format.setInternalTextureFormat(GL_RGB8_OES);
#else
format.setInternalTextureFormat(GL_RGBA);
#endif*/
QOpenGLFramebufferObject *framebufferObject = new QOpenGLFramebufferObject(size, format);
emit FBOTextureChanged(framebufferObject->texture(), ortho); emit FBOTextureChanged(framebufferObject->texture(), ortho);
return framebufferObject; return framebufferObject;
} }
void VncRenderer::synchronize(QQuickFramebufferObject *object) void VncRenderer::setColorMax(const QVector3D &colorMax)
{ {
QVnc *vnc = static_cast<QVnc*>(object); if(m_program.bind()) {
Dispatcher *dispatcher = vnc->dispatcher(); m_program.setUniformValue("colormax", colorMax);
m_fill_count = dispatcher->fill_count(); m_program.release();
m_copy_count = dispatcher->copy_count(); }
m_draw_count = dispatcher->draw_count(); }
m_program.bind(); void VncRenderer::frameSwapped()
m_program.setUniformValue("colormax", dispatcher->colorMax()); {
m_program.release(); if(m_rendered) {
m_rendered = false;
emit finishedRendering();
}
} }
vncrenderer.h
...@@ -9,40 +9,32 @@ ...@@ -9,40 +9,32 @@
#include <QMatrix4x4> #include <QMatrix4x4>
#include <QOpenGLShaderProgram> #include <QOpenGLShaderProgram>
#include <QOpenGLBuffer> #include <QOpenGLBuffer>
#include <QOpenGLTexture>
#include <QSharedPointer> #include <QSharedPointer>
#include <QTime> #include <QTime>
#include "qvnc.h"
class VncRenderer : public QObject, public QQuickFramebufferObject::Renderer class VncRenderer : public QObject, public QQuickFramebufferObject::Renderer
{ {
Q_OBJECT Q_OBJECT
public: public:
VncRenderer(QQuickWindow *window, VncRenderer(QQuickWindow *window,
QSharedPointer<QOpenGLBuffer> vertices, QOpenGLBuffer vertices,
QSharedPointer<QVector<GLuint>> copy_textures, QSharedPointer<QVector<GLuint>> textures,
QSharedPointer<QVector<QOpenGLTexture*>> draw_textures,
QObject *parent = 0); QObject *parent = 0);
protected: protected:
void render() override; void render() override;
QOpenGLFramebufferObject *createFramebufferObject(const QSize &size) override; QOpenGLFramebufferObject *createFramebufferObject(const QSize &size) override;
void synchronize(QQuickFramebufferObject *) override;
private: private:
QSharedPointer<QOpenGLBuffer> m_vertices;
QOpenGLShaderProgram m_program;
QQuickWindow *m_window; QQuickWindow *m_window;
QOpenGLBuffer m_vertices;
QSharedPointer<QVector<GLuint>> m_textures;
QVector3D m_colorMax;
QOpenGLShaderProgram m_program;
QOpenGLFunctions *m_functions; QOpenGLFunctions *m_functions;
bool m_clear; bool m_rendered;
int m_frameCount; public slots:
QTime m_time; void setColorMax(const QVector3D &colorMax);
private slots:
unsigned int m_fill_count; void frameSwapped();
unsigned int m_copy_count;
unsigned int m_draw_count;
QSharedPointer<QVector<GLuint>> m_copy_textures;
QSharedPointer<QVector<QOpenGLTexture*>> m_draw_textures;
signals: signals:
void FBOTextureChanged(const unsigned int FBOTexture, const QMatrix4x4 &ortho); void FBOTextureChanged(const unsigned int FBOTexture, const QMatrix4x4 &ortho);
void finishedRendering(); void finishedRendering();
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment