FreeRDP
Loading...
Searching...
No Matches
shadow_encoder.c
1
19#include <freerdp/config.h>
20
21#include <winpr/assert.h>
22
23#include "shadow.h"
24
25#include "shadow_encoder.h"
26
27#include <freerdp/log.h>
28#define TAG CLIENT_TAG("shadow")
29
30UINT32 shadow_encoder_preferred_fps(rdpShadowEncoder* encoder)
31{
32 /* Return preferred fps calculated according to the last
33 * sent frame id and last client-acknowledged frame id.
34 */
35 return encoder->fps;
36}
37
38UINT32 shadow_encoder_inflight_frames(rdpShadowEncoder* encoder)
39{
40 /* Return in-flight frame count.
41 * If queueDepth is SUSPEND_FRAME_ACKNOWLEDGEMENT, count = 0
42 * Otherwise, calculate count =
43 * <last sent frame id> - <last client-acknowledged frame id>
44 * Note: This function is exported so that subsystem could
45 * implement its own strategy to tune fps.
46 */
47 return (encoder->queueDepth == SUSPEND_FRAME_ACKNOWLEDGEMENT)
48 ? 0
49 : encoder->frameId - encoder->lastAckframeId;
50}
51
52UINT32 shadow_encoder_create_frame_id(rdpShadowEncoder* encoder)
53{
54 UINT32 frameId = 0;
55 UINT32 inFlightFrames = shadow_encoder_inflight_frames(encoder);
56
57 /*
58 * Calculate preferred fps according to how much frames are
59 * in-progress. Note that it only works when subsystem implementation
60 * calls shadow_encoder_preferred_fps and takes the suggestion.
61 */
62 if (inFlightFrames > 1)
63 {
64 encoder->fps = (100 / (inFlightFrames + 1) * encoder->maxFps) / 100;
65 }
66 else
67 {
68 encoder->fps += 2;
69
70 if (encoder->fps > encoder->maxFps)
71 encoder->fps = encoder->maxFps;
72 }
73
74 if (encoder->fps < 1)
75 encoder->fps = 1;
76
77 frameId = ++encoder->frameId;
78 return frameId;
79}
80
81WINPR_ATTR_NODISCARD
82static int shadow_encoder_init_grid(rdpShadowEncoder* encoder)
83{
84 UINT32 tileSize = 0;
85 UINT32 tileCount = 0;
86 encoder->gridWidth = ((encoder->width + (encoder->maxTileWidth - 1)) / encoder->maxTileWidth);
87 encoder->gridHeight =
88 ((encoder->height + (encoder->maxTileHeight - 1)) / encoder->maxTileHeight);
89 tileSize = encoder->maxTileWidth * encoder->maxTileHeight * 4;
90 tileCount = encoder->gridWidth * encoder->gridHeight;
91 encoder->gridBuffer = (BYTE*)calloc(tileSize, tileCount);
92
93 if (!encoder->gridBuffer)
94 return -1;
95
96 encoder->grid = (BYTE**)calloc(tileCount, sizeof(BYTE*));
97
98 if (!encoder->grid)
99 return -1;
100
101 for (UINT32 i = 0; i < encoder->gridHeight; i++)
102 {
103 for (UINT32 j = 0; j < encoder->gridWidth; j++)
104 {
105 const size_t k = (1ULL * i * encoder->gridWidth) + j;
106 encoder->grid[k] = &(encoder->gridBuffer[k * tileSize]);
107 }
108 }
109
110 return 0;
111}
112
113static int shadow_encoder_uninit_grid(rdpShadowEncoder* encoder)
114{
115 if (encoder->gridBuffer)
116 {
117 free(encoder->gridBuffer);
118 encoder->gridBuffer = nullptr;
119 }
120
121 if (encoder->grid)
122 {
123 free((void*)encoder->grid);
124 encoder->grid = nullptr;
125 }
126
127 encoder->gridWidth = 0;
128 encoder->gridHeight = 0;
129 return 0;
130}
131
132WINPR_ATTR_NODISCARD
133static int shadow_encoder_init_rfx(rdpShadowEncoder* encoder)
134{
135 if (!encoder->rfx)
136 encoder->rfx = rfx_context_new_ex(
137 TRUE, freerdp_settings_get_uint32(encoder->server->settings, FreeRDP_ThreadingFlags));
138
139 if (!encoder->rfx)
140 goto fail;
141
142 if (!rfx_context_reset(encoder->rfx, encoder->width, encoder->height))
143 goto fail;
144
145 {
146 const UINT32 mode =
147 freerdp_settings_get_uint32(encoder->server->settings, FreeRDP_RemoteFxRlgrMode);
148 if (!rfx_context_set_mode(encoder->rfx, WINPR_ASSERTING_INT_CAST(RLGR_MODE, mode)))
149 goto fail;
150 }
151 rfx_context_set_pixel_format(encoder->rfx, PIXEL_FORMAT_BGRX32);
152 encoder->codecs |= FREERDP_CODEC_REMOTEFX;
153 return 1;
154fail:
155 rfx_context_free(encoder->rfx);
156 encoder->rfx = nullptr;
157 return -1;
158}
159
160WINPR_ATTR_NODISCARD
161static int shadow_encoder_init_nsc(rdpShadowEncoder* encoder)
162{
163 rdpContext* context = (rdpContext*)encoder->client;
164 rdpSettings* settings = context->settings;
165
166 if (!encoder->nsc)
167 encoder->nsc = nsc_context_new();
168
169 if (!encoder->nsc)
170 goto fail;
171
172 if (!nsc_context_reset(encoder->nsc, encoder->width, encoder->height))
173 goto fail;
174
175 if (!nsc_context_set_parameters(
176 encoder->nsc, NSC_COLOR_LOSS_LEVEL,
177 freerdp_settings_get_uint32(settings, FreeRDP_NSCodecColorLossLevel)))
178 goto fail;
179 if (!nsc_context_set_parameters(
180 encoder->nsc, NSC_ALLOW_SUBSAMPLING,
181 freerdp_settings_get_bool(settings, FreeRDP_NSCodecAllowSubsampling) ? 1 : 0))
182 goto fail;
183 if (!nsc_context_set_parameters(
184 encoder->nsc, NSC_DYNAMIC_COLOR_FIDELITY,
185 !freerdp_settings_get_bool(settings, FreeRDP_NSCodecAllowDynamicColorFidelity)))
186 goto fail;
187 if (!nsc_context_set_parameters(encoder->nsc, NSC_COLOR_FORMAT, PIXEL_FORMAT_BGRX32))
188 goto fail;
189 encoder->codecs |= FREERDP_CODEC_NSCODEC;
190 return 1;
191fail:
192 nsc_context_free(encoder->nsc);
193 return -1;
194}
195
196WINPR_ATTR_NODISCARD
197static int shadow_encoder_init_planar(rdpShadowEncoder* encoder)
198{
199 DWORD planarFlags = 0;
200 rdpContext* context = (rdpContext*)encoder->client;
201 rdpSettings* settings = context->settings;
202
203 if (freerdp_settings_get_bool(settings, FreeRDP_DrawAllowSkipAlpha))
204 planarFlags |= PLANAR_FORMAT_HEADER_NA;
205
206 planarFlags |= PLANAR_FORMAT_HEADER_RLE;
207
208 if (!encoder->planar)
209 {
210 encoder->planar = freerdp_bitmap_planar_context_new(planarFlags, encoder->maxTileWidth,
211 encoder->maxTileHeight);
212 }
213
214 if (!encoder->planar)
215 goto fail;
216
217 if (!freerdp_bitmap_planar_context_reset(encoder->planar, encoder->maxTileWidth,
218 encoder->maxTileHeight))
219 goto fail;
220
221 encoder->codecs |= FREERDP_CODEC_PLANAR;
222 return 1;
223fail:
224 freerdp_bitmap_planar_context_free(encoder->planar);
225 return -1;
226}
227
228WINPR_ATTR_NODISCARD
229static int shadow_encoder_init_interleaved(rdpShadowEncoder* encoder)
230{
231 if (!encoder->interleaved)
232 encoder->interleaved = bitmap_interleaved_context_new(TRUE);
233
234 if (!encoder->interleaved)
235 goto fail;
236
237 if (!bitmap_interleaved_context_reset(encoder->interleaved))
238 goto fail;
239
240 encoder->codecs |= FREERDP_CODEC_INTERLEAVED;
241 return 1;
242fail:
243 bitmap_interleaved_context_free(encoder->interleaved);
244 return -1;
245}
246
247WINPR_ATTR_NODISCARD
248static int shadow_encoder_init_h264(rdpShadowEncoder* encoder)
249{
250 if (!encoder->h264)
251 encoder->h264 = h264_context_new(TRUE);
252
253 if (!encoder->h264)
254 goto fail;
255
256 if (!h264_context_reset(encoder->h264, encoder->width, encoder->height))
257 goto fail;
258
259 if (!h264_context_set_option(encoder->h264, H264_CONTEXT_OPTION_RATECONTROL,
260 encoder->server->h264RateControlMode))
261 goto fail;
262 if (!h264_context_set_option(encoder->h264, H264_CONTEXT_OPTION_BITRATE,
263 encoder->server->h264BitRate))
264 goto fail;
265 if (!h264_context_set_option(encoder->h264, H264_CONTEXT_OPTION_FRAMERATE,
266 encoder->server->h264FrameRate))
267 goto fail;
268 if (!h264_context_set_option(encoder->h264, H264_CONTEXT_OPTION_QP, encoder->server->h264QP))
269 goto fail;
270
271 encoder->codecs |= FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444;
272 return 1;
273fail:
274 h264_context_free(encoder->h264);
275 return -1;
276}
277
278#if defined(WITH_GFX_AV1)
279WINPR_ATTR_NODISCARD
280static int shadow_encoder_init_av1(rdpShadowEncoder* encoder, UINT32 codecs)
281{
282 WINPR_ASSERT(encoder);
283
284 UINT32 profile = 0;
285 if ((codecs & FREERDP_CODEC_AV1_I444) != 0)
286 profile = 1;
287
288 if (!encoder->av1)
289 encoder->av1 = freerdp_av1_context_new(TRUE);
290
291 if (!encoder->av1)
292 goto fail;
293
294 if (!freerdp_av1_context_reset(encoder->av1, encoder->width, encoder->height))
295 goto fail;
296
297 if (!freerdp_av1_context_set_option(encoder->av1, FREERDP_AV1_CONTEXT_OPTION_PROFILE, profile))
298 goto fail;
299
300 if (!freerdp_av1_context_set_option(encoder->av1, FREERDP_AV1_CONTEXT_OPTION_RATECONTROL,
301 encoder->server->AV1RateControlMode))
302 goto fail;
303 if (!freerdp_av1_context_set_option(encoder->av1, FREERDP_AV1_CONTEXT_OPTION_BITRATE,
304 encoder->server->AV1BitRate))
305 goto fail;
306
307 encoder->codecs &= ~(FREERDP_CODEC_AV1_I420 | FREERDP_CODEC_AV1_I444);
308 encoder->codecs |= codecs;
309 return 1;
310fail:
311 freerdp_av1_context_free(encoder->av1);
312 encoder->av1 = nullptr;
313 return -1;
314}
315#endif
316
317WINPR_ATTR_NODISCARD
318static int shadow_encoder_init_progressive(rdpShadowEncoder* encoder)
319{
320 WINPR_ASSERT(encoder);
321 if (!encoder->progressive)
322 encoder->progressive = progressive_context_new(TRUE);
323
324 if (!encoder->progressive)
325 goto fail;
326
327 if (!progressive_context_reset(encoder->progressive))
328 goto fail;
329
330 encoder->codecs |= FREERDP_CODEC_PROGRESSIVE;
331 return 1;
332fail:
333 progressive_context_free(encoder->progressive);
334 return -1;
335}
336
337WINPR_ATTR_NODISCARD
338static int shadow_encoder_init(rdpShadowEncoder* encoder)
339{
340 encoder->width = encoder->server->screen->width;
341 encoder->height = encoder->server->screen->height;
342 encoder->maxTileWidth = 64;
343 encoder->maxTileHeight = 64;
344 if (shadow_encoder_init_grid(encoder) < 0)
345 return -1;
346
347 if (!encoder->bs)
348 encoder->bs = Stream_New(nullptr, 4ULL * encoder->maxTileWidth * encoder->maxTileHeight);
349
350 if (!encoder->bs)
351 return -1;
352
353 return 1;
354}
355
356static int shadow_encoder_uninit_rfx(rdpShadowEncoder* encoder)
357{
358 if (encoder->rfx)
359 {
360 rfx_context_free(encoder->rfx);
361 encoder->rfx = nullptr;
362 }
363
364 encoder->codecs &= (UINT32)~FREERDP_CODEC_REMOTEFX;
365 return 1;
366}
367
368static int shadow_encoder_uninit_nsc(rdpShadowEncoder* encoder)
369{
370 if (encoder->nsc)
371 {
372 nsc_context_free(encoder->nsc);
373 encoder->nsc = nullptr;
374 }
375
376 encoder->codecs &= (UINT32)~FREERDP_CODEC_NSCODEC;
377 return 1;
378}
379
380static int shadow_encoder_uninit_planar(rdpShadowEncoder* encoder)
381{
382 if (encoder->planar)
383 {
384 freerdp_bitmap_planar_context_free(encoder->planar);
385 encoder->planar = nullptr;
386 }
387
388 encoder->codecs &= (UINT32)~FREERDP_CODEC_PLANAR;
389 return 1;
390}
391
392static int shadow_encoder_uninit_interleaved(rdpShadowEncoder* encoder)
393{
394 if (encoder->interleaved)
395 {
396 bitmap_interleaved_context_free(encoder->interleaved);
397 encoder->interleaved = nullptr;
398 }
399
400 encoder->codecs &= (UINT32)~FREERDP_CODEC_INTERLEAVED;
401 return 1;
402}
403
404static int shadow_encoder_uninit_h264(rdpShadowEncoder* encoder)
405{
406 if (encoder->h264)
407 {
408 h264_context_free(encoder->h264);
409 encoder->h264 = nullptr;
410 }
411
412 encoder->codecs &= (UINT32) ~(FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444);
413 return 1;
414}
415
416#if defined(WITH_GFX_AV1)
417static int shadow_encoder_uninit_av1(rdpShadowEncoder* encoder)
418{
419 WINPR_ASSERT(encoder);
420
421 freerdp_av1_context_free(encoder->av1);
422 encoder->av1 = nullptr;
423
424 encoder->codecs &= (UINT32) ~(FREERDP_CODEC_AV1_I420 | FREERDP_CODEC_AV1_I444);
425 return 1;
426}
427#endif
428
429static int shadow_encoder_uninit_progressive(rdpShadowEncoder* encoder)
430{
431 WINPR_ASSERT(encoder);
432 if (encoder->progressive)
433 {
434 progressive_context_free(encoder->progressive);
435 encoder->progressive = nullptr;
436 }
437
438 encoder->codecs &= (UINT32)~FREERDP_CODEC_PROGRESSIVE;
439 return 1;
440}
441
442static int shadow_encoder_uninit(rdpShadowEncoder* encoder)
443{
444 shadow_encoder_uninit_grid(encoder);
445
446 if (encoder->bs)
447 {
448 Stream_Free(encoder->bs, TRUE);
449 encoder->bs = nullptr;
450 }
451
452 shadow_encoder_uninit_rfx(encoder);
453
454 shadow_encoder_uninit_nsc(encoder);
455
456 shadow_encoder_uninit_planar(encoder);
457
458 shadow_encoder_uninit_interleaved(encoder);
459 shadow_encoder_uninit_h264(encoder);
460#if defined(WITH_GFX_AV1)
461 shadow_encoder_uninit_av1(encoder);
462#endif
463
464 shadow_encoder_uninit_progressive(encoder);
465
466 return 1;
467}
468
469int shadow_encoder_reset(rdpShadowEncoder* encoder)
470{
471 int status = 0;
472 UINT32 codecs = encoder->codecs;
473 rdpContext* context = (rdpContext*)encoder->client;
474 rdpSettings* settings = context->settings;
475 status = shadow_encoder_uninit(encoder);
476
477 if (status < 0)
478 return -1;
479
480 status = shadow_encoder_init(encoder);
481
482 if (status < 0)
483 return -1;
484
485 status = shadow_encoder_prepare(encoder, codecs);
486
487 if (status < 0)
488 return -1;
489
490 encoder->fps = 16;
491 encoder->maxFps = 32;
492 encoder->frameId = 0;
493 encoder->lastAckframeId = 0;
494 encoder->frameAck = freerdp_settings_get_bool(settings, FreeRDP_SurfaceFrameMarkerEnabled);
495 return 1;
496}
497
498int shadow_encoder_prepare(rdpShadowEncoder* encoder, UINT32 codecs)
499{
500 int status = 0;
501
502 if ((codecs & FREERDP_CODEC_REMOTEFX) && !(encoder->codecs & FREERDP_CODEC_REMOTEFX))
503 {
504 WLog_DBG(TAG, "initializing RemoteFX encoder");
505 status = shadow_encoder_init_rfx(encoder);
506
507 if (status < 0)
508 return -1;
509 }
510
511 if ((codecs & FREERDP_CODEC_NSCODEC) && !(encoder->codecs & FREERDP_CODEC_NSCODEC))
512 {
513 WLog_DBG(TAG, "initializing NSCodec encoder");
514 status = shadow_encoder_init_nsc(encoder);
515
516 if (status < 0)
517 return -1;
518 }
519
520 if ((codecs & FREERDP_CODEC_PLANAR) && !(encoder->codecs & FREERDP_CODEC_PLANAR))
521 {
522 WLog_DBG(TAG, "initializing planar bitmap encoder");
523 status = shadow_encoder_init_planar(encoder);
524
525 if (status < 0)
526 return -1;
527 }
528
529 if ((codecs & FREERDP_CODEC_INTERLEAVED) && !(encoder->codecs & FREERDP_CODEC_INTERLEAVED))
530 {
531 WLog_DBG(TAG, "initializing interleaved bitmap encoder");
532 status = shadow_encoder_init_interleaved(encoder);
533
534 if (status < 0)
535 return -1;
536 }
537
538 if ((codecs & (FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444)) &&
539 !(encoder->codecs & (FREERDP_CODEC_AVC420 | FREERDP_CODEC_AVC444)))
540 {
541 WLog_DBG(TAG, "initializing H.264 encoder");
542 status = shadow_encoder_init_h264(encoder);
543
544 if (status < 0)
545 return -1;
546 }
547
548 if ((codecs & FREERDP_CODEC_PROGRESSIVE) && !(encoder->codecs & FREERDP_CODEC_PROGRESSIVE))
549 {
550 WLog_DBG(TAG, "initializing progressive encoder");
551 status = shadow_encoder_init_progressive(encoder);
552
553 if (status < 0)
554 return -1;
555 }
556
557#if defined(WITH_GFX_AV1)
558 const UINT32 cmask = codecs & (FREERDP_CODEC_AV1_I420 | FREERDP_CODEC_AV1_I444);
559 const UINT32 emask = encoder->codecs & (FREERDP_CODEC_AV1_I420 | FREERDP_CODEC_AV1_I444);
560 if (cmask != emask)
561 {
562 WLog_DBG(TAG, "initializing AV1 encoder");
563 status = shadow_encoder_init_av1(encoder, codecs);
564
565 if (status < 0)
566 return -1;
567 }
568#endif
569
570 return 1;
571}
572
573rdpShadowEncoder* shadow_encoder_new(rdpShadowClient* client)
574{
575 rdpShadowEncoder* encoder = nullptr;
576 rdpShadowServer* server = client->server;
577 encoder = (rdpShadowEncoder*)calloc(1, sizeof(rdpShadowEncoder));
578
579 if (!encoder)
580 return nullptr;
581
582 encoder->client = client;
583 encoder->server = server;
584 encoder->fps = 16;
585 encoder->maxFps = 32;
586
587 if (shadow_encoder_init(encoder) < 0)
588 {
589 shadow_encoder_free(encoder);
590 return nullptr;
591 }
592
593 return encoder;
594}
595
596void shadow_encoder_free(rdpShadowEncoder* encoder)
597{
598 if (!encoder)
599 return;
600
601 shadow_encoder_uninit(encoder);
602 free(encoder);
603}
freerdp_settings_get_uint32
WINPR_ATTR_NODISCARD FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
WINPR_ATTR_NODISCARD FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.