Differential D6186 Diff 15554 src/server/remote_access_interface.cpp

Changeset View

Standalone View

src/server/remote_access_interface.cpp

This file was added.

		1		/****************************************************************************
		2		Copyright 2016 Oleg Chernovskiy <kanedias@xaker.ru>
		3
		4		This library is free software; you can redistribute it and/or
		5		modify it under the terms of the GNU Lesser General Public
		6		License as published by the Free Software Foundation; either
		7		version 2.1 of the License, or (at your option) version 3, or any
		8		later version accepted by the membership of KDE e.V. (or its
		9		successor approved by the membership of KDE e.V.), which shall
		10		act as a proxy defined in Section 6 of version 3 of the license.
		11
		12		This library is distributed in the hope that it will be useful,
		13		but WITHOUT ANY WARRANTY; without even the implied warranty of
		14		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15		Lesser General Public License for more details.
		16
		17		You should have received a copy of the GNU Lesser General Public
		18		License along with this library. If not, see <http://www.gnu.org/licenses/>.
		19		****************************************************************************/
		20		#include "remote_access_interface.h"
		21		#include "remote_access_interface_p.h"
		22		#include "display.h"
		23		#include "global_p.h"
		24		#include "resource_p.h"
		25		#include "logging_p.h"
		26
		27		#include <wayland-remote-access-server-protocol.h>
		28
		29		#include <QHash>
		30		#include <QMutableHashIterator>
		31
		32		#include <functional>
		33
		34		namespace KWayland
		35		{
		36		namespace Server
		37		{
		38
		39		class BufferHandle::Private // @see gbm_import_fd_data
		40		{
		41		public:
		42		// Note that on client side received fd number will be different
		43		// and meaningful only for client process!
		44		// Thus we can use server-side fd as an implicit unique id
		45		qint32 fd = 0; ///< also internal buffer id for client
		46		quint32 width = 0;
		47		quint32 height = 0;
		48		quint32 stride = 0;
		49		quint32 format = 0;
		50		};
		51
		52		BufferHandle::BufferHandle()
		53		: d(new Private)
		54		{
		55		}
		56
		57		BufferHandle::~BufferHandle()
		58		{
		59		}
		60
		61		void BufferHandle::setFd(qint32 fd)
		62		{
		63		d->fd = fd;
		64		}
		65
		66		qint32 BufferHandle::fd() const
		67		{
		68		return d->fd;
		69		}
		70
		71		void BufferHandle::setSize(quint32 width, quint32 height)
		72		{
		73		d->width = width;
		74		d->height = height;
		75		}
		76
		77		quint32 BufferHandle::width() const
		78		{
		79		return d->width;
		80		}
		81
		82		quint32 BufferHandle::height() const
		83		{
		84		return d->height;
		85		}
		86
		87		void BufferHandle::setStride(qint32 stride)
		88		{
		89		d->stride = stride;
		90		}
		91
		92
		93		quint32 BufferHandle::stride() const
		94		{
		95		return d->stride;
		96		}
		97
		98		void BufferHandle::setFormat(quint32 format)
		99		{
		100		d->format = format;
		101		}
		102
		103		quint32 BufferHandle::format() const
		104		{
		105		return d->format;
		106		}
		107
		108		/**
		109		* @brief helper struct for manual reference counting.
		110		* automatic counting via QSharedPointer is no-go here as we hold strong reference in sentBuffers.
		111		*/
		112		struct BufferHolder
		113		{
		114		const BufferHandle *buf;
		115		quint32 counter;
		116		};
		117
		118		class RemoteAccessManagerInterface::Private : public Global::Private
		119		{
		120		public:
		121		Private(RemoteAccessManagerInterface q, Display d);
		122		virtual ~Private();
		123
		124		/**
		125		* @brief Send buffer ready notification to all connected clients
		126		* @param buf buffer containing GBM-related params
		127		*/
		128		void sendBufferReady(const BufferHandle *buf);
		129		/**
		130		* @brief Release all bound buffers associated with this resource
		131		* @param resource one of bound clients
		132		*/
		133		void release(wl_resource *resource);
		134
		135		/**
		136		* Clients of this interface.
		137		* This may be screenshot app, video capture app,
		138		* remote control app etc.
		139		*/
		140		QList<wl_resource *> clients;
		141		private:
		142		// methods
		143		static void unbind(wl_resource *resource);
		144		static Private cast(wl_resource r) {
		145		return reinterpret_cast<Private*>(wl_resource_get_user_data(r));
		146		}
		147		static void getBufferCallback(wl_client client, wl_resource resource, uint32_t buffer, uint32_t internalBufId);
		148		static void releaseCallback(wl_client client, wl_resource resource);
		149		void bind(wl_client *client, uint32_t version, uint32_t id) override;
		150
		151		/**
		152		* @brief Unreferences counter and frees buffer when it reaches zero
		153		* @param buf holder to decrease reference counter on
		154		* @return true if buffer was released, false otherwise
		155		*/
		156		bool unref(BufferHolder &buf);
		157
		158		// fields
		159		static const struct org_kde_kwin_remote_access_manager_interface s_interface;
		160		static const quint32 s_version;
		161
		162		RemoteAccessManagerInterface *q;
		163
		164		/**
		165		* Buffers that were sent but still not acked by server
		166		* Keys are fd numbers as they are unique
		167		**/
		168		QHash<qint32, BufferHolder> sentBuffers;
		169		};
		170
		171		const quint32 RemoteAccessManagerInterface::Private::s_version = 1;
		172
		173		RemoteAccessManagerInterface::Private::Private(RemoteAccessManagerInterface q, Display d)
		174		: Global::Private(d, &org_kde_kwin_remote_access_manager_interface, s_version)
		175		, q(q)
		176		{
		177		}
		178
		179		void RemoteAccessManagerInterface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
		180		{
		181		// create new client resource
		182		auto c = display->getConnection(client);
		183		wl_resource *resource = c->createResource(&org_kde_kwin_remote_access_manager_interface, qMin(version, s_version), id);
		184		if (!resource) {
		185		wl_client_post_no_memory(client);
		186		return;
		187		}
		188		wl_resource_set_implementation(resource, &s_interface, this, unbind);
		189
		190		// add newly created client resource to the list
		191		clients << resource;
		192		}
		193
		194		void RemoteAccessManagerInterface::Private::sendBufferReady(const BufferHandle *buf)
		195		{
		196		BufferHolder holder {buf, 0};
		197		// notify clients
		198		qCDebug(KWAYLAND_SERVER) << "Server buffer sent: fd" << buf->fd();
		199		for (auto res : clients) {
		200		org_kde_kwin_remote_access_manager_send_buffer_ready(res, buf->fd());
		201		holder.counter++;
		202		}
		203		// store buffer locally, clients will ask it later
		204		sentBuffers[buf->fd()] = holder;
		205		}
		206
		207		#ifndef DOXYGEN_SHOULD_SKIP_THIS
		208		const struct org_kde_kwin_remote_access_manager_interface RemoteAccessManagerInterface::Private::s_interface = {
		209		getBufferCallback,
		210		releaseCallback
		211		};
		212		#endif
		213
		214		void RemoteAccessManagerInterface::Private::getBufferCallback(wl_client client, wl_resource resource, uint32_t buffer, uint32_t internalBufId)
		215		{
		216		Private *p = cast(resource);
		217
		218		// client asks for buffer we earlier announced, we must have it
		219		if (Q_UNLIKELY(!p->sentBuffers.contains(internalBufId))) { // no such buffer (?)
		220		wl_resource_post_no_memory(resource);
		221		return;
		222		}
		223
		224		BufferHolder &bh = p->sentBuffers[internalBufId];
		225		auto rbuf = new RemoteBufferInterface(p->q, resource, bh.buf);
		226		rbuf->create(p->display->getConnection(client), wl_resource_get_version(resource), buffer);
		227		if (!rbuf->resource()) {
		228		wl_resource_post_no_memory(resource);
		229		delete rbuf;
		230		return;
		231		}
		232
		233		QObject::connect(rbuf, &QObject::destroyed, [p, rbuf, resource, &bh] {
		234		if (!p->clients.contains(resource)) {
		235		// remote buffer destroy confirmed after client is already gone
		236		// all relevant buffers are already unreferenced
		237		return;
		238		}
		239
		240		qCDebug(KWAYLAND_SERVER) << "Remote buffer returned, client" << wl_resource_get_id(resource)
		241		<< ", id" << rbuf->id()
		242		<< ", fd" << bh.buf->fd();
		243		if (p->unref(bh)) {
		244		p->sentBuffers.remove(bh.buf->fd());
		245		}
		246		});
		247
		248		// send buffer params
		249		rbuf->passFd();
		250		}
		251
		252		void RemoteAccessManagerInterface::Private::releaseCallback(wl_client client, wl_resource resource)
		253		{
		254		Q_UNUSED(client);
		255		unbind(resource);
		256		}
		257
		258		bool RemoteAccessManagerInterface::Private::unref(BufferHolder &bh)
		259		{
		260		bh.counter--;
		261		if (!bh.counter) {
		262		// no more clients using this buffer
		263		qCDebug(KWAYLAND_SERVER) << "Buffer released, fd" << bh.buf->fd();
		264		emit q->bufferReleased(bh.buf);
		265		return true;
		266		}
		267
		268		return false;
		269		}
		270
		271		void RemoteAccessManagerInterface::Private::unbind(wl_resource *resource)
		272		{
		273		// we're unbinding, all sent buffers for this client are now effectively invalid
		274		Private *p = cast(resource);
		275		p->release(resource);
		276		}
		277
		278		void RemoteAccessManagerInterface::Private::release(wl_resource *resource)
		279		{
		280		// all holders should decrement their counter as one client is gone
		281		QMutableHashIterator<qint32, BufferHolder> itr(sentBuffers);
		282		while (itr.hasNext()) {
		283		BufferHolder &bh = itr.next().value();
		284		if (unref(bh)) {
		285		itr.remove();
		286		}
		287		}
		288
		289		clients.removeAll(resource);
		290		}
		291
		292		RemoteAccessManagerInterface::Private::~Private()
		293		{
		294		// server deletes created interfaces, release all held buffers
		295		auto c = clients; // shadow copy
		296		for (auto res : c) {
		297		release(res);
		298		}
		299		}
		300
		301		RemoteAccessManagerInterface::RemoteAccessManagerInterface(Display display, QObject parent)
		302		: Global(new Private(this, display), parent)
		303		{
		304		}
		305
		306		void RemoteAccessManagerInterface::sendBufferReady(const BufferHandle *buf)
		307		{
		308		Private priv = reinterpret_cast<Private >(d.data());
		309		priv->sendBufferReady(buf);
		310		}
		311
		312		bool RemoteAccessManagerInterface::isBound() const
		313		{
		314		Private priv = reinterpret_cast<Private >(d.data());
		315		return !priv->clients.isEmpty();
		316		}
		317
		318		class RemoteBufferInterface::Private : public Resource::Private
		319		{
		320		public:
		321		Private(RemoteAccessManagerInterface ram, RemoteBufferInterface q, wl_resource pResource, const BufferHandle buf);
		322		~Private();
		323
		324		void passFd();
		325
		326		private:
		327		static const struct org_kde_kwin_remote_buffer_interface s_interface;
		328
		329		const BufferHandle *wrapped;
		330		};
		331
		332		#ifndef DOXYGEN_SHOULD_SKIP_THIS
		333		const struct org_kde_kwin_remote_buffer_interface RemoteBufferInterface::Private::s_interface = {
		334		resourceDestroyedCallback
		335		};
		336		#endif
		337
		338		RemoteBufferInterface::Private::Private(RemoteAccessManagerInterface ram, RemoteBufferInterface q, wl_resource pResource, const BufferHandle buf)
		339		: Resource::Private(q, ram, pResource, &org_kde_kwin_remote_buffer_interface, &s_interface), wrapped(buf)
		340		{
		341		}
		342
		343		RemoteBufferInterface::Private::~Private()
		344		{
		345		}
		346
		347		void RemoteBufferInterface::Private::passFd()
		348		{
		349		org_kde_kwin_remote_buffer_send_gbm_handle(resource, wrapped->fd(),
		350		wrapped->width(), wrapped->height(), wrapped->stride(), wrapped->format());
		351		}
		352
		353		RemoteBufferInterface::RemoteBufferInterface(RemoteAccessManagerInterface ram, wl_resource pResource, const BufferHandle *buf)
		354		: Resource(new Private(ram, this, pResource, buf), ram)
		355		{
		356		}
		357
		358		RemoteBufferInterface::Private *RemoteBufferInterface::d_func() const
		359		{
		360		return reinterpret_cast<Private*>(d.data());
		361		}
		362
		363
		364		void RemoteBufferInterface::passFd()
		365		{
		366		d_func()->passFd();
		367		}
		368
		369		}
		370		}