FreeRDP
Loading...
Searching...
No Matches
server/rdpgfx_main.c
1
20#include <freerdp/config.h>
21
22#include <winpr/assert.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include <winpr/cast.h>
28#include <winpr/crt.h>
29#include <winpr/synch.h>
30#include <winpr/thread.h>
31#include <winpr/stream.h>
32
33#include <freerdp/freerdp.h>
34#include <freerdp/codec/color.h>
35
36#include <freerdp/channels/wtsvc.h>
37#include <freerdp/channels/log.h>
38
39#include "rdpgfx_common.h"
40#include "rdpgfx_main.h"
41
42#define TAG CHANNELS_TAG("rdpgfx.server")
43
44static BOOL rdpgfx_server_close(RdpgfxServerContext* context);
45
46#define checkCapsAreExchanged(context) \
47 checkCapsAreExchangedInt(context, __FILE__, __func__, __LINE__)
48WINPR_ATTR_NODISCARD static BOOL checkCapsAreExchangedInt(RdpgfxServerContext* context,
49 const char* file, const char* fkt,
50 size_t line)
51{
52 WINPR_ASSERT(context);
53 WINPR_ASSERT(context->priv);
54
55 const DWORD level = WLOG_TRACE;
56 if (WLog_IsLevelActive(context->priv->log, level))
57 {
58 WLog_PrintTextMessage(context->priv->log, level, line, file, fkt,
59 "activeCapSet{Version=0x%08" PRIx32 ", flags=0x%08" PRIx32 "}",
60 context->priv->activeCapSet.version,
61 context->priv->activeCapSet.flags);
62 }
63 return context->priv->activeCapSet.version > 0;
64}
65
75WINPR_ATTR_NODISCARD static inline size_t rdpgfx_pdu_length(size_t dataLen)
76{
77 return RDPGFX_HEADER_SIZE + dataLen;
78}
79
80WINPR_ATTR_NODISCARD static inline UINT rdpgfx_server_packet_init_header(wStream* s, UINT16 cmdId,
81 size_t pduLength)
82{
83 const RDPGFX_HEADER header = { .flags = 0,
84 .cmdId = cmdId,
85 .pduLength = WINPR_ASSERTING_INT_CAST(UINT32, pduLength) };
86 /* Write header. Note that actual length might be changed
87 * after the entire packet has been constructed. */
88 return rdpgfx_write_header(s, &header);
89}
90
98WINPR_ATTR_NODISCARD static inline BOOL rdpgfx_server_packet_complete_header(wStream* s,
99 size_t start)
100{
101 const size_t current = Stream_GetPosition(s);
102 const size_t cap = Stream_Capacity(s);
103 if (cap < start + RDPGFX_HEADER_SIZE)
104 return FALSE;
105 if ((start > UINT32_MAX) || (current < start))
106 return FALSE;
107 /* Fill actual length */
108 if (!Stream_SetPosition(s, start + RDPGFX_HEADER_SIZE - sizeof(UINT32)))
109 return FALSE;
110 Stream_Write_UINT32(s, (UINT32)(current - start)); /* pduLength (4 bytes) */
111 return Stream_SetPosition(s, current);
112}
113
121WINPR_ATTR_NODISCARD static UINT rdpgfx_server_packet_send(RdpgfxServerContext* context, wStream* s)
122{
123 UINT error = 0;
124 UINT32 flags = 0;
125 ULONG written = 0;
126 BYTE* pSrcData = Stream_Buffer(s);
127 const size_t SrcSize = Stream_GetPosition(s);
128 if (SrcSize > UINT32_MAX)
129 return ERROR_INTERNAL_ERROR;
130
131 WINPR_ASSERT(context);
132 WINPR_ASSERT(context->priv);
133
134 /* Allocate new stream with enough capacity. Additional overhead is
135 * descriptor (1 bytes) + segmentCount (2 bytes) + uncompressedSize (4 bytes)
136 * + segmentCount * size (4 bytes) */
137 wStream* fs = Stream_New(nullptr, SrcSize + 7 + (SrcSize / ZGFX_SEGMENTED_MAXSIZE + 1) * 4);
138
139 if (!fs)
140 {
141 WLog_Print(context->priv->log, WLOG_ERROR, "Stream_New failed!");
142 error = CHANNEL_RC_NO_MEMORY;
143 goto out;
144 }
145
146 if (zgfx_compress_to_stream(context->priv->zgfx, fs, pSrcData, (UINT32)SrcSize, &flags) < 0)
147 {
148 WLog_Print(context->priv->log, WLOG_ERROR, "zgfx_compress_to_stream failed!");
149 error = ERROR_INTERNAL_ERROR;
150 goto out;
151 }
152
153 {
154 const size_t pos = Stream_GetPosition(fs);
155 WINPR_ASSERT(pos <= UINT32_MAX);
156 if (!WTSVirtualChannelWrite(context->priv->rdpgfx_channel, Stream_BufferAs(fs, char),
157 (UINT32)pos, &written))
158 {
159 WLog_Print(context->priv->log, WLOG_ERROR, "WTSVirtualChannelWrite failed!");
160 error = ERROR_INTERNAL_ERROR;
161 goto out;
162 }
163 }
164
165 if (written < Stream_GetPosition(fs))
166 {
167 WLog_Print(context->priv->log, WLOG_WARN,
168 "Unexpected bytes written: %" PRIu32 "/%" PRIuz "", written,
169 Stream_GetPosition(fs));
170 }
171
172 error = CHANNEL_RC_OK;
173out:
174 Stream_Free(fs, TRUE);
175 Stream_Free(s, TRUE);
176 return error;
177}
178
191WINPR_ATTR_MALLOC(Stream_Free, 1)
192static wStream* rdpgfx_server_single_packet_new(wLog* log, UINT16 cmdId, size_t dataLen)
193{
194 UINT error = 0;
195 const size_t pduLength = rdpgfx_pdu_length(dataLen);
196 wStream* s = Stream_New(nullptr, pduLength);
197
198 if (!s)
199 {
200 WLog_Print(log, WLOG_ERROR, "Stream_New failed!");
201 goto error;
202 }
203
204 if ((error = rdpgfx_server_packet_init_header(s, cmdId, pduLength)))
205 {
206 WLog_Print(log, WLOG_ERROR, "Failed to init header with error %" PRIu32 "!", error);
207 goto error;
208 }
209
210 return s;
211error:
212 Stream_Free(s, TRUE);
213 return nullptr;
214}
215
224WINPR_ATTR_NODISCARD static inline UINT
225rdpgfx_server_single_packet_send(RdpgfxServerContext* context, wStream* s)
226{
227 /* Fill actual length */
228 if (!rdpgfx_server_packet_complete_header(s, 0))
229 return ERROR_INTERNAL_ERROR;
230 return rdpgfx_server_packet_send(context, s);
231}
232
238WINPR_ATTR_NODISCARD static UINT
239rdpgfx_send_caps_confirm_pdu(RdpgfxServerContext* context,
240 const RDPGFX_CAPS_CONFIRM_PDU* capsConfirm)
241{
242 WINPR_ASSERT(context);
243 WINPR_ASSERT(context->priv);
244 WINPR_ASSERT(capsConfirm);
245
246 RDPGFX_CAPSET* capsSet = capsConfirm->capsSet;
247 WINPR_ASSERT(capsSet);
248
249 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_CAPSCONFIRM,
250 RDPGFX_CAPSET_BASE_SIZE + capsSet->length);
251
252 if (!s)
253 {
254 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
255 return CHANNEL_RC_NO_MEMORY;
256 }
257
258 WLog_Print(context->priv->log, WLOG_DEBUG,
259 "CAPS version=0x%04" PRIx32 ", flags=0x%04" PRIx32 ", length=%" PRIu32,
260 capsSet->version, capsSet->flags, capsSet->length);
261 Stream_Write_UINT32(s, capsSet->version); /* version (4 bytes) */
262 Stream_Write_UINT32(s, capsSet->length); /* capsDataLength (4 bytes) */
263
264 if (capsSet->length >= 4)
265 {
266 Stream_Write_UINT32(s, capsSet->flags); /* capsData (4 bytes) */
267 Stream_Zero(s, capsSet->length - 4);
268 }
269 else
270 Stream_Zero(s, capsSet->length);
271
272 context->priv->activeCapSet = *capsSet;
273 return rdpgfx_server_single_packet_send(context, s);
274}
275
281WINPR_ATTR_NODISCARD static UINT
282rdpgfx_send_reset_graphics_pdu(RdpgfxServerContext* context, const RDPGFX_RESET_GRAPHICS_PDU* pdu)
283{
284 const size_t RDPGFX_RESET_GRAPHICS_PDU_SIZE = 340;
285
286 if (!checkCapsAreExchanged(context))
287 return CHANNEL_RC_NOT_INITIALIZED;
288
289 WINPR_ASSERT(pdu);
290 WINPR_ASSERT(context->priv);
291
292 /* Check monitorCount. This ensures total size within 340 bytes) */
293 if (pdu->monitorCount >= 16)
294 {
295 WLog_Print(context->priv->log, WLOG_ERROR,
296 "Monitor count MUST be less than or equal to 16: %" PRIu32 "",
297 pdu->monitorCount);
298 return ERROR_INVALID_DATA;
299 }
300
301 wStream* s =
302 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_RESETGRAPHICS,
303 RDPGFX_RESET_GRAPHICS_PDU_SIZE - RDPGFX_HEADER_SIZE);
304
305 if (!s)
306 {
307 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
308 return CHANNEL_RC_NO_MEMORY;
309 }
310
311 Stream_Write_UINT32(s, pdu->width); /* width (4 bytes) */
312 Stream_Write_UINT32(s, pdu->height); /* height (4 bytes) */
313 Stream_Write_UINT32(s, pdu->monitorCount); /* monitorCount (4 bytes) */
314
315 for (UINT32 index = 0; index < pdu->monitorCount; index++)
316 {
317 const MONITOR_DEF* monitor = &(pdu->monitorDefArray[index]);
318 Stream_Write_INT32(s, monitor->left); /* left (4 bytes) */
319 Stream_Write_INT32(s, monitor->top); /* top (4 bytes) */
320 Stream_Write_INT32(s, monitor->right); /* right (4 bytes) */
321 Stream_Write_INT32(s, monitor->bottom); /* bottom (4 bytes) */
322 Stream_Write_UINT32(s, monitor->flags); /* flags (4 bytes) */
323 }
324
325 /* pad (total size must be 340 bytes) */
326 const size_t pos = Stream_GetPosition(s);
327 if (pos > RDPGFX_RESET_GRAPHICS_PDU_SIZE)
328 {
329 Stream_Free(s, TRUE);
330 return ERROR_INVALID_DATA;
331 }
332 if (!Stream_SafeZero(s, RDPGFX_RESET_GRAPHICS_PDU_SIZE - pos))
333 {
334 Stream_Free(s, TRUE);
335 return ERROR_INVALID_DATA;
336 }
337 return rdpgfx_server_single_packet_send(context, s);
338}
339
345WINPR_ATTR_NODISCARD static UINT
346rdpgfx_send_evict_cache_entry_pdu(RdpgfxServerContext* context,
347 const RDPGFX_EVICT_CACHE_ENTRY_PDU* pdu)
348{
349 if (!checkCapsAreExchanged(context))
350 return CHANNEL_RC_NOT_INITIALIZED;
351
352 WINPR_ASSERT(pdu);
353 WINPR_ASSERT(context->priv);
354 wStream* s =
355 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_EVICTCACHEENTRY, 2);
356
357 if (!s)
358 {
359 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
360 return CHANNEL_RC_NO_MEMORY;
361 }
362
363 Stream_Write_UINT16(s, pdu->cacheSlot); /* cacheSlot (2 bytes) */
364 return rdpgfx_server_single_packet_send(context, s);
365}
366
372WINPR_ATTR_NODISCARD static UINT
373rdpgfx_send_cache_import_reply_pdu(RdpgfxServerContext* context,
374 const RDPGFX_CACHE_IMPORT_REPLY_PDU* pdu)
375{
376 if (!checkCapsAreExchanged(context))
377 return CHANNEL_RC_NOT_INITIALIZED;
378 WINPR_ASSERT(context);
379 WINPR_ASSERT(context->priv);
380 WINPR_ASSERT(pdu);
381
382 WLog_Print(context->priv->log, WLOG_DEBUG, "reply with %" PRIu16 " entries",
383 pdu->importedEntriesCount);
384 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_CACHEIMPORTREPLY,
385 2 + 2 * pdu->importedEntriesCount);
386
387 if (!s)
388 {
389 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
390 return CHANNEL_RC_NO_MEMORY;
391 }
392
393 /* importedEntriesCount (2 bytes) */
394 Stream_Write_UINT16(s, pdu->importedEntriesCount);
395
396 for (UINT16 index = 0; index < pdu->importedEntriesCount; index++)
397 {
398 Stream_Write_UINT16(s, pdu->cacheSlots[index]); /* cacheSlot (2 bytes) */
399 }
400
401 return rdpgfx_server_single_packet_send(context, s);
402}
403
404WINPR_ATTR_NODISCARD static UINT
405rdpgfx_process_cache_import_offer_pdu(RdpgfxServerContext* context,
406 const RDPGFX_CACHE_IMPORT_OFFER_PDU* cacheImportOffer)
407{
408 if (!checkCapsAreExchanged(context))
409 return CHANNEL_RC_NOT_INITIALIZED;
410 WINPR_ASSERT(context);
411 WINPR_ASSERT(context->priv);
412 WINPR_ASSERT(cacheImportOffer);
413
414 RDPGFX_CACHE_IMPORT_REPLY_PDU reply = WINPR_C_ARRAY_INIT;
415 WLog_Print(context->priv->log, WLOG_DEBUG,
416 "received %" PRIu16 " entries, reply with %" PRIu16 " entries",
417 cacheImportOffer->cacheEntriesCount, reply.importedEntriesCount);
418 return IFCALLRESULT(CHANNEL_RC_OK, context->CacheImportReply, context, &reply);
419}
420
426WINPR_ATTR_NODISCARD static UINT
427rdpgfx_send_create_surface_pdu(RdpgfxServerContext* context, const RDPGFX_CREATE_SURFACE_PDU* pdu)
428{
429 if (!checkCapsAreExchanged(context))
430 return CHANNEL_RC_NOT_INITIALIZED;
431
432 WINPR_ASSERT(context->priv);
433 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_CREATESURFACE, 7);
434
435 WINPR_ASSERT(context);
436 WINPR_ASSERT(pdu);
437 WINPR_ASSERT((pdu->pixelFormat == GFX_PIXEL_FORMAT_XRGB_8888) ||
438 (pdu->pixelFormat == GFX_PIXEL_FORMAT_ARGB_8888));
439
440 if (!s)
441 {
442 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
443 return CHANNEL_RC_NO_MEMORY;
444 }
445
446 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
447 Stream_Write_UINT16(s, pdu->width); /* width (2 bytes) */
448 Stream_Write_UINT16(s, pdu->height); /* height (2 bytes) */
449 Stream_Write_UINT8(s, pdu->pixelFormat); /* RDPGFX_PIXELFORMAT (1 byte) */
450 return rdpgfx_server_single_packet_send(context, s);
451}
452
458WINPR_ATTR_NODISCARD static UINT
459rdpgfx_send_delete_surface_pdu(RdpgfxServerContext* context, const RDPGFX_DELETE_SURFACE_PDU* pdu)
460{
461 if (!checkCapsAreExchanged(context))
462 return CHANNEL_RC_NOT_INITIALIZED;
463
464 WINPR_ASSERT(pdu);
465 WINPR_ASSERT(context->priv);
466 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_DELETESURFACE, 2);
467
468 if (!s)
469 {
470 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
471 return CHANNEL_RC_NO_MEMORY;
472 }
473
474 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
475 return rdpgfx_server_single_packet_send(context, s);
476}
477
478WINPR_ATTR_NODISCARD static inline BOOL
479rdpgfx_write_start_frame_pdu(wStream* s, const RDPGFX_START_FRAME_PDU* pdu)
480{
481 if (!Stream_EnsureRemainingCapacity(s, 8))
482 return FALSE;
483
484 WINPR_ASSERT(pdu);
485 Stream_Write_UINT32(s, pdu->timestamp); /* timestamp (4 bytes) */
486 Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */
487 return TRUE;
488}
489
490WINPR_ATTR_NODISCARD static inline BOOL rdpgfx_write_end_frame_pdu(wStream* s,
491 const RDPGFX_END_FRAME_PDU* pdu)
492{
493 if (!Stream_EnsureRemainingCapacity(s, 4))
494 return FALSE;
495 WINPR_ASSERT(pdu);
496 Stream_Write_UINT32(s, pdu->frameId); /* frameId (4 bytes) */
497 return TRUE;
498}
499
505WINPR_ATTR_NODISCARD static UINT rdpgfx_send_start_frame_pdu(RdpgfxServerContext* context,
506 const RDPGFX_START_FRAME_PDU* pdu)
507{
508 if (!checkCapsAreExchanged(context))
509 return CHANNEL_RC_NOT_INITIALIZED;
510
511 WINPR_ASSERT(pdu);
512 WINPR_ASSERT(context->priv);
513 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_STARTFRAME,
514 RDPGFX_START_FRAME_PDU_SIZE);
515
516 if (!s)
517 {
518 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
519 return CHANNEL_RC_NO_MEMORY;
520 }
521
522 if (!rdpgfx_write_start_frame_pdu(s, pdu))
523 {
524 Stream_Free(s, TRUE);
525 return ERROR_INTERNAL_ERROR;
526 }
527 return rdpgfx_server_single_packet_send(context, s);
528}
529
535WINPR_ATTR_NODISCARD static UINT rdpgfx_send_end_frame_pdu(RdpgfxServerContext* context,
536 const RDPGFX_END_FRAME_PDU* pdu)
537{
538 if (!checkCapsAreExchanged(context))
539 return CHANNEL_RC_NOT_INITIALIZED;
540
541 WINPR_ASSERT(pdu);
542 WINPR_ASSERT(context->priv);
543 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_ENDFRAME,
544 RDPGFX_END_FRAME_PDU_SIZE);
545
546 if (!s)
547 {
548 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
549 return CHANNEL_RC_NO_MEMORY;
550 }
551
552 if (!rdpgfx_write_end_frame_pdu(s, pdu))
553 {
554 Stream_Free(s, TRUE);
555 return ERROR_INTERNAL_ERROR;
556 }
557 return rdpgfx_server_single_packet_send(context, s);
558}
559
566WINPR_ATTR_NODISCARD static inline UINT32
567rdpgfx_estimate_h264_avc420(const RDPGFX_AVC420_BITMAP_STREAM* havc420)
568{
569 WINPR_ASSERT(havc420);
570 /* H264 metadata + H264 stream. See rdpgfx_write_h264_avc420 */
571 return sizeof(UINT32) /* numRegionRects */
572 + 10ULL /* regionRects + quantQualityVals */
573 * havc420->meta.numRegionRects +
574 havc420->length;
575}
576
583WINPR_ATTR_NODISCARD static inline UINT32
584rdpgfx_estimate_surface_command(const RDPGFX_SURFACE_COMMAND* cmd)
585{
586 RDPGFX_AVC420_BITMAP_STREAM* havc420 = nullptr;
587 RDPGFX_AVC444_BITMAP_STREAM* havc444 = nullptr;
588 UINT32 h264Size = 0;
589
590 WINPR_ASSERT(cmd);
591
592 /* Estimate stream size according to codec. */
593 switch (cmd->codecId)
594 {
595 case RDPGFX_CODECID_CAPROGRESSIVE:
596 case RDPGFX_CODECID_CAPROGRESSIVE_V2:
597 return RDPGFX_WIRE_TO_SURFACE_PDU_2_SIZE + cmd->length;
598
599 case RDPGFX_CODECID_AVC420:
600 havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
601 h264Size = rdpgfx_estimate_h264_avc420(havc420);
602 return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + h264Size;
603
604 case RDPGFX_CODECID_AVC444:
605 havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
606 h264Size = sizeof(UINT32); /* cbAvc420EncodedBitstream1 */
607 /* avc420EncodedBitstream1 */
608 havc420 = &(havc444->bitstream[0]);
609 h264Size += rdpgfx_estimate_h264_avc420(havc420);
610
611 /* avc420EncodedBitstream2 */
612 if (havc444->LC == 0)
613 {
614 havc420 = &(havc444->bitstream[1]);
615 h264Size += rdpgfx_estimate_h264_avc420(havc420);
616 }
617
618 return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + h264Size;
619
620 default:
621 return RDPGFX_WIRE_TO_SURFACE_PDU_1_SIZE + cmd->length;
622 }
623}
624
632WINPR_ATTR_NODISCARD static inline UINT16
633rdpgfx_surface_command_cmdid(const RDPGFX_SURFACE_COMMAND* cmd)
634{
635 WINPR_ASSERT(cmd);
636
637 if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||
638 cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
639 {
640 return RDPGFX_CMDID_WIRETOSURFACE_2;
641 }
642
643 return RDPGFX_CMDID_WIRETOSURFACE_1;
644}
645
651WINPR_ATTR_NODISCARD static UINT rdpgfx_write_h264_metablock(wLog* log, wStream* s,
652 const RDPGFX_H264_METABLOCK* meta)
653{
654 RECTANGLE_16* regionRect = nullptr;
655 RDPGFX_H264_QUANT_QUALITY* quantQualityVal = nullptr;
656 UINT error = CHANNEL_RC_OK;
657
658 WINPR_ASSERT(meta);
659 if (!Stream_EnsureRemainingCapacity(s, 4ull + meta->numRegionRects * 10ull))
660 return ERROR_OUTOFMEMORY;
661
662 Stream_Write_UINT32(s, meta->numRegionRects); /* numRegionRects (4 bytes) */
663
664 for (UINT32 index = 0; index < meta->numRegionRects; index++)
665 {
666 regionRect = &(meta->regionRects[index]);
667
668 if ((error = rdpgfx_write_rect16(s, regionRect)))
669 {
670 WLog_Print(log, WLOG_ERROR, "rdpgfx_write_rect16 failed with error %" PRIu32 "!",
671 error);
672 return error;
673 }
674 }
675
676 for (UINT32 index = 0; index < meta->numRegionRects; index++)
677 {
678 quantQualityVal = &(meta->quantQualityVals[index]);
679 Stream_Write_UINT8(s, WINPR_ASSERTING_INT_CAST(
680 uint8_t, quantQualityVal->qp | (quantQualityVal->r << 6) |
681 (quantQualityVal->p << 7))); /* qpVal (1 byte) */
682 /* qualityVal (1 byte) */
683 Stream_Write_UINT8(s, quantQualityVal->qualityVal);
684 }
685
686 return error;
687}
688
695WINPR_ATTR_NODISCARD static inline UINT
696rdpgfx_write_h264_avc420(wLog* log, wStream* s, RDPGFX_AVC420_BITMAP_STREAM* havc420)
697{
698 WINPR_ASSERT(havc420);
699 const UINT error = rdpgfx_write_h264_metablock(log, s, &(havc420->meta));
700
701 if (error != CHANNEL_RC_OK)
702 {
703 WLog_Print(log, WLOG_ERROR, "rdpgfx_write_h264_metablock failed with error %" PRIu32 "!",
704 error);
705 return error;
706 }
707
708 if (!Stream_EnsureRemainingCapacity(s, havc420->length))
709 return ERROR_OUTOFMEMORY;
710
711 Stream_Write(s, havc420->data, havc420->length);
712 return error;
713}
714
722WINPR_ATTR_NODISCARD static UINT rdpgfx_write_surface_command(wLog* log, wStream* s,
723 const RDPGFX_SURFACE_COMMAND* cmd)
724{
725 UINT error = CHANNEL_RC_OK;
726 RDPGFX_AVC420_BITMAP_STREAM* havc420 = nullptr;
727 RDPGFX_AVC444_BITMAP_STREAM* havc444 = nullptr;
728 UINT8 pixelFormat = 0;
729
730 WINPR_ASSERT(cmd);
731 switch (cmd->format)
732 {
733 case PIXEL_FORMAT_BGRX32:
734 pixelFormat = GFX_PIXEL_FORMAT_XRGB_8888;
735 break;
736
737 case PIXEL_FORMAT_BGRA32:
738 pixelFormat = GFX_PIXEL_FORMAT_ARGB_8888;
739 break;
740
741 default:
742 WLog_Print(log, WLOG_ERROR, "Format %s not supported!",
743 FreeRDPGetColorFormatName(cmd->format));
744 return ERROR_INVALID_DATA;
745 }
746
747 if (cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE ||
748 cmd->codecId == RDPGFX_CODECID_CAPROGRESSIVE_V2)
749 {
750 if (!Stream_EnsureRemainingCapacity(s, 13ull + cmd->length))
751 return ERROR_INTERNAL_ERROR;
752 /* Write RDPGFX_CMDID_WIRETOSURFACE_2 format for CAPROGRESSIVE */
753 Stream_Write_UINT16(
754 s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->surfaceId)); /* surfaceId (2 bytes) */
755 Stream_Write_UINT16(
756 s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->codecId)); /* codecId (2 bytes) */
757 Stream_Write_UINT32(s, cmd->contextId); /* codecContextId (4 bytes) */
758 Stream_Write_UINT8(s, pixelFormat); /* pixelFormat (1 byte) */
759 Stream_Write_UINT32(s, cmd->length); /* bitmapDataLength (4 bytes) */
760 Stream_Write(s, cmd->data, cmd->length);
761 }
762 else
763 {
764 /* Write RDPGFX_CMDID_WIRETOSURFACE_1 format for others */
765 if (!Stream_EnsureRemainingCapacity(s, 17))
766 return ERROR_INTERNAL_ERROR;
767 Stream_Write_UINT16(
768 s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->surfaceId)); /* surfaceId (2 bytes) */
769 Stream_Write_UINT16(
770 s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->codecId)); /* codecId (2 bytes) */
771 Stream_Write_UINT8(s, pixelFormat); /* pixelFormat (1 byte) */
772 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->left)); /* left (2 bytes) */
773 Stream_Write_UINT16(s, WINPR_ASSERTING_INT_CAST(uint16_t, cmd->top)); /* top (2 bytes) */
774 Stream_Write_UINT16(s,
775 WINPR_ASSERTING_INT_CAST(uint16_t, cmd->right)); /* right (2 bytes) */
776 Stream_Write_UINT16(s,
777 WINPR_ASSERTING_INT_CAST(uint16_t, cmd->bottom)); /* bottom (2 bytes) */
778 Stream_Write_UINT32(s, cmd->length); /* bitmapDataLength (4 bytes) */
779 const size_t bitmapDataStart = Stream_GetPosition(s);
780
781 switch (cmd->codecId)
782 {
783#if defined(WITH_GFX_AV1)
784 case RDPGFX_CODECID_AV1:
785#endif
786 case RDPGFX_CODECID_AVC420:
787 {
788 havc420 = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
789 error = rdpgfx_write_h264_avc420(log, s, havc420);
790
791 if (error != CHANNEL_RC_OK)
792 {
793 WLog_Print(log, WLOG_ERROR, "rdpgfx_write_h264_avc420 failed!");
794 return error;
795 }
796 }
797 break;
798
799 case RDPGFX_CODECID_AVC444:
800 case RDPGFX_CODECID_AVC444v2:
801 {
802 havc444 = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
803 havc420 = &(havc444->bitstream[0]); /* avc420EncodedBitstreamInfo (4 bytes) */
804 if (!Stream_EnsureRemainingCapacity(s, 4))
805 return ERROR_INTERNAL_ERROR;
806 Stream_Write_UINT32(s, havc444->cbAvc420EncodedBitstream1 |
807 ((uint32_t)havc444->LC << 30UL));
808 /* avc420EncodedBitstream1 */
809 error = rdpgfx_write_h264_avc420(log, s, havc420);
810
811 if (error != CHANNEL_RC_OK)
812 {
813 WLog_Print(log, WLOG_ERROR, "rdpgfx_write_h264_avc420 failed!");
814 return error;
815 }
816
817 /* avc420EncodedBitstream2 */
818 if (havc444->LC == 0)
819 {
820 havc420 = &(havc444->bitstream[1]);
821 error = rdpgfx_write_h264_avc420(log, s, havc420);
822
823 if (error != CHANNEL_RC_OK)
824 {
825 WLog_Print(log, WLOG_ERROR, "rdpgfx_write_h264_avc420 failed!");
826 return error;
827 }
828 }
829 }
830 break;
831 default:
832 if (!Stream_EnsureRemainingCapacity(s, cmd->length))
833 return ERROR_INTERNAL_ERROR;
834 Stream_Write(s, cmd->data, cmd->length);
835 break;
836 }
837
838 /* Fill actual bitmap data length */
839 const size_t bitmapDataLength = Stream_GetPosition(s) - bitmapDataStart;
840 if (bitmapDataLength > UINT32_MAX)
841 return ERROR_INTERNAL_ERROR;
842
843 if (!Stream_SetPosition(s, bitmapDataStart - sizeof(UINT32)))
844 return ERROR_INVALID_DATA;
845 if (!Stream_EnsureRemainingCapacity(s, 4))
846 return ERROR_INTERNAL_ERROR;
847 Stream_Write_UINT32(s, (UINT32)bitmapDataLength); /* bitmapDataLength (4 bytes) */
848 if (!Stream_SafeSeek(s, bitmapDataLength))
849 return ERROR_INTERNAL_ERROR;
850 }
851
852 return error;
853}
854
862WINPR_ATTR_NODISCARD static UINT rdpgfx_send_surface_command(RdpgfxServerContext* context,
863 const RDPGFX_SURFACE_COMMAND* cmd)
864{
865 if (!checkCapsAreExchanged(context))
866 return CHANNEL_RC_NOT_INITIALIZED;
867 UINT error = CHANNEL_RC_OK;
868
869 WINPR_ASSERT(context);
870 WINPR_ASSERT(context->priv);
871 WINPR_ASSERT(cmd);
872
873 wStream* s =
874 rdpgfx_server_single_packet_new(context->priv->log, rdpgfx_surface_command_cmdid(cmd),
875 rdpgfx_estimate_surface_command(cmd));
876
877 if (!s)
878 {
879 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
880 return CHANNEL_RC_NO_MEMORY;
881 }
882
883 error = rdpgfx_write_surface_command(context->priv->log, s, cmd);
884
885 if (error != CHANNEL_RC_OK)
886 {
887 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_write_surface_command failed!");
888 goto error;
889 }
890
891 return rdpgfx_server_single_packet_send(context, s);
892error:
893 Stream_Free(s, TRUE);
894 return error;
895}
896
905WINPR_ATTR_NODISCARD static UINT
906rdpgfx_send_surface_frame_command(RdpgfxServerContext* context, const RDPGFX_SURFACE_COMMAND* cmd,
907 const RDPGFX_START_FRAME_PDU* startFrame,
908 const RDPGFX_END_FRAME_PDU* endFrame)
909
910{
911 if (!checkCapsAreExchanged(context))
912 return CHANNEL_RC_NOT_INITIALIZED;
913
914 WINPR_ASSERT(context->priv);
915 WINPR_ASSERT(cmd);
916 WINPR_ASSERT(startFrame);
917 WINPR_ASSERT(endFrame);
918
919 UINT error = CHANNEL_RC_OK;
920 size_t size = rdpgfx_pdu_length(rdpgfx_estimate_surface_command(cmd));
921
922 if (startFrame)
923 {
924 size += rdpgfx_pdu_length(RDPGFX_START_FRAME_PDU_SIZE);
925 }
926
927 if (endFrame)
928 {
929 size += rdpgfx_pdu_length(RDPGFX_END_FRAME_PDU_SIZE);
930 }
931
932 wStream* s = Stream_New(nullptr, size);
933
934 if (!s)
935 {
936 WLog_Print(context->priv->log, WLOG_ERROR, "Stream_New failed!");
937 return CHANNEL_RC_NO_MEMORY;
938 }
939
940 /* Write start frame if exists */
941 if (startFrame)
942 {
943 const size_t position = Stream_GetPosition(s);
944 error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_STARTFRAME, 0);
945
946 if (error != CHANNEL_RC_OK)
947 {
948 WLog_Print(context->priv->log, WLOG_ERROR,
949 "Failed to init header with error %" PRIu32 "!", error);
950 goto error;
951 }
952
953 if (!rdpgfx_write_start_frame_pdu(s, startFrame) ||
954 !rdpgfx_server_packet_complete_header(s, position))
955 {
956 error = ERROR_INTERNAL_ERROR;
957 goto error;
958 }
959 }
960
961 /* Write RDPGFX_CMDID_WIRETOSURFACE_1 or RDPGFX_CMDID_WIRETOSURFACE_2 */
962 {
963 const size_t pos = Stream_GetPosition(s);
964 error = rdpgfx_server_packet_init_header(s, rdpgfx_surface_command_cmdid(cmd),
965 0); // Actual length will be filled later
966
967 if (error != CHANNEL_RC_OK)
968 {
969 WLog_Print(context->priv->log, WLOG_ERROR,
970 "Failed to init header with error %" PRIu32 "!", error);
971 goto error;
972 }
973
974 error = rdpgfx_write_surface_command(context->priv->log, s, cmd);
975
976 if (error != CHANNEL_RC_OK)
977 {
978 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_write_surface_command failed!");
979 goto error;
980 }
981
982 if (!rdpgfx_server_packet_complete_header(s, pos))
983 {
984 error = ERROR_INTERNAL_ERROR;
985 goto error;
986 }
987 }
988
989 /* Write end frame if exists */
990 if (endFrame)
991 {
992 const size_t position = Stream_GetPosition(s);
993 error = rdpgfx_server_packet_init_header(s, RDPGFX_CMDID_ENDFRAME, 0);
994
995 if (error != CHANNEL_RC_OK)
996 {
997 WLog_Print(context->priv->log, WLOG_ERROR,
998 "Failed to init header with error %" PRIu32 "!", error);
999 goto error;
1000 }
1001
1002 if (!rdpgfx_write_end_frame_pdu(s, endFrame) ||
1003 !rdpgfx_server_packet_complete_header(s, position))
1004 {
1005 error = ERROR_INTERNAL_ERROR;
1006 goto error;
1007 }
1008 }
1009
1010 return rdpgfx_server_packet_send(context, s);
1011error:
1012 Stream_Free(s, TRUE);
1013 return error;
1014}
1015
1021WINPR_ATTR_NODISCARD static UINT
1022rdpgfx_send_delete_encoding_context_pdu(RdpgfxServerContext* context,
1023 const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* pdu)
1024{
1025 if (!checkCapsAreExchanged(context))
1026 return CHANNEL_RC_NOT_INITIALIZED;
1027
1028 WINPR_ASSERT(context->priv);
1029 WINPR_ASSERT(pdu);
1030 wStream* s =
1031 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_DELETEENCODINGCONTEXT, 6);
1032
1033 if (!s)
1034 {
1035 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1036 return CHANNEL_RC_NO_MEMORY;
1037 }
1038
1039 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1040 Stream_Write_UINT32(s, pdu->codecContextId); /* codecContextId (4 bytes) */
1041 return rdpgfx_server_single_packet_send(context, s);
1042}
1043
1049WINPR_ATTR_NODISCARD static UINT rdpgfx_send_solid_fill_pdu(RdpgfxServerContext* context,
1050 const RDPGFX_SOLID_FILL_PDU* pdu)
1051{
1052 if (!checkCapsAreExchanged(context))
1053 return CHANNEL_RC_NOT_INITIALIZED;
1054
1055 WINPR_ASSERT(context->priv);
1056 WINPR_ASSERT(pdu);
1057
1058 UINT error = CHANNEL_RC_OK;
1059 RECTANGLE_16* fillRect = nullptr;
1060 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_SOLIDFILL,
1061 8 + 8 * pdu->fillRectCount);
1062
1063 if (!s)
1064 {
1065 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1066 return CHANNEL_RC_NO_MEMORY;
1067 }
1068
1069 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1070
1071 /* fillPixel (4 bytes) */
1072 if ((error = rdpgfx_write_color32(s, &(pdu->fillPixel))))
1073 {
1074 WLog_Print(context->priv->log, WLOG_ERROR,
1075 "rdpgfx_write_color32 failed with error %" PRIu32 "!", error);
1076 goto error;
1077 }
1078
1079 Stream_Write_UINT16(s, pdu->fillRectCount); /* fillRectCount (2 bytes) */
1080
1081 for (UINT16 index = 0; index < pdu->fillRectCount; index++)
1082 {
1083 fillRect = &(pdu->fillRects[index]);
1084
1085 if ((error = rdpgfx_write_rect16(s, fillRect)))
1086 {
1087 WLog_Print(context->priv->log, WLOG_ERROR,
1088 "rdpgfx_write_rect16 failed with error %" PRIu32 "!", error);
1089 goto error;
1090 }
1091 }
1092
1093 return rdpgfx_server_single_packet_send(context, s);
1094error:
1095 Stream_Free(s, TRUE);
1096 return error;
1097}
1098
1104WINPR_ATTR_NODISCARD static UINT
1105rdpgfx_send_surface_to_surface_pdu(RdpgfxServerContext* context,
1106 const RDPGFX_SURFACE_TO_SURFACE_PDU* pdu)
1107{
1108 if (!checkCapsAreExchanged(context))
1109 return CHANNEL_RC_NOT_INITIALIZED;
1110
1111 WINPR_ASSERT(pdu);
1112 WINPR_ASSERT(context->priv);
1113
1114 UINT error = CHANNEL_RC_OK;
1115 RDPGFX_POINT16* destPt = nullptr;
1116 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_SURFACETOSURFACE,
1117 14 + 4 * pdu->destPtsCount);
1118
1119 if (!s)
1120 {
1121 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1122 return CHANNEL_RC_NO_MEMORY;
1123 }
1124
1125 Stream_Write_UINT16(s, pdu->surfaceIdSrc); /* surfaceIdSrc (2 bytes) */
1126 Stream_Write_UINT16(s, pdu->surfaceIdDest); /* surfaceIdDest (2 bytes) */
1127
1128 /* rectSrc (8 bytes ) */
1129 if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc))))
1130 {
1131 WLog_Print(context->priv->log, WLOG_ERROR,
1132 "rdpgfx_write_rect16 failed with error %" PRIu32 "!", error);
1133 goto error;
1134 }
1135
1136 Stream_Write_UINT16(s, pdu->destPtsCount); /* destPtsCount (2 bytes) */
1137
1138 for (UINT16 index = 0; index < pdu->destPtsCount; index++)
1139 {
1140 destPt = &(pdu->destPts[index]);
1141
1142 if ((error = rdpgfx_write_point16(s, destPt)))
1143 {
1144 WLog_Print(context->priv->log, WLOG_ERROR,
1145 "rdpgfx_write_point16 failed with error %" PRIu32 "!", error);
1146 goto error;
1147 }
1148 }
1149
1150 return rdpgfx_server_single_packet_send(context, s);
1151error:
1152 Stream_Free(s, TRUE);
1153 return error;
1154}
1155
1161WINPR_ATTR_NODISCARD static UINT
1162rdpgfx_send_surface_to_cache_pdu(RdpgfxServerContext* context,
1163 const RDPGFX_SURFACE_TO_CACHE_PDU* pdu)
1164{
1165 if (!checkCapsAreExchanged(context))
1166 return CHANNEL_RC_NOT_INITIALIZED;
1167
1168 WINPR_ASSERT(pdu);
1169 WINPR_ASSERT(context->priv);
1170
1171 UINT error = CHANNEL_RC_OK;
1172 wStream* s =
1173 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_SURFACETOCACHE, 20);
1174
1175 if (!s)
1176 {
1177 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1178 return CHANNEL_RC_NO_MEMORY;
1179 }
1180
1181 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1182 Stream_Write_UINT64(s, pdu->cacheKey); /* cacheKey (8 bytes) */
1183 Stream_Write_UINT16(s, pdu->cacheSlot); /* cacheSlot (2 bytes) */
1184
1185 /* rectSrc (8 bytes ) */
1186 if ((error = rdpgfx_write_rect16(s, &(pdu->rectSrc))))
1187 {
1188 WLog_Print(context->priv->log, WLOG_ERROR,
1189 "rdpgfx_write_rect16 failed with error %" PRIu32 "!", error);
1190 goto error;
1191 }
1192
1193 return rdpgfx_server_single_packet_send(context, s);
1194error:
1195 Stream_Free(s, TRUE);
1196 return error;
1197}
1198
1204WINPR_ATTR_NODISCARD static UINT
1205rdpgfx_send_cache_to_surface_pdu(RdpgfxServerContext* context,
1206 const RDPGFX_CACHE_TO_SURFACE_PDU* pdu)
1207{
1208 if (!checkCapsAreExchanged(context))
1209 return CHANNEL_RC_NOT_INITIALIZED;
1210
1211 WINPR_ASSERT(pdu);
1212 WINPR_ASSERT(context->priv);
1213
1214 UINT error = CHANNEL_RC_OK;
1215 RDPGFX_POINT16* destPt = nullptr;
1216 wStream* s = rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_CACHETOSURFACE,
1217 6 + 4 * pdu->destPtsCount);
1218
1219 if (!s)
1220 {
1221 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1222 return CHANNEL_RC_NO_MEMORY;
1223 }
1224
1225 Stream_Write_UINT16(s, pdu->cacheSlot); /* cacheSlot (2 bytes) */
1226 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1227 Stream_Write_UINT16(s, pdu->destPtsCount); /* destPtsCount (2 bytes) */
1228
1229 for (UINT16 index = 0; index < pdu->destPtsCount; index++)
1230 {
1231 destPt = &(pdu->destPts[index]);
1232
1233 if ((error = rdpgfx_write_point16(s, destPt)))
1234 {
1235 WLog_Print(context->priv->log, WLOG_ERROR,
1236 "rdpgfx_write_point16 failed with error %" PRIu32 "", error);
1237 goto error;
1238 }
1239 }
1240
1241 return rdpgfx_server_single_packet_send(context, s);
1242error:
1243 Stream_Free(s, TRUE);
1244 return error;
1245}
1246
1252WINPR_ATTR_NODISCARD static UINT
1253rdpgfx_send_map_surface_to_output_pdu(RdpgfxServerContext* context,
1254 const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* pdu)
1255{
1256 if (!checkCapsAreExchanged(context))
1257 return CHANNEL_RC_NOT_INITIALIZED;
1258
1259 WINPR_ASSERT(pdu);
1260 WINPR_ASSERT(context->priv);
1261 wStream* s =
1262 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_MAPSURFACETOOUTPUT, 12);
1263
1264 if (!s)
1265 {
1266 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1267 return CHANNEL_RC_NO_MEMORY;
1268 }
1269
1270 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1271 Stream_Write_UINT16(s, 0); /* reserved (2 bytes). Must be 0 */
1272 Stream_Write_UINT32(s, pdu->outputOriginX); /* outputOriginX (4 bytes) */
1273 Stream_Write_UINT32(s, pdu->outputOriginY); /* outputOriginY (4 bytes) */
1274 return rdpgfx_server_single_packet_send(context, s);
1275}
1276
1282WINPR_ATTR_NODISCARD static UINT
1283rdpgfx_send_map_surface_to_window_pdu(RdpgfxServerContext* context,
1284 const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* pdu)
1285{
1286 if (!checkCapsAreExchanged(context))
1287 return CHANNEL_RC_NOT_INITIALIZED;
1288
1289 WINPR_ASSERT(pdu);
1290 WINPR_ASSERT(context->priv);
1291
1292 wStream* s =
1293 rdpgfx_server_single_packet_new(context->priv->log, RDPGFX_CMDID_MAPSURFACETOWINDOW, 18);
1294
1295 if (!s)
1296 {
1297 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1298 return CHANNEL_RC_NO_MEMORY;
1299 }
1300
1301 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1302 Stream_Write_UINT64(s, pdu->windowId); /* windowId (8 bytes) */
1303 Stream_Write_UINT32(s, pdu->mappedWidth); /* mappedWidth (4 bytes) */
1304 Stream_Write_UINT32(s, pdu->mappedHeight); /* mappedHeight (4 bytes) */
1305 return rdpgfx_server_single_packet_send(context, s);
1306}
1307
1308WINPR_ATTR_NODISCARD static UINT
1309rdpgfx_send_map_surface_to_scaled_window_pdu(RdpgfxServerContext* context,
1310 const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* pdu)
1311{
1312 if (!checkCapsAreExchanged(context))
1313 return CHANNEL_RC_NOT_INITIALIZED;
1314
1315 WINPR_ASSERT(pdu);
1316 WINPR_ASSERT(context->priv);
1317 wStream* s = rdpgfx_server_single_packet_new(context->priv->log,
1318 RDPGFX_CMDID_MAPSURFACETOSCALEDWINDOW, 26);
1319
1320 if (!s)
1321 {
1322 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1323 return CHANNEL_RC_NO_MEMORY;
1324 }
1325
1326 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1327 Stream_Write_UINT64(s, pdu->windowId); /* windowId (8 bytes) */
1328 Stream_Write_UINT32(s, pdu->mappedWidth); /* mappedWidth (4 bytes) */
1329 Stream_Write_UINT32(s, pdu->mappedHeight); /* mappedHeight (4 bytes) */
1330 Stream_Write_UINT32(s, pdu->targetWidth); /* targetWidth (4 bytes) */
1331 Stream_Write_UINT32(s, pdu->targetHeight); /* targetHeight (4 bytes) */
1332 return rdpgfx_server_single_packet_send(context, s);
1333}
1334
1340WINPR_ATTR_NODISCARD static UINT rdpgfx_recv_frame_acknowledge_pdu(RdpgfxServerContext* context,
1341 wStream* s)
1342{
1343 WINPR_ASSERT(context);
1344
1345 if (!checkCapsAreExchanged(context))
1346 return CHANNEL_RC_NOT_INITIALIZED;
1347
1348 WINPR_ASSERT(context->priv);
1349
1350 RDPGFX_FRAME_ACKNOWLEDGE_PDU pdu = WINPR_C_ARRAY_INIT;
1351 UINT error = CHANNEL_RC_OK;
1352
1353 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 12))
1354 return ERROR_INVALID_DATA;
1355
1356 Stream_Read_UINT32(s, pdu.queueDepth); /* queueDepth (4 bytes) */
1357 Stream_Read_UINT32(s, pdu.frameId); /* frameId (4 bytes) */
1358 Stream_Read_UINT32(s, pdu.totalFramesDecoded); /* totalFramesDecoded (4 bytes) */
1359
1360 IFCALLRET(context->FrameAcknowledge, error, context, &pdu);
1361
1362 if (error)
1363 WLog_Print(context->priv->log, WLOG_ERROR,
1364 "context->FrameAcknowledge failed with error %" PRIu32 "", error);
1365
1366 return error;
1367}
1368
1374WINPR_ATTR_NODISCARD static UINT rdpgfx_recv_cache_import_offer_pdu(RdpgfxServerContext* context,
1375 wStream* s)
1376{
1377 WINPR_ASSERT(context);
1378 if (!checkCapsAreExchanged(context))
1379 return CHANNEL_RC_NOT_INITIALIZED;
1380
1381 WINPR_ASSERT(context->priv);
1382
1383 RDPGFX_CACHE_IMPORT_OFFER_PDU pdu = WINPR_C_ARRAY_INIT;
1384 RDPGFX_CACHE_ENTRY_METADATA* cacheEntry = nullptr;
1385 UINT error = CHANNEL_RC_OK;
1386
1387 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 2))
1388 return ERROR_INVALID_DATA;
1389
1390 /* cacheEntriesCount (2 bytes) */
1391 Stream_Read_UINT16(s, pdu.cacheEntriesCount);
1392
1393 /* 2.2.2.16 RDPGFX_CACHE_IMPORT_OFFER_PDU */
1394 if (pdu.cacheEntriesCount >= 5462)
1395 {
1396 WLog_Print(context->priv->log, WLOG_ERROR, "Invalid cacheEntriesCount: %" PRIu16 "",
1397 pdu.cacheEntriesCount);
1398 return ERROR_INVALID_DATA;
1399 }
1400
1401 if (!Stream_CheckAndLogRequiredLengthOfSizeWLog(context->priv->log, s, pdu.cacheEntriesCount,
1402 12ull))
1403 return ERROR_INVALID_DATA;
1404
1405 for (UINT16 index = 0; index < pdu.cacheEntriesCount; index++)
1406 {
1407 cacheEntry = &(pdu.cacheEntries[index]);
1408 Stream_Read_UINT64(s, cacheEntry->cacheKey); /* cacheKey (8 bytes) */
1409 Stream_Read_UINT32(s, cacheEntry->bitmapLength); /* bitmapLength (4 bytes) */
1410 }
1411
1412 IFCALLRET(context->CacheImportOffer, error, context, &pdu);
1413
1414 if (error)
1415 WLog_Print(context->priv->log, WLOG_ERROR,
1416 "context->CacheImportOffer failed with error %" PRIu32 "", error);
1417
1418 return error;
1419}
1420
1426WINPR_ATTR_NODISCARD static UINT rdpgfx_recv_caps_advertise_pdu(RdpgfxServerContext* context,
1427 wStream* s)
1428{
1429 RDPGFX_CAPSET* capsSets = nullptr;
1430 RDPGFX_CAPS_ADVERTISE_PDU pdu = WINPR_C_ARRAY_INIT;
1431 UINT error = ERROR_INVALID_DATA;
1432
1433 if (!context)
1434 return ERROR_BAD_ARGUMENTS;
1435
1436 WINPR_ASSERT(context->priv);
1437 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 2))
1438 return ERROR_INVALID_DATA;
1439
1440 Stream_Read_UINT16(s, pdu.capsSetCount); /* capsSetCount (2 bytes) */
1441 if (pdu.capsSetCount > 0)
1442 {
1443 capsSets = calloc(pdu.capsSetCount, (RDPGFX_CAPSET_BASE_SIZE + 4));
1444 if (!capsSets)
1445 return ERROR_OUTOFMEMORY;
1446 }
1447
1448 pdu.capsSets = capsSets;
1449
1450 for (UINT16 index = 0; index < pdu.capsSetCount; index++)
1451 {
1452 RDPGFX_CAPSET* capsSet = &(pdu.capsSets[index]);
1453
1454 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 8))
1455 goto fail;
1456
1457 Stream_Read_UINT32(s, capsSet->version); /* version (4 bytes) */
1458 Stream_Read_UINT32(s, capsSet->length); /* capsDataLength (4 bytes) */
1459
1460 if (capsSet->length >= 4)
1461 {
1462 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 4))
1463 goto fail;
1464
1465 Stream_Peek_UINT32(s, capsSet->flags); /* capsData (4 bytes) */
1466 }
1467
1468 if (!Stream_SafeSeek(s, capsSet->length))
1469 goto fail;
1470 }
1471
1472 error = ERROR_BAD_CONFIGURATION;
1473 IFCALLRET(context->CapsAdvertise, error, context, &pdu);
1474
1475 if (error)
1476 WLog_Print(context->priv->log, WLOG_ERROR,
1477 "context->CapsAdvertise failed with error %" PRIu32 "", error);
1478
1479fail:
1480 free(capsSets);
1481 return error;
1482}
1483
1489WINPR_ATTR_NODISCARD static UINT rdpgfx_recv_qoe_frame_acknowledge_pdu(RdpgfxServerContext* context,
1490 wStream* s)
1491{
1492 WINPR_ASSERT(context);
1493
1494 if (!checkCapsAreExchanged(context))
1495 return CHANNEL_RC_NOT_INITIALIZED;
1496
1497 RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU pdu = WINPR_C_ARRAY_INIT;
1498 UINT error = CHANNEL_RC_OK;
1499
1500 WINPR_ASSERT(context->priv);
1501
1502 if (!Stream_CheckAndLogRequiredLengthWLog(context->priv->log, s, 12))
1503 return ERROR_INVALID_DATA;
1504
1505 Stream_Read_UINT32(s, pdu.frameId); /* frameId (4 bytes) */
1506 Stream_Read_UINT32(s, pdu.timestamp); /* timestamp (4 bytes) */
1507 Stream_Read_UINT16(s, pdu.timeDiffSE); /* timeDiffSE (2 bytes) */
1508 Stream_Read_UINT16(s, pdu.timeDiffEDR); /* timeDiffEDR (2 bytes) */
1509
1510 IFCALLRET(context->QoeFrameAcknowledge, error, context, &pdu);
1511
1512 if (error)
1513 WLog_Print(context->priv->log, WLOG_ERROR,
1514 "context->QoeFrameAcknowledge failed with error %" PRIu32 "", error);
1515
1516 return error;
1517}
1518
1519WINPR_ATTR_NODISCARD static UINT
1520rdpgfx_send_map_surface_to_scaled_output_pdu(RdpgfxServerContext* context,
1521 const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* pdu)
1522{
1523 if (!checkCapsAreExchanged(context))
1524 return CHANNEL_RC_NOT_INITIALIZED;
1525
1526 WINPR_ASSERT(pdu);
1527 WINPR_ASSERT(context->priv);
1528 wStream* s = rdpgfx_server_single_packet_new(context->priv->log,
1529 RDPGFX_CMDID_MAPSURFACETOSCALEDOUTPUT, 20);
1530
1531 if (!s)
1532 {
1533 WLog_Print(context->priv->log, WLOG_ERROR, "rdpgfx_server_single_packet_new failed!");
1534 return CHANNEL_RC_NO_MEMORY;
1535 }
1536
1537 Stream_Write_UINT16(s, pdu->surfaceId); /* surfaceId (2 bytes) */
1538 Stream_Write_UINT16(s, 0); /* reserved (2 bytes). Must be 0 */
1539 Stream_Write_UINT32(s, pdu->outputOriginX); /* outputOriginX (4 bytes) */
1540 Stream_Write_UINT32(s, pdu->outputOriginY); /* outputOriginY (4 bytes) */
1541 Stream_Write_UINT32(s, pdu->targetWidth); /* targetWidth (4 bytes) */
1542 Stream_Write_UINT32(s, pdu->targetHeight); /* targetHeight (4 bytes) */
1543 return rdpgfx_server_single_packet_send(context, s);
1544}
1545
1551WINPR_ATTR_NODISCARD static UINT rdpgfx_server_receive_pdu(RdpgfxServerContext* context,
1552 wStream* data)
1553{
1554 size_t packetlen = 0;
1555 wStream sbuffer = WINPR_C_ARRAY_INIT;
1556 RDPGFX_HEADER header = WINPR_C_ARRAY_INIT;
1557 UINT error = CHANNEL_RC_OK;
1558
1559 WINPR_ASSERT(context);
1560 WINPR_ASSERT(context->priv);
1561
1562 if ((error = rdpgfx_read_header(context->priv->log, data, &header, &packetlen)))
1563 {
1564 WLog_Print(context->priv->log, WLOG_ERROR,
1565 "rdpgfx_read_header failed with error %" PRIu32 "!", error);
1566 return error;
1567 }
1568
1569 /* Limit the PDU parsers to the data of this PDU, the stream might contain more of them */
1570 wStream* s = Stream_StaticConstInit(&sbuffer, Stream_ConstPointer(data), packetlen);
1571 Stream_Seek(data, packetlen);
1572
1573 WLog_Print(context->priv->log, WLOG_TRACE,
1574 "cmdId: %s (0x%04" PRIX16 ") flags: 0x%04" PRIX16 " pduLength: %" PRIu32 "",
1575 rdpgfx_get_cmd_id_string(header.cmdId), header.cmdId, header.flags,
1576 header.pduLength);
1577
1578 switch (header.cmdId)
1579 {
1580 case RDPGFX_CMDID_FRAMEACKNOWLEDGE:
1581 if ((error = rdpgfx_recv_frame_acknowledge_pdu(context, s)))
1582 WLog_Print(context->priv->log, WLOG_ERROR,
1583 "rdpgfx_recv_frame_acknowledge_pdu "
1584 "failed with error %" PRIu32 "!",
1585 error);
1586
1587 break;
1588
1589 case RDPGFX_CMDID_CACHEIMPORTOFFER:
1590 if ((error = rdpgfx_recv_cache_import_offer_pdu(context, s)))
1591 WLog_Print(context->priv->log, WLOG_ERROR,
1592 "rdpgfx_recv_cache_import_offer_pdu "
1593 "failed with error %" PRIu32 "!",
1594 error);
1595
1596 break;
1597
1598 case RDPGFX_CMDID_CAPSADVERTISE:
1599 if ((error = rdpgfx_recv_caps_advertise_pdu(context, s)))
1600 WLog_Print(context->priv->log, WLOG_ERROR,
1601 "rdpgfx_recv_caps_advertise_pdu "
1602 "failed with error %" PRIu32 "!",
1603 error);
1604
1605 break;
1606
1607 case RDPGFX_CMDID_QOEFRAMEACKNOWLEDGE:
1608 if ((error = rdpgfx_recv_qoe_frame_acknowledge_pdu(context, s)))
1609 WLog_Print(context->priv->log, WLOG_ERROR,
1610 "rdpgfx_recv_qoe_frame_acknowledge_pdu "
1611 "failed with error %" PRIu32 "!",
1612 error);
1613
1614 break;
1615
1616 default:
1617 error = CHANNEL_RC_BAD_PROC;
1618 break;
1619 }
1620
1621 if (error)
1622 {
1623 WLog_Print(context->priv->log, WLOG_ERROR,
1624 "Error while parsing GFX cmdId: %s (0x%04" PRIX16 ")",
1625 rdpgfx_get_cmd_id_string(header.cmdId), header.cmdId);
1626 return error;
1627 }
1628
1629 const size_t end = Stream_GetPosition(s);
1630
1631 if (end != packetlen)
1632 {
1633 WLog_Print(context->priv->log, WLOG_ERROR,
1634 "Unexpected gfx pdu end: Actual: %" PRIuz ", Expected: %" PRIuz "", end,
1635 packetlen);
1636 }
1637
1638 return error;
1639}
1640
1641WINPR_ATTR_NODISCARD static DWORD WINAPI rdpgfx_server_thread_func(LPVOID arg)
1642{
1643 RdpgfxServerContext* context = (RdpgfxServerContext*)arg;
1644 WINPR_ASSERT(context);
1645
1646 RdpgfxServerPrivate* priv = context->priv;
1647 DWORD status = 0;
1648 DWORD nCount = 0;
1649 HANDLE events[8] = WINPR_C_ARRAY_INIT;
1650 UINT error = CHANNEL_RC_OK;
1651
1652 WINPR_ASSERT(priv);
1653
1654 if (priv->ownThread)
1655 {
1656 WINPR_ASSERT(priv->stopEvent);
1657 events[nCount++] = priv->stopEvent;
1658 }
1659
1660 WINPR_ASSERT(priv->channelEvent);
1661 events[nCount++] = priv->channelEvent;
1662
1663 /* Main virtual channel loop. RDPGFX do not need version negotiation */
1664 while (TRUE)
1665 {
1666 status = WaitForMultipleObjects(nCount, events, FALSE, INFINITE);
1667
1668 if (status == WAIT_FAILED)
1669 {
1670 error = GetLastError();
1671 WLog_Print(context->priv->log, WLOG_ERROR,
1672 "WaitForMultipleObjects failed with error %" PRIu32 "", error);
1673 break;
1674 }
1675
1676 /* Stop Event */
1677 if (status == WAIT_OBJECT_0)
1678 break;
1679
1680 if ((error = rdpgfx_server_handle_messages(context)))
1681 {
1682 WLog_Print(context->priv->log, WLOG_ERROR,
1683 "rdpgfx_server_handle_messages failed with error %" PRIu32 "", error);
1684 break;
1685 }
1686 }
1687
1688 if (error && context->rdpcontext)
1689 setChannelError(context->rdpcontext, error, "rdpgfx_server_thread_func reported an error");
1690
1691 ExitThread(error);
1692 return error;
1693}
1694
1695WINPR_ATTR_NODISCARD static BOOL rdpgfx_server_open(RdpgfxServerContext* context)
1696{
1697 WINPR_ASSERT(context);
1698 RdpgfxServerPrivate* priv = context->priv;
1699 void* buffer = nullptr;
1700
1701 WINPR_ASSERT(priv);
1702
1703 if (!priv->isOpened)
1704 {
1705 PULONG pSessionId = nullptr;
1706 DWORD BytesReturned = 0;
1707 priv->SessionId = WTS_CURRENT_SESSION;
1708 UINT32 channelId = 0;
1709 BOOL status = TRUE;
1710
1711 if (WTSQuerySessionInformationA(context->vcm, WTS_CURRENT_SESSION, WTSSessionId,
1712 (LPSTR*)&pSessionId, &BytesReturned) == FALSE)
1713 {
1714 WLog_Print(context->priv->log, WLOG_ERROR, "WTSQuerySessionInformationA failed!");
1715 return FALSE;
1716 }
1717
1718 priv->SessionId = (DWORD)*pSessionId;
1719 WTSFreeMemory(pSessionId);
1720 priv->rdpgfx_channel = WTSVirtualChannelOpenEx(priv->SessionId, RDPGFX_DVC_CHANNEL_NAME,
1721 WTS_CHANNEL_OPTION_DYNAMIC);
1722
1723 if (!priv->rdpgfx_channel)
1724 {
1725 WLog_Print(context->priv->log, WLOG_ERROR, "WTSVirtualChannelOpenEx failed!");
1726 return FALSE;
1727 }
1728
1729 channelId = WTSChannelGetIdByHandle(priv->rdpgfx_channel);
1730
1731 IFCALLRET(context->ChannelIdAssigned, status, context, channelId);
1732 if (!status)
1733 {
1734 WLog_Print(context->priv->log, WLOG_ERROR, "context->ChannelIdAssigned failed!");
1735 goto fail;
1736 }
1737
1738 /* Query for channel event handle */
1739 if (!WTSVirtualChannelQuery(priv->rdpgfx_channel, WTSVirtualEventHandle, &buffer,
1740 &BytesReturned) ||
1741 (BytesReturned != sizeof(HANDLE)))
1742 {
1743 WLog_Print(context->priv->log, WLOG_ERROR,
1744 "WTSVirtualChannelQuery failed "
1745 "or invalid returned size(%" PRIu32 ")",
1746 BytesReturned);
1747
1748 if (buffer)
1749 WTSFreeMemory(buffer);
1750
1751 goto fail;
1752 }
1753
1754 priv->channelEvent = *(HANDLE*)buffer;
1755 WTSFreeMemory(buffer);
1756
1757 if (!(priv->zgfx = zgfx_context_new(TRUE)))
1758 {
1759 WLog_Print(context->priv->log, WLOG_ERROR, "Create zgfx context failed!");
1760 goto fail;
1761 }
1762
1763 priv->isReady = FALSE;
1764 const RDPGFX_CAPSET empty = WINPR_C_ARRAY_INIT;
1765 priv->activeCapSet = empty;
1766 if (priv->ownThread)
1767 {
1768 if (!(priv->stopEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr)))
1769 {
1770 WLog_Print(context->priv->log, WLOG_ERROR, "CreateEvent failed!");
1771 goto fail;
1772 }
1773
1774 if (!(priv->thread = CreateThread(nullptr, 0, rdpgfx_server_thread_func, (void*)context,
1775 0, nullptr)))
1776 {
1777 WLog_Print(context->priv->log, WLOG_ERROR, "CreateThread failed!");
1778 goto fail;
1779 }
1780 }
1781
1782 priv->isOpened = TRUE;
1783 return TRUE;
1784 }
1785
1786 WLog_Print(context->priv->log, WLOG_ERROR, "RDPGFX channel is already opened!");
1787 return FALSE;
1788fail:
1789 (void)rdpgfx_server_close(context);
1790 return FALSE;
1791}
1792
1793BOOL rdpgfx_server_close(RdpgfxServerContext* context)
1794{
1795 WINPR_ASSERT(context);
1796
1797 RdpgfxServerPrivate* priv = context->priv;
1798 WINPR_ASSERT(priv);
1799
1800 if (priv->ownThread && priv->thread)
1801 {
1802 (void)SetEvent(priv->stopEvent);
1803
1804 if (WaitForSingleObject(priv->thread, INFINITE) == WAIT_FAILED)
1805 {
1806 WLog_Print(context->priv->log, WLOG_ERROR,
1807 "WaitForSingleObject failed with error %" PRIu32 "", GetLastError());
1808 return FALSE;
1809 }
1810
1811 (void)CloseHandle(priv->thread);
1812 (void)CloseHandle(priv->stopEvent);
1813 priv->thread = nullptr;
1814 priv->stopEvent = nullptr;
1815 }
1816
1817 zgfx_context_free(priv->zgfx);
1818 priv->zgfx = nullptr;
1819
1820 if (priv->rdpgfx_channel)
1821 {
1822 (void)WTSVirtualChannelClose(priv->rdpgfx_channel);
1823 priv->rdpgfx_channel = nullptr;
1824 }
1825
1826 priv->channelEvent = nullptr;
1827 priv->isOpened = FALSE;
1828 priv->isReady = FALSE;
1829 const RDPGFX_CAPSET empty = WINPR_C_ARRAY_INIT;
1830 priv->activeCapSet = empty;
1831 return TRUE;
1832}
1833
1834WINPR_ATTR_NODISCARD static BOOL rdpgfx_server_initialize(RdpgfxServerContext* context,
1835 BOOL externalThread)
1836{
1837 WINPR_ASSERT(context);
1838 WINPR_ASSERT(context->priv);
1839
1840 if (context->priv->isOpened)
1841 {
1842 WLog_Print(context->priv->log, WLOG_WARN,
1843 "Application error: RDPEGFX channel already initialized, "
1844 "calling in this state is not possible!");
1845 return FALSE;
1846 }
1847
1848 context->priv->ownThread = !externalThread;
1849 return TRUE;
1850}
1851
1852RdpgfxServerContext* rdpgfx_server_context_new(HANDLE vcm)
1853{
1854 RdpgfxServerContext* context = (RdpgfxServerContext*)calloc(1, sizeof(RdpgfxServerContext));
1855
1856 if (!context)
1857 return nullptr;
1858
1859 context->vcm = vcm;
1860 context->Initialize = rdpgfx_server_initialize;
1861 context->Open = rdpgfx_server_open;
1862 context->Close = rdpgfx_server_close;
1863 context->ResetGraphics = rdpgfx_send_reset_graphics_pdu;
1864 context->StartFrame = rdpgfx_send_start_frame_pdu;
1865 context->EndFrame = rdpgfx_send_end_frame_pdu;
1866 context->SurfaceCommand = rdpgfx_send_surface_command;
1867 context->SurfaceFrameCommand = rdpgfx_send_surface_frame_command;
1868 context->DeleteEncodingContext = rdpgfx_send_delete_encoding_context_pdu;
1869 context->CreateSurface = rdpgfx_send_create_surface_pdu;
1870 context->DeleteSurface = rdpgfx_send_delete_surface_pdu;
1871 context->SolidFill = rdpgfx_send_solid_fill_pdu;
1872 context->SurfaceToSurface = rdpgfx_send_surface_to_surface_pdu;
1873 context->SurfaceToCache = rdpgfx_send_surface_to_cache_pdu;
1874 context->CacheToSurface = rdpgfx_send_cache_to_surface_pdu;
1875 context->CacheImportOffer = rdpgfx_process_cache_import_offer_pdu;
1876 context->CacheImportReply = rdpgfx_send_cache_import_reply_pdu;
1877 context->EvictCacheEntry = rdpgfx_send_evict_cache_entry_pdu;
1878 context->MapSurfaceToOutput = rdpgfx_send_map_surface_to_output_pdu;
1879 context->MapSurfaceToWindow = rdpgfx_send_map_surface_to_window_pdu;
1880 context->MapSurfaceToScaledOutput = rdpgfx_send_map_surface_to_scaled_output_pdu;
1881 context->MapSurfaceToScaledWindow = rdpgfx_send_map_surface_to_scaled_window_pdu;
1882 context->CapsAdvertise = nullptr;
1883 context->CapsConfirm = rdpgfx_send_caps_confirm_pdu;
1884 context->FrameAcknowledge = nullptr;
1885 context->QoeFrameAcknowledge = nullptr;
1886 RdpgfxServerPrivate* priv = context->priv =
1887 (RdpgfxServerPrivate*)calloc(1, sizeof(RdpgfxServerPrivate));
1888
1889 if (!priv)
1890 goto fail;
1891
1892 priv->log = WLog_Get(TAG);
1893 if (!priv->log)
1894 goto fail;
1895
1896 /* Create shared input stream */
1897 priv->input_stream = Stream_New(nullptr, 4);
1898
1899 if (!priv->input_stream)
1900 {
1901 WLog_Print(context->priv->log, WLOG_ERROR, "Stream_New failed!");
1902 goto fail;
1903 }
1904
1905 priv->isOpened = FALSE;
1906 priv->isReady = FALSE;
1907 priv->ownThread = TRUE;
1908
1909 {
1910 const RDPGFX_CAPSET empty = WINPR_C_ARRAY_INIT;
1911 priv->activeCapSet = empty;
1912 }
1913
1914 return context;
1915fail:
1916 WINPR_PRAGMA_DIAG_PUSH
1917 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
1918 rdpgfx_server_context_free(context);
1919 WINPR_PRAGMA_DIAG_POP
1920 return nullptr;
1921}
1922
1923void rdpgfx_server_context_free(RdpgfxServerContext* context)
1924{
1925 if (!context)
1926 return;
1927
1928 (void)rdpgfx_server_close(context);
1929
1930 if (context->priv)
1931 Stream_Free(context->priv->input_stream, TRUE);
1932
1933 free(context->priv);
1934 free(context);
1935}
1936
1937HANDLE rdpgfx_server_get_event_handle(RdpgfxServerContext* context)
1938{
1939 if (!context)
1940 return nullptr;
1941 if (!context->priv)
1942 return nullptr;
1943 return context->priv->channelEvent;
1944}
1945
1946/*
1947 * Handle rpdgfx messages - server side
1948 *
1949 * @param context side context
1950 *
1951 * @return 0 on success
1952 * ERROR_NO_DATA if no data could be read this time
1953 * otherwise a Win32 error code
1954 */
1955UINT rdpgfx_server_handle_messages(RdpgfxServerContext* context)
1956{
1957 DWORD BytesReturned = 0;
1958 void* buffer = nullptr;
1959 UINT ret = CHANNEL_RC_OK;
1960
1961 WINPR_ASSERT(context);
1962 WINPR_ASSERT(context->priv);
1963
1964 RdpgfxServerPrivate* priv = context->priv;
1965 wStream* s = priv->input_stream;
1966
1967 /* Check whether the dynamic channel is ready */
1968 if (!priv->isReady)
1969 {
1970 if (WTSVirtualChannelQuery(priv->rdpgfx_channel, WTSVirtualChannelReady, &buffer,
1971 &BytesReturned) == FALSE)
1972 {
1973 if (GetLastError() == ERROR_NO_DATA)
1974 return ERROR_NO_DATA;
1975
1976 WLog_Print(context->priv->log, WLOG_ERROR, "WTSVirtualChannelQuery failed");
1977 return ERROR_INTERNAL_ERROR;
1978 }
1979
1980 priv->isReady = *((BOOL*)buffer);
1981 WTSFreeMemory(buffer);
1982 }
1983
1984 /* Consume channel event only after the gfx dynamic channel is ready */
1985 if (priv->isReady)
1986 {
1987 Stream_ResetPosition(s);
1988
1989 if (!WTSVirtualChannelRead(priv->rdpgfx_channel, 0, nullptr, 0, &BytesReturned))
1990 {
1991 if (GetLastError() == ERROR_NO_DATA)
1992 return ERROR_NO_DATA;
1993
1994 WLog_Print(context->priv->log, WLOG_ERROR, "WTSVirtualChannelRead failed!");
1995 return ERROR_INTERNAL_ERROR;
1996 }
1997
1998 if (BytesReturned < 1)
1999 return CHANNEL_RC_OK;
2000
2001 if (!Stream_EnsureRemainingCapacity(s, BytesReturned))
2002 {
2003 WLog_Print(context->priv->log, WLOG_ERROR, "Stream_EnsureRemainingCapacity failed!");
2004 return CHANNEL_RC_NO_MEMORY;
2005 }
2006
2007 const size_t len = Stream_Capacity(s);
2008 if (len > UINT32_MAX)
2009 return ERROR_INTERNAL_ERROR;
2010 if (WTSVirtualChannelRead(priv->rdpgfx_channel, 0, Stream_BufferAs(s, char), (UINT32)len,
2011 &BytesReturned) == FALSE)
2012 {
2013 WLog_Print(context->priv->log, WLOG_ERROR, "WTSVirtualChannelRead failed!");
2014 return ERROR_INTERNAL_ERROR;
2015 }
2016
2017 if (!Stream_SetLength(s, BytesReturned))
2018 return ERROR_INTERNAL_ERROR;
2019
2020 Stream_ResetPosition(s);
2021
2022 while (Stream_GetPosition(s) < Stream_Length(s))
2023 {
2024 if ((ret = rdpgfx_server_receive_pdu(context, s)))
2025 {
2026 WLog_Print(context->priv->log, WLOG_ERROR,
2027 "rdpgfx_server_receive_pdu "
2028 "failed with error %" PRIu32 "!",
2029 ret);
2030 return ret;
2031 }
2032 }
2033 }
2034
2035 return ret;
2036}
MONITOR_DEF
Definition settings_types.h:434
RDPGFX_AVC420_BITMAP_STREAM
Definition channels/rdpgfx.h:427
RDPGFX_AVC444_BITMAP_STREAM
Definition channels/rdpgfx.h:434
RDPGFX_CACHE_ENTRY_METADATA
Definition channels/rdpgfx.h:359
RDPGFX_CACHE_IMPORT_OFFER_PDU
Definition channels/rdpgfx.h:367
RDPGFX_CACHE_IMPORT_REPLY_PDU
Definition channels/rdpgfx.h:373
RDPGFX_CACHE_TO_SURFACE_PDU
Definition channels/rdpgfx.h:282
RDPGFX_CAPSET
Definition channels/rdpgfx.h:138
RDPGFX_CAPS_ADVERTISE_PDU
Definition channels/rdpgfx.h:379
RDPGFX_CAPS_CONFIRM_PDU
Definition channels/rdpgfx.h:385
RDPGFX_CREATE_SURFACE_PDU
Definition channels/rdpgfx.h:295
RDPGFX_DELETE_ENCODING_CONTEXT_PDU
Definition channels/rdpgfx.h:251
RDPGFX_DELETE_SURFACE_PDU
Definition channels/rdpgfx.h:303
RDPGFX_END_FRAME_PDU
Definition channels/rdpgfx.h:318
RDPGFX_EVICT_CACHE_ENTRY_PDU
Definition channels/rdpgfx.h:290
RDPGFX_FRAME_ACKNOWLEDGE_PDU
Definition channels/rdpgfx.h:326
RDPGFX_H264_METABLOCK
Definition channels/rdpgfx.h:420
RDPGFX_H264_QUANT_QUALITY
Definition channels/rdpgfx.h:410
RDPGFX_HEADER
Definition channels/rdpgfx.h:97
RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU
Definition channels/rdpgfx.h:341
RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU
Definition channels/rdpgfx.h:349
RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU
Definition channels/rdpgfx.h:398
RDPGFX_MAP_SURFACE_TO_WINDOW_PDU
Definition channels/rdpgfx.h:390
RDPGFX_POINT16
Definition channels/rdpgfx.h:44
RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU
Definition channels/rdpgfx.h:441
RDPGFX_RESET_GRAPHICS_PDU
Definition channels/rdpgfx.h:333
RDPGFX_SOLID_FILL_PDU
Definition channels/rdpgfx.h:257
RDPGFX_START_FRAME_PDU
Definition channels/rdpgfx.h:310
RDPGFX_SURFACE_COMMAND
Definition channels/rdpgfx.h:234
RDPGFX_SURFACE_TO_CACHE_PDU
Definition channels/rdpgfx.h:274
RDPGFX_SURFACE_TO_SURFACE_PDU
Definition channels/rdpgfx.h:265
RECTANGLE_16
Definition types.h:109