В прошлый раз мы решили задачу формирования видео-потока. Теперь займемся сетевой частью. Реализуем передачу видео-потока по сети.

Исправление ошибки

Начнем с исправления одной неприятной ошибки, которая осталась незамеченной в предыдущей части. Она касалась некорректного управления памятью при захвате изображения курсора мыши под Linux.

Проблема заключалась в том, что конструктор QImage не делает глубокую копию переданного буфера с данными изображения. Поэтому память освобождалась и поведение приложения становилось неопределенным (хоть это и было незаметно).

Немного изменим структуру Cursor:

struct Cursor {
    QImage img;
    QPoint pos;

    // Linux-reserved
    QVarLengthArray< quint32 > buffer;
};

А теперь саму функцию получения курсора для Linux:

Cursor DesktopRecorder::captureCursor() const {
    Cursor cursor;

    if( auto curImage = XFixesGetCursorImage( QX11Info::display() ) ) {
        cursor.buffer.resize( curImage->width * curImage->height );
        for( int i = 0; i < cursor.buffer.size(); ++i ) {
            cursor.buffer[ i ] = curImage->pixels[ i ] & 0xffffffff;
        }
        cursor.img = QImage(
            reinterpret_cast< const uchar* >( cursor.buffer.data() ),
            curImage->width,
            curImage->height,
            QImage::Format_ARGB32_Premultiplied
        );
        cursor.pos = QCursor::pos() - QPoint( curImage->xhot, curImage->yhot );
        XFree( curImage );
    }

    return cursor;
}

Проблема решена.

Серверная часть

Для сетевого взаимодействия воспользуемся библиотекой LibQxt. О ней мы уже говорили, когда создавали простой чат, поэтому обойдемся без лишних пояснений.

Модуль назовем RemoteControlServer. Начинаем с заголовочного файла remotecontrolserver.h:

#ifndef REMOTECONTROLSERVER_H
#define REMOTECONTROLSERVER_H

#include <QObject>
#include <QxtRPCPeer>
#include <desktoprecorder.h>

class RemoteControlServer : public QObject {
    Q_OBJECT
public:
    explicit RemoteControlServer( QObject* parent = 0 );

    bool start();

private slots:
    void onClientConnected( quint64 clientID );
    void onClientDisconnected( quint64 clientID );

    void onEnableCursorCapture( quint64, bool enabled );

    void onFrameAvailable( const QImage& frame );

private:
    QxtRPCPeer m_peer;
    ITNotes::DesktopRecorder m_recorder;

};

#endif // REMOTECONTROLSERVER_H

Далее реализация в remotecontrolserver.cpp:

#include "remotecontrolserver.h"

#include <shareddefs.h>

#include <QBuffer>

static const QSize SCALED_FRAME_SIZE = QSize( 900, 550 );

RemoteControlServer::RemoteControlServer( QObject* parent ) : QObject( parent ) {
    connect( &m_peer, SIGNAL( clientConnected( quint64 ) ), SLOT( onClientConnected( quint64 ) ) );
    connect( &m_peer, SIGNAL( clientDisconnected( quint64 ) ), SLOT( onClientDisconnected( quint64 ) ) );

    connect( &m_recorder, SIGNAL( frameAvailable( QImage ) ), SLOT( onFrameAvailable( QImage ) ) );
    m_peer.attachSlot( ENABLE_CURSOR_CAPTURE_SIG, this, SLOT( onEnableCursorCapture( quint64, bool ) ) );
}

bool RemoteControlServer::start() {
    return m_peer.listen( QHostAddress::Any, PORT );
}

void RemoteControlServer::onClientConnected( quint64 clientID ) {
    qDebug() << "Client connected:" << clientID;
    m_recorder.start( 10 );
}

void RemoteControlServer::onClientDisconnected( quint64 clientID ) {
    qDebug() << "Client disconnected:" << clientID;
    m_recorder.stop();
}

void RemoteControlServer::onEnableCursorCapture( quint64, bool enabled ) {
    m_recorder.enableCursorCapture( enabled );
}

void RemoteControlServer::onFrameAvailable( const QImage& frame ) {
    QByteArray ba;
    QBuffer buffer( &ba );
    frame.scaled( SCALED_FRAME_SIZE, Qt::KeepAspectRatio, Qt::SmoothTransformation ).save( &buffer, "JPG" );

    m_peer.call( FRAME_AVAILABLE_SIG, qCompress( ba, 9 ), frame.size() );
}

Сетевое взаимодействие двунаправленное. Сервер перенаправляем кадры видео-потока, полученные от DesktopRecorder. А Клиент может включать/отключать захват курсора мыши. Связь осуществляется через именованные функции FRAME_AVAILABLE_SIG и ENABLE_CURSOR_CAPTURE_SIG, объявленные в shareddefs.h:

#ifndef SHAREDDEFS_H
#define SHAREDDEFS_H

#include <QString>

static const char* const FRAME_AVAILABLE_SIG = "FRAME_AVAILABLE_SIG";
static const char* const ENABLE_CURSOR_CAPTURE_SIG = "ENABLE_CURSOR_CAPTURE_SIG";

static const int PORT = 9900;

#endif // SHAREDDEFS_H

В этом же файле задана константа PORT, которая определяет то, на каком порту работает сервер.

Обратим внимание на то, что Сервер не просто отправляет кадры в том виде, в котором они приходят от DesktopRecorder, а уменьшает их масштаб, кодирует их в JPG и дополнительно сжимает с помощью qCompress(). В зависимости от исходного разрешения кадра размер (в байтах) получившегося изображения оказывается существенно меньше. Однако это приводит к заметной потере качества.

Также мы передаем исходный размер изображения, чтобы потом иметь возможность согласовывать координаты мыши.

Такой метод кодирования очень примитивен, и не рекомендуется для реального использования. При увеличении качества изображения плавность трансляции на клиентской стороне в целом сохраняется за счет буферизации видео-потока, но происходит серьезное запаздывание кадров, что абсолютно неприемлемо для наших дальнейших целей. Более оптимальным было бы жесткое выпадение кадров, но и это не является наилучшим решением, поэтому пока что не будем ничего усложнять.

Алгоритм получился не слишком адаптивным. Я настроил его на оптимальное соотношение частоты кадров/качества картинки для своей локальной сети. На своей системе вы можете покрутить константой SCALED_FRAME_SIZE, которая определяет масштаб пересылаемого кадра.

Клиентская часть

Позаимствуем внешний вид клиентского сетевого приложения от виджета DesktopRecorderDemo из прошлой части. При запуске Сервера на Linux и Клиента на Windows (допустимы и любые другие комбинации) имеем следующее:

Обращаю внимание, что на форме виджета можно указать ip-адрес или имя хоста для сервера, к которому нужно подключиться.

Заголовочный файл remotecontrolclientwidget.h:

#ifndef REMOTECONTROLCLIENTWIDGET_H
#define REMOTECONTROLCLIENTWIDGET_H

#include <QWidget>
#include <QxtRPCPeer>

namespace Ui {
class RemoteControlClientWidget;
}

class RemoteControlClientWidget : public QWidget {
    Q_OBJECT

public:
    explicit RemoteControlClientWidget( QWidget* parent = 0 );
    ~RemoteControlClientWidget();

private slots:
    void onStartStop();
    void onFrameAvailable( const QByteArray& imgData, const QSize& realSize );

    void onConnectedToServer();
    void onDisconnectedFromServer();
    void onServerError( const QAbstractSocket::SocketError& error );
    void refreshConnection();

private:
    Ui::RemoteControlClientWidget* ui;

    QxtRPCPeer m_peer;

    bool m_connected;
};

#endif // REMOTECONTROLCLIENTWIDGET_H

И реализация remotecontrolclientwidget.cpp:

#include "remotecontrolclientwidget.h"
#include "ui_remotecontrolclientwidget.h"

#include <shareddefs.h>

#include <QTimer>

static const int CONNECTION_RETRY_TIME_OUT_MSEC = 2 * 1000; // 2 секунды

RemoteControlClientWidget::RemoteControlClientWidget( QWidget* parent ) :
    QWidget( parent ),
    ui( new Ui::RemoteControlClientWidget ),
    m_connected( false ) {
    ui->setupUi( this );

    ui->stopBn->hide();

    connect( ui->startBn, SIGNAL( clicked( bool ) ), SLOT( onStartStop() ) );
    connect( ui->stopBn, SIGNAL( clicked( bool ) ), SLOT( onStartStop() ) );

    connect( &m_peer, SIGNAL( connectedToServer() ), SLOT( onConnectedToServer() ) );
    connect( &m_peer, SIGNAL( disconnectedFromServer() ), SLOT( onDisconnectedFromServer() ) );
    connect(
        &m_peer,
        SIGNAL( serverError( const QAbstractSocket::SocketError& ) ),
        SLOT( onServerError( const QAbstractSocket::SocketError& ) )
    );

    m_peer.attachSlot( FRAME_AVAILABLE_SIG, this, SLOT( onFrameAvailable( QByteArray, QSize ) ) );
    m_peer.attachSignal( ui->captureCursorChkBox, SIGNAL( clicked( bool ) ), ENABLE_CURSOR_CAPTURE_SIG );
}

RemoteControlClientWidget::~RemoteControlClientWidget() {
    delete ui;
}

void RemoteControlClientWidget::onStartStop() {
    if( ui->startBn->isVisible() ) {
        refreshConnection();
    } else {
        m_peer.disconnectServer();
        m_connected = false;
    }

    ui->startBn->setVisible( !ui->startBn->isVisible() );
    ui->stopBn->setVisible( !ui->stopBn->isVisible() );
    ui->ipEd->setEnabled( !ui->stopBn->isVisible() );
}

void RemoteControlClientWidget::onFrameAvailable( const QByteArray& imgData, const QSize& realSize ) {
    Q_UNUSED( realSize )

    auto img = QImage::fromData( qUncompress( imgData ), "JPG" );
    ui->viewLbl->setPixmap( QPixmap::fromImage( img ).scaled(
        ui->viewLbl->size(),
        Qt::KeepAspectRatio,
        Qt::SmoothTransformation
    ));
}

void RemoteControlClientWidget::onConnectedToServer() {
    qDebug() << "Connected to server";
    m_connected = true;

    ui->startBn->setVisible( false );
    ui->stopBn->setVisible( true );
    ui->ipEd->setEnabled( false );

    m_peer.call( ENABLE_CURSOR_CAPTURE_SIG, ui->captureCursorChkBox->isChecked() );
}

void RemoteControlClientWidget::onDisconnectedFromServer() {
    qDebug() << "Disconnected from server";
    m_connected = false;
}

void RemoteControlClientWidget::onServerError( const QAbstractSocket::SocketError& error ) {
    qDebug() << "Server error:" << QString::number( error, 16 );
    m_connected = false;
    if( ui->stopBn->isVisible() ) {
        QTimer::singleShot( CONNECTION_RETRY_TIME_OUT_MSEC, this, SLOT( refreshConnection() ) );
    }
}

void RemoteControlClientWidget::refreshConnection() {
    if( !m_connected ) {
        m_peer.connect( ui->ipEd->text(), PORT );
    }
}

Выводы

Видео-трансляции так или иначе передается по сети. Качество картинки заметно уступает TeamViewer-у, и ближе к тому, что может предложить Skype в режиме показа экрана. Но это уже вопрос технологий кодирования видео-потоков, поэтому отложим его до лучших времен. Следующий шаг - передача действий мыши…

Исходники

 Скачать исходники примера RemoteControlDemo

Также они доступны на github: https://github.com/itnotesblog/RemoteControlDemo под тэгом v.0.2.1.

Сборка проекта проверялась под Linux и Windows с Qt 4.8.4 и компиляторами gcc (x64) и msvc.2010 (32-bit) соответственно.

Обратите внимание, что у проекта есть зависимость от LibQxt. Вам понадобится либо использовать совместимый компилятор, либо пересобрать LibQxt самостоятельно из исходников.

Для Windows-версии dll-файлы LibQxt расположены в lib.win32/LibQxt/. Не забудьте скопировать их в bin/(debug|release)/.

Похожие публикации