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