Differential D29015 Diff 80799 plugins/platforms/drm/screencaststream.cpp

Changeset View

Standalone View

plugins/platforms/drm/screencaststream.cpp

This file was added.

1		/*
2		* Copyright © 2018-2020 Red Hat, Inc
3		*
4		* This program 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 of the License, or (at your option) any later version.
8		*
9		* This library is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12		* Lesser General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public
15		* License along with this library. If not, see <http://www.gnu.org/licenses/>.
16		*
17		* Authors:
18		* Jan Grulich <jgrulich@redhat.com>
19		*/
20
21		#include "screencaststream.h"
22
23		#include <limits.h>
24		#include <math.h>
25		#include <sys/mman.h>
26		#include <stdio.h>
27
28		#include <abstract_egl_backend.h>
29		#include "drm_buffer_gbm.h"
30
31		#include <QLoggingCategory>
32
33		#include <KNotification>
34		#include <KLocalizedString>
35		#include <gbm.h>
36
37		Q_LOGGING_CATEGORY(KWinScreenCastStream, "xdp-kde-screencast-stream")
38
	jgrulichUnsubmitted Not Done xdp-kde-screencast-stream → kwin_screencast_stream? jgrulich: xdp-kde-screencast-stream → kwin_screencast_stream?
39		class PwFraction {
40		public:
41		int num;
42		int denom;
43		};
44
45		// Stolen from mutter
46
47		#define MAX_TERMS 30
48		#define MIN_DIVISOR 1.0e-10
49		#define MAX_ERROR 1.0e-20
50
51		#define PROP_RANGE(min, max) 2, (min), (max)
52
53		#define BITS_PER_PIXEL 4
54
55		static int greatestCommonDivisor(int a, int b)
56		{
57		while (b != 0) {
58		int temp = a;
59
60		a = b;
61		b = temp % b;
62		}
63
64		return qAbs(a);
65		}
66
67		static PwFraction pipewireFractionFromDouble(double src)
68		{
69		double V, F; /* double being converted */
70		int N, D; /* will contain the result */
71		int A; /* current term in continued fraction */
72		int64_t N1, D1; /* numerator, denominator of last approx */
73		int64_t N2, D2; /* numerator, denominator of previous approx */
74		int i;
75		int gcd;
76		bool negative = false;
77
78		/* initialize fraction being converted */
79		F = src;
80		if (F < 0.0) {
81		F = -F;
82		negative = true;
83		}
84
85		V = F;
86		/* initialize fractions with 1/0, 0/1 */
87		N1 = 1;
88		D1 = 0;
89		N2 = 0;
90		D2 = 1;
91		N = 1;
92		D = 1;
93
94		for (i = 0; i < MAX_TERMS; ++i) {
95		/* get next term */
96		A = (int) F; /* no floor() needed, F is always >= 0 */
97		/* get new divisor */
98		F = F - A;
99
100		/* calculate new fraction in temp */
101		N2 = N1 * A + N2;
102		D2 = D1 * A + D2;
103
104		/* guard against overflow */
105		if (N2 > INT_MAX \|\| D2 > INT_MAX)
106		break;
107
108		N = N2;
109		D = D2;
110
111		/* save last two fractions */
112		N2 = N1;
113		D2 = D1;
114		N1 = N;
115		D1 = D;
116
117		/* quit if dividing by zero or close enough to target */
118		if (F < MIN_DIVISOR \|\| fabs (V - ((double) N) / D) < MAX_ERROR)
119		break;
120
121		/* Take reciprocal */
122		F = 1 / F;
123		}
124
125		/* fix for overflow */
126		if (D == 0) {
127		N = INT_MAX;
128		D = 1;
129		}
130
131		/* fix for negative */
132		if (negative)
133		N = -N;
134
135		/* simplify */
136		gcd = greatestCommonDivisor(N, D);
137		if (gcd) {
138		N /= gcd;
139		D /= gcd;
140		}
141
142		PwFraction fraction;
143		fraction.num = N;
144		fraction.denom = D;
145
146		return fraction;
147		}
148
149		void ScreenCastStream::stop()
150		{
151		m_stopped = true;
152		delete this;
153		}
154
155		void ScreenCastStream::onCoreError(void data, uint32_t id, int seq, int res, const char message)
156		{
157		Q_UNUSED(seq)
158		ScreenCastStream pw = static_cast<ScreenCastStream>(data);
159
160		qCWarning(KWinScreenCastStream) << "PipeWire remote error: " << message;
161
162		if (id == PW_ID_CORE) {
163		if (res == -EPIPE) {
164		Q_EMIT pw->stopStreaming(pw->nodeId());
165		}
166		}
167		}
168
169		void ScreenCastStream::onStreamStateChanged(void data, pw_stream_state old, pw_stream_state state, const char error_message)
170		{
171		Q_UNUSED(old)
172
173		ScreenCastStream pw = static_cast<ScreenCastStream>(data);
174
175		switch (state) {
176		case PW_STREAM_STATE_ERROR:
177		qCWarning(KWinScreenCastStream) << "Stream error: " << error_message;
178		break;
179		case PW_STREAM_STATE_PAUSED:
180		qCDebug(KWinScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state);
181		if (pw->nodeId() == 0 && pw->pwStream) {
182		pw->pwNodeId = pw_stream_get_node_id(pw->pwStream);
183		Q_EMIT pw->streamReady(pw->nodeId());
184		}
185		if (pw->m_stopped) {
186		Q_EMIT pw->stopStreaming(pw->nodeId());
187		}
188		break;
189		case PW_STREAM_STATE_STREAMING:
190		qCDebug(KWinScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state);
191		Q_EMIT pw->startStreaming();
192		break;
193		case PW_STREAM_STATE_UNCONNECTED:
194		case PW_STREAM_STATE_CONNECTING:
195		qCDebug(KWinScreenCastStream) << "Stream state: " << pw_stream_state_as_string(state);
196		break;
197		}
198		}
199
200		void ScreenCastStream::onStreamParamChanged(void data, uint32_t id, const struct spa_pod format)
201		{
202		qCDebug(KWinScreenCastStream) << "Stream format changed";
203
204		ScreenCastStream pw = static_cast<ScreenCastStream>(data);
205
206		uint8_t paramsBuffer[1024];
207		int32_t width, height, stride, size;
208		struct spa_pod_builder pod_builder;
209		const struct spa_pod *params[1];
210
211		if (!format \|\| id != SPA_PARAM_Format) {
212		return;
213		}
214
215		spa_format_video_raw_parse (format, &pw->videoFormat);
216
217		width = pw->videoFormat.size.width;
218		height =pw->videoFormat.size.height;
219		stride = SPA_ROUND_UP_N (width * BITS_PER_PIXEL, 4);
220		size = height * stride;
221
222		pod_builder = SPA_POD_BUILDER_INIT (paramsBuffer, sizeof (paramsBuffer));
223
224		params[0] = (spa_pod*) spa_pod_builder_add_object(&pod_builder,
225		SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
226		SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(16, 2, 16),
227		SPA_PARAM_BUFFERS_blocks, SPA_POD_Int (1),
228		SPA_PARAM_BUFFERS_size, SPA_POD_Int(size),
229		SPA_PARAM_BUFFERS_stride, SPA_POD_CHOICE_RANGE_Int(stride, stride, INT32_MAX),
230		SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
231		pw_stream_update_params(pw->pwStream, params, 1);
232		}
233
234		ScreenCastStream::ScreenCastStream(const QSize &resolution, KWin::AbstractEglBackend* backend, QObject *parent)
235		: QObject(parent)
236		, resolution(resolution)
237		, m_backend(backend)
238		{
239		pwCoreEvents.version = PW_VERSION_CORE_EVENTS;
240		pwCoreEvents.error = &onCoreError;
241
242		pwStreamEvents.version = PW_VERSION_STREAM_EVENTS;
243		pwStreamEvents.state_changed = &onStreamStateChanged;
244		pwStreamEvents.param_changed = &onStreamParamChanged;
245		}
246
247		ScreenCastStream::~ScreenCastStream()
248		{
249		if (pwMainLoop) {
250		pw_thread_loop_stop(pwMainLoop);
251		}
252
253		if (pwStream) {
254		pw_stream_destroy(pwStream);
255		}
256
257
258		if (pwCore) {
259		pw_core_disconnect(pwCore);
260		}
261
262		if (pwContext) {
263		pw_context_destroy(pwContext);
264		}
265
266		if (pwMainLoop) {
267		pw_thread_loop_destroy(pwMainLoop);
268		}
269		}
270
271		bool ScreenCastStream::init()
272		{
273		pw_init(nullptr, nullptr);
274
275		pwMainLoop = pw_thread_loop_new("pipewire-main-loop", nullptr);
276		pwContext = pw_context_new(pw_thread_loop_get_loop(pwMainLoop), nullptr, 0);
277		if (!pwContext) {
278		qCWarning(KWinScreenCastStream) << "Failed to create PipeWire context";
279		m_error = i18n("Failed to create PipeWire context");
280		return false;
281		}
282
283		pwCore = pw_context_connect(pwContext, nullptr, 0);
284		if (!pwCore) {
285		qCWarning(KWinScreenCastStream) << "Failed to connect PipeWire context";
286		m_error = i18n("Failed to connect PipeWire context");
287		return false;
288		}
289
290		pw_core_add_listener(pwCore, &coreListener, &pwCoreEvents, this);
291
292		pwStream = createStream();
293		if (!pwStream) {
294		qCWarning(KWinScreenCastStream) << "Failed to create PipeWire stream";
295		m_error = i18n("Failed to create PipeWire stream");
296		return false;
297		}
298
299
300		if (pw_thread_loop_start(pwMainLoop) < 0) {
301		qCWarning(KWinScreenCastStream) << "Failed to start main PipeWire loop";
302		m_error = i18n("Failed to start main PipeWire loop");
303		return false;
304		}
305		return true;
306		}
307
308		uint ScreenCastStream::framerate()
309		{
310		if (pwStream) {
311		return videoFormat.max_framerate.num / videoFormat.max_framerate.denom;
312		}
313
314		return 0;
315		}
316
317		uint ScreenCastStream::nodeId()
318		{
319		return pwNodeId;
320		}
321
322		pw_stream *ScreenCastStream::createStream()
323		{
324		uint8_t buffer[1024];
325		spa_pod_builder podBuilder = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
326
327		const float frameRate = 25;
328
329		spa_fraction maxFramerate;
330		spa_fraction minFramerate;
331		const spa_pod *params[1];
332
333		auto stream = pw_stream_new(pwCore, "kwin-screen-cast", nullptr);
334
335		PwFraction fraction = pipewireFractionFromDouble(frameRate);
336
337		minFramerate = SPA_FRACTION(1, 1);
338		maxFramerate = SPA_FRACTION((uint32_t)fraction.num, (uint32_t)fraction.denom);
339
340		spa_rectangle minResolution = SPA_RECTANGLE(1, 1);
341		spa_rectangle maxResolution = SPA_RECTANGLE((uint32_t)resolution.width(), (uint32_t)resolution.height());
342
343		spa_fraction paramFraction = SPA_FRACTION(0, 1);
344
345		params[0] = (spa_pod*)spa_pod_builder_add_object(&podBuilder,
346		SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
347		SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
348		SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
349		SPA_FORMAT_VIDEO_format, SPA_POD_Id(SPA_VIDEO_FORMAT_RGBx),
350		SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(&maxResolution, &minResolution, &maxResolution),
351		SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&paramFraction),
352		SPA_FORMAT_VIDEO_maxFramerate, SPA_POD_CHOICE_RANGE_Fraction(&maxFramerate, &minFramerate, &maxFramerate));
353
354		pw_stream_add_listener(stream, &streamListener, &pwStreamEvents, this);
355
356		auto flags = static_cast<pw_stream_flags>(PW_STREAM_FLAG_DRIVER \| PW_STREAM_FLAG_MAP_BUFFERS);
357
358		if (pw_stream_connect(stream, PW_DIRECTION_OUTPUT, SPA_ID_INVALID, flags, params, 1) != 0) {
359		qCWarning(KWinScreenCastStream) << "Could not connect to stream";
360		return nullptr;
361		}
362
363		return stream;
364		}
365
366		bool ScreenCastStream::recordFrame(gbm_bo *bo, quint32 width, quint32 height, quint32 stride)
367		{
368		struct pw_buffer *buffer;
369		struct spa_buffer *spa_buffer;
370		uint8_t *data = nullptr;
371
372		if (!(buffer = pw_stream_dequeue_buffer(pwStream))) {
373		qCWarning(KWinScreenCastStream) << "Failed to record frame: couldn't obtain PipeWire buffer";
374		return false;
375		}
376
377		spa_buffer = buffer->buffer;
378
379		if (!(data = (uint8_t *) spa_buffer->datas[0].data)) {
380		qCWarning(KWinScreenCastStream) << "Failed to record frame: invalid buffer data";
381		pw_stream_queue_buffer(pwStream, buffer);
382		return false;
383		}
384
385		quint32 streamStride;
386		const quint32 minStride = SPA_ROUND_UP_N(videoFormat.size.width * BITS_PER_PIXEL, 4);
387		const quint32 minSrcSize = height * minStride;
388
389		const quint32 srcSize = height * stride;
390		const quint32 destSize = spa_buffer->datas[0].maxsize;
391
392		// If we can fit source into the pipewire buffer, we can use stride we got from gbm_bo as the client
393		// should be able to handle it
394		if (srcSize <= destSize) {
395		streamStride = stride;
396		// Fallback to fixed minimum stride, which should be (width * bpp)
397		} else if (minSrcSize == destSize) {
398		streamStride = minStride;
399		} else {
400		qCWarning(KWinScreenCastStream) << "Failed to record frame: got buffer with higher stride than we can handle";
401		pw_stream_queue_buffer(pwStream, buffer);
402		return false;
403		}
404
405		// bind context to render thread
406		eglMakeCurrent(m_backend->eglDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, m_backend->context());
407
408		// create EGL image from imported BO
409		EGLImageKHR image = eglCreateImageKHR(m_backend->eglDisplay(), nullptr, EGL_NATIVE_PIXMAP_KHR, bo, nullptr);
410
411		if (image == EGL_NO_IMAGE_KHR) {
412		qCWarning(KWinScreenCastStream) << "Failed to record frame: Error creating EGLImageKHR - " << glGetError();
413		pw_stream_queue_buffer(pwStream, buffer);
414		return false;
415		}
416
417		// create GL 2D texture for framebuffer
418		GLuint texture;
419		glGenTextures(1, &texture);
420		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
421		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
422		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
423		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
424		glBindTexture(GL_TEXTURE_2D, texture);
425		glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image);
426
427		glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
428
429		glDeleteTextures(1, &texture);
430		eglDestroyImageKHR(m_backend->eglDisplay(), image);
431
432		spa_buffer->datas[0].chunk->offset = 0;
433		spa_buffer->datas[0].chunk->size = spa_buffer->datas[0].maxsize;
434		spa_buffer->datas[0].chunk->stride = streamStride;
435
436		pw_stream_queue_buffer(pwStream, buffer);
437		return true;
438		}
439
440		void ScreenCastStream::removeStream()
441		{
442		// FIXME destroying streams seems to be crashing, Mutter also doesn't remove them, maybe Pipewire does this automatically
443		// pw_stream_destroy(pwStream);
444		// pwStream = nullptr;
445		pw_stream_disconnect(pwStream);
446		}