FreeRDP
Loading...
Searching...
No Matches
gdi/gfx.c
1
22#include <freerdp/config.h>
23
24#include "../core/update.h"
25
26#include <winpr/assert.h>
27#include <winpr/cast.h>
28
29#include <freerdp/api.h>
30#include <freerdp/log.h>
31#include <freerdp/gdi/gfx.h>
32#include <freerdp/gdi/region.h>
33#include <freerdp/utils/gfx.h>
34#include <math.h>
35
36#define TAG FREERDP_TAG("gdi")
37
38static BOOL is_rect_valid(const RECTANGLE_16* rect, size_t width, size_t height)
39{
40 if (!rect)
41 return FALSE;
42 if ((rect->left > rect->right) || (rect->right > width))
43 return FALSE;
44 if ((rect->top > rect->bottom) || (rect->bottom > height))
45 return FALSE;
46 return TRUE;
47}
48
49static BOOL is_within_surface(const gdiGfxSurface* surface, const RDPGFX_SURFACE_COMMAND* cmd)
50{
51 RECTANGLE_16 rect;
52 if (!surface || !cmd)
53 return FALSE;
54 rect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
55 rect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
56 rect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
57 rect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
58 if (!is_rect_valid(&rect, surface->width, surface->height))
59 {
60 WLog_ERR(TAG,
61 "Command rect %" PRIu32 "x%" PRIu32 "-%" PRIu32 "x%" PRIu32
62 " not within bounds of %" PRIu32 "x%" PRIu32,
63 rect.left, rect.top, cmd->width, cmd->height, surface->width, surface->height);
64 return FALSE;
65 }
66
67 return TRUE;
68}
69
70static DWORD gfx_align_scanline(DWORD widthInBytes, DWORD alignment)
71{
72 const UINT32 align = alignment;
73 const UINT32 pad = align - (widthInBytes % alignment);
74 UINT32 scanline = widthInBytes;
75
76 if (align != pad)
77 scanline += pad;
78
79 return scanline;
80}
81
87static UINT gdi_ResetGraphics(RdpgfxClientContext* context,
88 const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
89{
90 UINT rc = ERROR_INTERNAL_ERROR;
91 UINT16 count = 0;
92 UINT32 DesktopWidth = 0;
93 UINT32 DesktopHeight = 0;
94 UINT16* pSurfaceIds = NULL;
95 rdpGdi* gdi = NULL;
96 rdpUpdate* update = NULL;
97 rdpSettings* settings = NULL;
98
99 WINPR_ASSERT(context);
100 WINPR_ASSERT(resetGraphics);
101
102 gdi = (rdpGdi*)context->custom;
103 WINPR_ASSERT(gdi);
104
105 update = gdi->context->update;
106 WINPR_ASSERT(update);
107
108 settings = gdi->context->settings;
109 WINPR_ASSERT(settings);
110 EnterCriticalSection(&context->mux);
111 DesktopWidth = resetGraphics->width;
112 DesktopHeight = resetGraphics->height;
113
114 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopWidth, DesktopWidth))
115 goto fail;
116 if (!freerdp_settings_set_uint32(settings, FreeRDP_DesktopHeight, DesktopHeight))
117 goto fail;
118
119 if (update)
120 {
121 WINPR_ASSERT(update->DesktopResize);
122 update->DesktopResize(gdi->context);
123 }
124
125 WINPR_ASSERT(context->GetSurfaceIds);
126 context->GetSurfaceIds(context, &pSurfaceIds, &count);
127
128 for (UINT32 index = 0; index < count; index++)
129 {
130 WINPR_ASSERT(context->GetSurfaceData);
131 gdiGfxSurface* surface =
132 (gdiGfxSurface*)context->GetSurfaceData(context, pSurfaceIds[index]);
133
134 if (!surface)
135 continue;
136
137 memset(surface->data, 0xFF, (size_t)surface->scanline * surface->height);
138 region16_clear(&surface->invalidRegion);
139 }
140
141 free(pSurfaceIds);
142
143 if (!freerdp_settings_get_bool(gdi->context->settings, FreeRDP_DeactivateClientDecoding))
144 {
145 const UINT32 width = (UINT32)MAX(0, gdi->width);
146 const UINT32 height = (UINT32)MAX(0, gdi->height);
147
148 if (!freerdp_client_codecs_reset(
149 context->codecs, freerdp_settings_get_codecs_flags(settings), width, height))
150 {
151 goto fail;
152 }
153 if (!freerdp_client_codecs_reset(
154 gdi->context->codecs, freerdp_settings_get_codecs_flags(settings), width, height))
155 {
156 goto fail;
157 }
158 }
159
160 rc = CHANNEL_RC_OK;
161fail:
162 LeaveCriticalSection(&context->mux);
163 return rc;
164}
165
166static UINT gdi_OutputUpdate(rdpGdi* gdi, gdiGfxSurface* surface)
167{
168 UINT rc = ERROR_INTERNAL_ERROR;
169 UINT32 surfaceX = 0;
170 UINT32 surfaceY = 0;
171 RECTANGLE_16 surfaceRect;
172 const RECTANGLE_16* rects = NULL;
173 UINT32 nbRects = 0;
174 rdpUpdate* update = NULL;
175
176 WINPR_ASSERT(gdi);
177 WINPR_ASSERT(gdi->context);
178 WINPR_ASSERT(surface);
179
180 update = gdi->context->update;
181 WINPR_ASSERT(update);
182
183 if (gdi->suppressOutput)
184 return CHANNEL_RC_OK;
185
186 surfaceX = surface->outputOriginX;
187 surfaceY = surface->outputOriginY;
188 surfaceRect.left = 0;
189 surfaceRect.top = 0;
190 surfaceRect.right = (UINT16)MIN(UINT16_MAX, surface->mappedWidth);
191 surfaceRect.bottom = (UINT16)MIN(UINT16_MAX, surface->mappedHeight);
192 region16_intersect_rect(&(surface->invalidRegion), &(surface->invalidRegion), &surfaceRect);
193 const double sx = surface->outputTargetWidth / (double)surface->mappedWidth;
194 const double sy = surface->outputTargetHeight / (double)surface->mappedHeight;
195
196 if (!(rects = region16_rects(&surface->invalidRegion, &nbRects)) || !nbRects)
197 return CHANNEL_RC_OK;
198
199 if (!update_begin_paint(update))
200 goto fail;
201
202 for (UINT32 i = 0; i < nbRects; i++)
203 {
204 const UINT32 nXSrc = rects[i].left;
205 const UINT32 nYSrc = rects[i].top;
206 const UINT32 nXDst = (UINT32)MIN(surfaceX + nXSrc * sx, gdi->width - 1);
207 const UINT32 nYDst = (UINT32)MIN(surfaceY + nYSrc * sy, gdi->height - 1);
208 const UINT32 swidth = rects[i].right - rects[i].left;
209 const UINT32 sheight = rects[i].bottom - rects[i].top;
210 const UINT32 dwidth = MIN((UINT32)(swidth * sx), (UINT32)gdi->width - nXDst);
211 const UINT32 dheight = MIN((UINT32)(sheight * sy), (UINT32)gdi->height - nYDst);
212
213 if (!freerdp_image_scale(gdi->primary_buffer, gdi->dstFormat, gdi->stride, nXDst, nYDst,
214 dwidth, dheight, surface->data, surface->format, surface->scanline,
215 nXSrc, nYSrc, swidth, sheight))
216 {
217 rc = CHANNEL_RC_NULL_DATA;
218 goto fail;
219 }
220
221 gdi_InvalidateRegion(gdi->primary->hdc, (INT32)nXDst, (INT32)nYDst, (INT32)dwidth,
222 (INT32)dheight);
223 }
224
225 rc = CHANNEL_RC_OK;
226fail:
227
228 if (!update_end_paint(update))
229 rc = ERROR_INTERNAL_ERROR;
230
231 region16_clear(&(surface->invalidRegion));
232 return rc;
233}
234
235static UINT gdi_WindowUpdate(RdpgfxClientContext* context, gdiGfxSurface* surface)
236{
237 WINPR_ASSERT(context);
238 WINPR_ASSERT(surface);
239 return IFCALLRESULT(CHANNEL_RC_OK, context->UpdateWindowFromSurface, context, surface);
240}
241
242static UINT gdi_UpdateSurfaces(RdpgfxClientContext* context)
243{
244 UINT16 count = 0;
245 UINT status = ERROR_INTERNAL_ERROR;
246 UINT16* pSurfaceIds = NULL;
247 rdpGdi* gdi = NULL;
248
249 WINPR_ASSERT(context);
250
251 gdi = (rdpGdi*)context->custom;
252 WINPR_ASSERT(gdi);
253
254 EnterCriticalSection(&context->mux);
255
256 WINPR_ASSERT(context->GetSurfaceIds);
257 context->GetSurfaceIds(context, &pSurfaceIds, &count);
258 status = CHANNEL_RC_OK;
259
260 for (UINT32 index = 0; index < count; index++)
261 {
262 WINPR_ASSERT(context->GetSurfaceData);
263 gdiGfxSurface* surface =
264 (gdiGfxSurface*)context->GetSurfaceData(context, pSurfaceIds[index]);
265
266 if (!surface)
267 continue;
268
269 /* Already handled in UpdateSurfaceArea callbacks */
270 if (context->UpdateSurfaceArea)
271 {
272 if (surface->handleInUpdateSurfaceArea)
273 continue;
274 }
275
276 if (surface->outputMapped)
277 status = gdi_OutputUpdate(gdi, surface);
278 else if (surface->windowMapped)
279 status = gdi_WindowUpdate(context, surface);
280
281 if (status != CHANNEL_RC_OK)
282 break;
283 }
284
285 free(pSurfaceIds);
286 LeaveCriticalSection(&context->mux);
287 return status;
288}
289
295static UINT gdi_StartFrame(RdpgfxClientContext* context, const RDPGFX_START_FRAME_PDU* startFrame)
296{
297 rdpGdi* gdi = NULL;
298
299 WINPR_ASSERT(context);
300 WINPR_ASSERT(startFrame);
301
302 gdi = (rdpGdi*)context->custom;
303 WINPR_ASSERT(gdi);
304 gdi->inGfxFrame = TRUE;
305 gdi->frameId = startFrame->frameId;
306 return CHANNEL_RC_OK;
307}
308
309static UINT gdi_call_update_surfaces(RdpgfxClientContext* context)
310{
311 WINPR_ASSERT(context);
312 return IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaces, context);
313}
314
320static UINT gdi_EndFrame(RdpgfxClientContext* context,
321 WINPR_ATTR_UNUSED const RDPGFX_END_FRAME_PDU* endFrame)
322{
323 WINPR_ASSERT(context);
324 WINPR_ASSERT(endFrame);
325
326 rdpGdi* gdi = (rdpGdi*)context->custom;
327 WINPR_ASSERT(gdi);
328 const UINT status = gdi_call_update_surfaces(context);
329 gdi->inGfxFrame = FALSE;
330 return status;
331}
332
333static UINT gdi_interFrameUpdate(rdpGdi* gdi, RdpgfxClientContext* context)
334{
335 WINPR_ASSERT(gdi);
336 UINT status = CHANNEL_RC_OK;
337 if (!gdi->inGfxFrame)
338 status = gdi_call_update_surfaces(context);
339 return status;
340}
341
347static UINT gdi_SurfaceCommand_Uncompressed(rdpGdi* gdi, RdpgfxClientContext* context,
348 const RDPGFX_SURFACE_COMMAND* cmd)
349{
350 UINT status = CHANNEL_RC_OK;
351 gdiGfxSurface* surface = NULL;
352 RECTANGLE_16 invalidRect;
353 DWORD bpp = 0;
354 size_t size = 0;
355 WINPR_ASSERT(gdi);
356 WINPR_ASSERT(context);
357 WINPR_ASSERT(cmd);
358
359 WINPR_ASSERT(context->GetSurfaceData);
360 surface =
361 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
362
363 if (!surface)
364 {
365 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
366 return ERROR_NOT_FOUND;
367 }
368
369 if (!is_within_surface(surface, cmd))
370 return ERROR_INVALID_DATA;
371
372 bpp = FreeRDPGetBytesPerPixel(cmd->format);
373 size = 1ull * bpp * cmd->width * cmd->height;
374 if (cmd->length < size)
375 {
376 WLog_ERR(TAG, "Not enough data, got %" PRIu32 ", expected %" PRIuz, cmd->length, size);
377 return ERROR_INVALID_DATA;
378 }
379
380 if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline, cmd->left,
381 cmd->top, cmd->width, cmd->height, cmd->data, cmd->format, 0,
382 0, 0, NULL, FREERDP_FLIP_NONE))
383 return ERROR_INTERNAL_ERROR;
384
385 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
386 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
387 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
388 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
389 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
390 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
391 &invalidRect);
392
393 if (status != CHANNEL_RC_OK)
394 goto fail;
395
396 status = gdi_interFrameUpdate(gdi, context);
397
398fail:
399 return status;
400}
401
407static UINT gdi_SurfaceCommand_RemoteFX(rdpGdi* gdi, RdpgfxClientContext* context,
408 const RDPGFX_SURFACE_COMMAND* cmd)
409{
410 UINT status = ERROR_INTERNAL_ERROR;
411 gdiGfxSurface* surface = NULL;
412 REGION16 invalidRegion;
413 const RECTANGLE_16* rects = NULL;
414 UINT32 nrRects = 0;
415 WINPR_ASSERT(gdi);
416 WINPR_ASSERT(context);
417 WINPR_ASSERT(cmd);
418
419 WINPR_ASSERT(context->GetSurfaceData);
420 surface =
421 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
422
423 if (!surface)
424 {
425 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
426 return ERROR_NOT_FOUND;
427 }
428
429 WINPR_ASSERT(surface->codecs);
430 rfx_context_set_pixel_format(surface->codecs->rfx, cmd->format);
431 region16_init(&invalidRegion);
432
433 if (!rfx_process_message(surface->codecs->rfx, cmd->data, cmd->length, cmd->left, cmd->top,
434 surface->data, surface->format, surface->scanline, surface->height,
435 &invalidRegion))
436 {
437 WLog_ERR(TAG, "Failed to process RemoteFX message");
438 goto fail;
439 }
440
441 rects = region16_rects(&invalidRegion, &nrRects);
442 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
443 nrRects, rects);
444
445 if (status != CHANNEL_RC_OK)
446 goto fail;
447
448 for (UINT32 x = 0; x < nrRects; x++)
449 region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rects[x]);
450
451 status = gdi_interFrameUpdate(gdi, context);
452
453fail:
454 region16_uninit(&invalidRegion);
455 return status;
456}
457
463static UINT gdi_SurfaceCommand_ClearCodec(rdpGdi* gdi, RdpgfxClientContext* context,
464 const RDPGFX_SURFACE_COMMAND* cmd)
465{
466 INT32 rc = 0;
467 UINT status = CHANNEL_RC_OK;
468 gdiGfxSurface* surface = NULL;
469 RECTANGLE_16 invalidRect;
470 WINPR_ASSERT(gdi);
471 WINPR_ASSERT(context);
472 WINPR_ASSERT(cmd);
473
474 WINPR_ASSERT(context->GetSurfaceData);
475 surface =
476 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
477
478 if (!surface)
479 {
480 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
481 return ERROR_NOT_FOUND;
482 }
483
484 WINPR_ASSERT(surface->codecs);
485 rc = clear_decompress(surface->codecs->clear, cmd->data, cmd->length, cmd->width, cmd->height,
486 surface->data, surface->format, surface->scanline, cmd->left, cmd->top,
487 surface->width, surface->height, &gdi->palette);
488
489 if (rc < 0)
490 {
491 WLog_ERR(TAG, "clear_decompress failure: %" PRId32 "", rc);
492 return ERROR_INTERNAL_ERROR;
493 }
494
495 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
496 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
497 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
498 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
499 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
500 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
501 &invalidRect);
502
503 if (status != CHANNEL_RC_OK)
504 goto fail;
505
506 status = gdi_interFrameUpdate(gdi, context);
507
508fail:
509 return status;
510}
511
517static UINT gdi_SurfaceCommand_Planar(rdpGdi* gdi, RdpgfxClientContext* context,
518 const RDPGFX_SURFACE_COMMAND* cmd)
519{
520 UINT status = CHANNEL_RC_OK;
521 BYTE* DstData = NULL;
522 gdiGfxSurface* surface = NULL;
523 RECTANGLE_16 invalidRect;
524 WINPR_ASSERT(gdi);
525 WINPR_ASSERT(context);
526 WINPR_ASSERT(cmd);
527
528 WINPR_ASSERT(context->GetSurfaceData);
529 surface =
530 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
531
532 if (!surface)
533 {
534 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
535 return ERROR_NOT_FOUND;
536 }
537
538 DstData = surface->data;
539
540 if (!is_within_surface(surface, cmd))
541 return ERROR_INVALID_DATA;
542
543 if (!freerdp_bitmap_decompress_planar(surface->codecs->planar, cmd->data, cmd->length,
544 cmd->width, cmd->height, DstData, surface->format,
545 surface->scanline, cmd->left, cmd->top, cmd->width,
546 cmd->height, FALSE))
547 return ERROR_INTERNAL_ERROR;
548
549 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
550 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
551 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
552 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
553 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
554 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
555 &invalidRect);
556
557 if (status != CHANNEL_RC_OK)
558 goto fail;
559
560 status = gdi_interFrameUpdate(gdi, context);
561
562fail:
563 return status;
564}
565
571static UINT gdi_SurfaceCommand_AVC420(rdpGdi* gdi, RdpgfxClientContext* context,
572 const RDPGFX_SURFACE_COMMAND* cmd)
573{
574#ifdef WITH_GFX_H264
575 INT32 rc = 0;
576 UINT status = CHANNEL_RC_OK;
577 gdiGfxSurface* surface = NULL;
578 RDPGFX_H264_METABLOCK* meta = NULL;
579 RDPGFX_AVC420_BITMAP_STREAM* bs = NULL;
580 WINPR_ASSERT(gdi);
581 WINPR_ASSERT(context);
582 WINPR_ASSERT(cmd);
583
584 WINPR_ASSERT(context->GetSurfaceData);
585 surface =
586 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
587
588 if (!surface)
589 {
590 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
591 return ERROR_NOT_FOUND;
592 }
593
594 if (!surface->h264)
595 {
596 surface->h264 = h264_context_new(FALSE);
597
598 if (!surface->h264)
599 {
600 WLog_ERR(TAG, "unable to create h264 context");
601 return ERROR_NOT_ENOUGH_MEMORY;
602 }
603
604 if (!h264_context_reset(surface->h264, surface->width, surface->height))
605 return ERROR_INTERNAL_ERROR;
606 }
607
608 if (!surface->h264)
609 return ERROR_NOT_SUPPORTED;
610
611 bs = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
612
613 if (!bs)
614 return ERROR_INTERNAL_ERROR;
615
616 meta = &(bs->meta);
617 rc = avc420_decompress(surface->h264, bs->data, bs->length, surface->data, surface->format,
618 surface->scanline, surface->width, surface->height, meta->regionRects,
619 meta->numRegionRects);
620
621 if (rc < 0)
622 {
623 WLog_WARN(TAG, "avc420_decompress failure: %" PRId32 ", ignoring update.", rc);
624 return CHANNEL_RC_OK;
625 }
626
627 for (UINT32 i = 0; i < meta->numRegionRects; i++)
628 {
629 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
630 &(meta->regionRects[i]));
631 }
632
633 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
634 meta->numRegionRects, meta->regionRects);
635
636 if (status != CHANNEL_RC_OK)
637 goto fail;
638
639 status = gdi_interFrameUpdate(gdi, context);
640
641fail:
642 return status;
643#else
644 return ERROR_NOT_SUPPORTED;
645#endif
646}
647
653static UINT gdi_SurfaceCommand_AVC444(rdpGdi* gdi, RdpgfxClientContext* context,
654 const RDPGFX_SURFACE_COMMAND* cmd)
655{
656#ifdef WITH_GFX_H264
657 INT32 rc = 0;
658 UINT status = CHANNEL_RC_OK;
659 gdiGfxSurface* surface = NULL;
660 RDPGFX_AVC444_BITMAP_STREAM* bs = NULL;
661 RDPGFX_AVC420_BITMAP_STREAM* avc1 = NULL;
662 RDPGFX_H264_METABLOCK* meta1 = NULL;
663 RDPGFX_AVC420_BITMAP_STREAM* avc2 = NULL;
664 RDPGFX_H264_METABLOCK* meta2 = NULL;
665 WINPR_ASSERT(gdi);
666 WINPR_ASSERT(context);
667 WINPR_ASSERT(cmd);
668
669 WINPR_ASSERT(context->GetSurfaceData);
670 surface =
671 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
672
673 if (!surface)
674 {
675 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
676 return ERROR_NOT_FOUND;
677 }
678
679 if (!surface->h264)
680 {
681 surface->h264 = h264_context_new(FALSE);
682
683 if (!surface->h264)
684 {
685 WLog_ERR(TAG, "unable to create h264 context");
686 return ERROR_NOT_ENOUGH_MEMORY;
687 }
688
689 if (!h264_context_reset(surface->h264, surface->width, surface->height))
690 return ERROR_INTERNAL_ERROR;
691 }
692
693 if (!surface->h264)
694 return ERROR_NOT_SUPPORTED;
695
696 bs = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
697
698 if (!bs)
699 return ERROR_INTERNAL_ERROR;
700
701 avc1 = &bs->bitstream[0];
702 avc2 = &bs->bitstream[1];
703 meta1 = &avc1->meta;
704 meta2 = &avc2->meta;
705 rc = avc444_decompress(surface->h264, bs->LC, meta1->regionRects, meta1->numRegionRects,
706 avc1->data, avc1->length, meta2->regionRects, meta2->numRegionRects,
707 avc2->data, avc2->length, surface->data, surface->format,
708 surface->scanline, surface->width, surface->height, cmd->codecId);
709
710 if (rc < 0)
711 {
712 WLog_WARN(TAG, "avc444_decompress failure: %" PRIu32 ", ignoring update.", status);
713 return CHANNEL_RC_OK;
714 }
715
716 for (UINT32 i = 0; i < meta1->numRegionRects; i++)
717 {
718 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
719 &(meta1->regionRects[i]));
720 }
721
722 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
723 meta1->numRegionRects, meta1->regionRects);
724
725 if (status != CHANNEL_RC_OK)
726 goto fail;
727
728 for (UINT32 i = 0; i < meta2->numRegionRects; i++)
729 {
730 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
731 &(meta2->regionRects[i]));
732 }
733
734 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
735 meta2->numRegionRects, meta2->regionRects);
736
737 if (status != CHANNEL_RC_OK)
738 goto fail;
739
740 status = gdi_interFrameUpdate(gdi, context);
741
742fail:
743 return status;
744#else
745 return ERROR_NOT_SUPPORTED;
746#endif
747}
748
749static BOOL gdi_apply_alpha(BYTE* data, UINT32 format, UINT32 stride, RECTANGLE_16* rect,
750 UINT32 startOffsetX, UINT32 count, BYTE a)
751{
752 UINT32 written = 0;
753 BOOL first = TRUE;
754 const UINT32 bpp = FreeRDPGetBytesPerPixel(format);
755 WINPR_ASSERT(rect);
756
757 for (size_t y = rect->top; y < rect->bottom; y++)
758 {
759 BYTE* line = &data[y * stride];
760
761 for (size_t x = first ? rect->left + startOffsetX : rect->left; x < rect->right; x++)
762 {
763 BYTE r = 0;
764 BYTE g = 0;
765 BYTE b = 0;
766
767 if (written == count)
768 return TRUE;
769
770 BYTE* src = &line[x * bpp];
771 UINT32 color = FreeRDPReadColor(src, format);
772 FreeRDPSplitColor(color, format, &r, &g, &b, NULL, NULL);
773 color = FreeRDPGetColor(format, r, g, b, a);
774 FreeRDPWriteColor(src, format, color);
775 written++;
776 }
777
778 first = FALSE;
779 }
780
781 return TRUE;
782}
788static UINT gdi_SurfaceCommand_Alpha(rdpGdi* gdi, RdpgfxClientContext* context,
789 const RDPGFX_SURFACE_COMMAND* cmd)
790{
791 UINT status = CHANNEL_RC_OK;
792 UINT16 alphaSig = 0;
793 UINT16 compressed = 0;
794 gdiGfxSurface* surface = NULL;
795 RECTANGLE_16 invalidRect;
796 wStream buffer;
797 wStream* s = NULL;
798 WINPR_ASSERT(gdi);
799 WINPR_ASSERT(context);
800 WINPR_ASSERT(cmd);
801
802 s = Stream_StaticConstInit(&buffer, cmd->data, cmd->length);
803
804 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
805 return ERROR_INVALID_DATA;
806
807 WINPR_ASSERT(context->GetSurfaceData);
808 surface =
809 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
810
811 if (!surface)
812 {
813 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
814 return ERROR_NOT_FOUND;
815 }
816
817 if (!is_within_surface(surface, cmd))
818 return ERROR_INVALID_DATA;
819
820 Stream_Read_UINT16(s, alphaSig);
821 Stream_Read_UINT16(s, compressed);
822
823 if (alphaSig != 0x414C)
824 return ERROR_INVALID_DATA;
825
826 if (compressed == 0)
827 {
828 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cmd->height, cmd->width))
829 return ERROR_INVALID_DATA;
830
831 for (size_t y = cmd->top; y < cmd->top + cmd->height; y++)
832 {
833 BYTE* line = &surface->data[y * surface->scanline];
834
835 for (size_t x = cmd->left; x < cmd->left + cmd->width; x++)
836 {
837 UINT32 color = 0;
838 BYTE r = 0;
839 BYTE g = 0;
840 BYTE b = 0;
841 BYTE a = 0;
842 BYTE* src = &line[x * FreeRDPGetBytesPerPixel(surface->format)];
843 Stream_Read_UINT8(s, a);
844 color = FreeRDPReadColor(src, surface->format);
845 FreeRDPSplitColor(color, surface->format, &r, &g, &b, NULL, NULL);
846 color = FreeRDPGetColor(surface->format, r, g, b, a);
847 FreeRDPWriteColor(src, surface->format, color);
848 }
849 }
850 }
851 else
852 {
853 UINT32 startOffsetX = 0;
854 RECTANGLE_16 rect = { 0 };
855 rect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
856 rect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
857 rect.right = (UINT16)MIN(UINT16_MAX, cmd->left + cmd->width);
858 rect.bottom = (UINT16)MIN(UINT16_MAX, cmd->top + cmd->height);
859
860 while (rect.top < rect.bottom)
861 {
862 UINT32 count = 0;
863 BYTE a = 0;
864
865 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
866 return ERROR_INVALID_DATA;
867
868 Stream_Read_UINT8(s, a);
869 Stream_Read_UINT8(s, count);
870
871 if (count >= 0xFF)
872 {
873 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
874 return ERROR_INVALID_DATA;
875
876 Stream_Read_UINT16(s, count);
877
878 if (count >= 0xFFFF)
879 {
880 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
881 return ERROR_INVALID_DATA;
882
883 Stream_Read_UINT32(s, count);
884 }
885 }
886
887 if (!gdi_apply_alpha(surface->data, surface->format, surface->scanline, &rect,
888 startOffsetX, count, a))
889 return ERROR_INTERNAL_ERROR;
890
891 startOffsetX += count;
892
893 while (startOffsetX >= cmd->width)
894 {
895 startOffsetX -= cmd->width;
896 rect.top++;
897 }
898 }
899 }
900
901 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
902 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
903 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
904 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
905 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
906 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
907 &invalidRect);
908
909 if (status != CHANNEL_RC_OK)
910 goto fail;
911
912 status = gdi_interFrameUpdate(gdi, context);
913
914fail:
915 return status;
916}
917
918#if defined(WITH_GFX_FRAME_DUMP)
919static void dump_cmd(const RDPGFX_SURFACE_COMMAND* cmd, UINT32 frameId)
920{
921 static UINT64 xxx = 0;
922 const char* path = "/tmp/dump/";
923 WINPR_ASSERT(cmd);
924 char fname[1024] = { 0 };
925
926 snprintf(fname, sizeof(fname), "%s/%08" PRIx64 ".raw", path, xxx++);
927 FILE* fp = fopen(fname, "w");
928 if (!fp)
929 return;
930 (void)fprintf(fp, "frameid: %" PRIu32 "\n", frameId);
931 (void)fprintf(fp, "surfaceId: %" PRIu32 "\n", cmd->surfaceId);
932 (void)fprintf(fp, "codecId: %" PRIu32 "\n", cmd->codecId);
933 (void)fprintf(fp, "contextId: %" PRIu32 "\n", cmd->contextId);
934 (void)fprintf(fp, "format: %" PRIu32 "\n", cmd->format);
935 (void)fprintf(fp, "left: %" PRIu32 "\n", cmd->left);
936 (void)fprintf(fp, "top: %" PRIu32 "\n", cmd->top);
937 (void)fprintf(fp, "right: %" PRIu32 "\n", cmd->right);
938 (void)fprintf(fp, "bottom: %" PRIu32 "\n", cmd->bottom);
939 (void)fprintf(fp, "width: %" PRIu32 "\n", cmd->width);
940 (void)fprintf(fp, "height: %" PRIu32 "\n", cmd->height);
941 (void)fprintf(fp, "length: %" PRIu32 "\n", cmd->length);
942
943 char* bdata = crypto_base64_encode_ex(cmd->data, cmd->length, FALSE);
944 (void)fprintf(fp, "data: %s\n", bdata);
945 free(bdata);
946 fclose(fp);
947}
948#endif
949
955static UINT gdi_SurfaceCommand_Progressive(rdpGdi* gdi, RdpgfxClientContext* context,
956 const RDPGFX_SURFACE_COMMAND* cmd)
957{
958 INT32 rc = 0;
959 UINT status = CHANNEL_RC_OK;
960 gdiGfxSurface* surface = NULL;
961 REGION16 invalidRegion;
962 const RECTANGLE_16* rects = NULL;
963 UINT32 nrRects = 0;
969 WINPR_ASSERT(gdi);
970 WINPR_ASSERT(context);
971 WINPR_ASSERT(cmd);
972 const UINT16 surfaceId = (UINT16)MIN(UINT16_MAX, cmd->surfaceId);
973
974 WINPR_ASSERT(context->GetSurfaceData);
975 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceId);
976
977 if (!surface)
978 {
979 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
980 return ERROR_NOT_FOUND;
981 }
982
983 if (!is_within_surface(surface, cmd))
984 return ERROR_INVALID_DATA;
985
986 WINPR_ASSERT(surface->codecs);
987 rc = progressive_create_surface_context(surface->codecs->progressive, surfaceId, surface->width,
988 surface->height);
989
990 if (rc < 0)
991 {
992 WLog_ERR(TAG, "progressive_create_surface_context failure: %" PRId32 "", rc);
993 return ERROR_INTERNAL_ERROR;
994 }
995
996 region16_init(&invalidRegion);
997
998 rc = progressive_decompress(surface->codecs->progressive, cmd->data, cmd->length, surface->data,
999 surface->format, surface->scanline, cmd->left, cmd->top,
1000 &invalidRegion, surfaceId, gdi->frameId);
1001
1002 if (rc < 0)
1003 {
1004 WLog_ERR(TAG, "progressive_decompress failure: %" PRId32 "", rc);
1005 region16_uninit(&invalidRegion);
1006 return ERROR_INTERNAL_ERROR;
1007 }
1008
1009 rects = region16_rects(&invalidRegion, &nrRects);
1010 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
1011 nrRects, rects);
1012
1013 if (status != CHANNEL_RC_OK)
1014 goto fail;
1015
1016 for (UINT32 x = 0; x < nrRects; x++)
1017 region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rects[x]);
1018
1019 region16_uninit(&invalidRegion);
1020
1021 status = gdi_interFrameUpdate(gdi, context);
1022
1023fail:
1024 return status;
1025}
1026
1032static UINT gdi_SurfaceCommand(RdpgfxClientContext* context, const RDPGFX_SURFACE_COMMAND* cmd)
1033{
1034 UINT status = CHANNEL_RC_OK;
1035 rdpGdi* gdi = NULL;
1036
1037 if (!context || !cmd)
1038 return ERROR_INVALID_PARAMETER;
1039
1040 gdi = (rdpGdi*)context->custom;
1041
1042 EnterCriticalSection(&context->mux);
1043 const UINT16 codecId = WINPR_ASSERTING_INT_CAST(UINT16, cmd->codecId);
1044 WLog_Print(gdi->log, WLOG_TRACE,
1045 "surfaceId=%" PRIu32 ", codec=%s [%" PRIu32 "], contextId=%" PRIu32 ", format=%s, "
1046 "left=%" PRIu32 ", top=%" PRIu32 ", right=%" PRIu32 ", bottom=%" PRIu32
1047 ", width=%" PRIu32 ", height=%" PRIu32 " "
1048 "length=%" PRIu32 ", data=%p, extra=%p",
1049 cmd->surfaceId, rdpgfx_get_codec_id_string(codecId), cmd->codecId, cmd->contextId,
1050 FreeRDPGetColorFormatName(cmd->format), cmd->left, cmd->top, cmd->right, cmd->bottom,
1051 cmd->width, cmd->height, cmd->length, (void*)cmd->data, (void*)cmd->extra);
1052#if defined(WITH_GFX_FRAME_DUMP)
1053 dump_cmd(cmd, gdi->frameId);
1054#endif
1055
1056 switch (codecId)
1057 {
1058 case RDPGFX_CODECID_UNCOMPRESSED:
1059 status = gdi_SurfaceCommand_Uncompressed(gdi, context, cmd);
1060 break;
1061
1062 case RDPGFX_CODECID_CAVIDEO:
1063 status = gdi_SurfaceCommand_RemoteFX(gdi, context, cmd);
1064 break;
1065
1066 case RDPGFX_CODECID_CLEARCODEC:
1067 status = gdi_SurfaceCommand_ClearCodec(gdi, context, cmd);
1068 break;
1069
1070 case RDPGFX_CODECID_PLANAR:
1071 status = gdi_SurfaceCommand_Planar(gdi, context, cmd);
1072 break;
1073
1074 case RDPGFX_CODECID_AVC420:
1075 status = gdi_SurfaceCommand_AVC420(gdi, context, cmd);
1076 break;
1077
1078 case RDPGFX_CODECID_AVC444v2:
1079 case RDPGFX_CODECID_AVC444:
1080 status = gdi_SurfaceCommand_AVC444(gdi, context, cmd);
1081 break;
1082
1083 case RDPGFX_CODECID_ALPHA:
1084 status = gdi_SurfaceCommand_Alpha(gdi, context, cmd);
1085 break;
1086
1087 case RDPGFX_CODECID_CAPROGRESSIVE:
1088 status = gdi_SurfaceCommand_Progressive(gdi, context, cmd);
1089 break;
1090
1091 case RDPGFX_CODECID_CAPROGRESSIVE_V2:
1092 WLog_WARN(TAG, "SurfaceCommand %s [0x%08" PRIX16 "] not implemented",
1093 rdpgfx_get_codec_id_string(codecId), codecId);
1094 break;
1095
1096 default:
1097 WLog_WARN(TAG, "Invalid SurfaceCommand %s [0x%08" PRIX16 "]",
1098 rdpgfx_get_codec_id_string(codecId), codecId);
1099 break;
1100 }
1101
1102 LeaveCriticalSection(&context->mux);
1103 return status;
1104}
1105
1111static UINT
1112gdi_DeleteEncodingContext(RdpgfxClientContext* context,
1113 const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
1114{
1115 WINPR_ASSERT(context);
1116 WINPR_ASSERT(deleteEncodingContext);
1117 WINPR_UNUSED(context);
1118 WINPR_UNUSED(deleteEncodingContext);
1119 return CHANNEL_RC_OK;
1120}
1121
1127static UINT gdi_CreateSurface(RdpgfxClientContext* context,
1128 const RDPGFX_CREATE_SURFACE_PDU* createSurface)
1129{
1130 UINT rc = ERROR_INTERNAL_ERROR;
1131 gdiGfxSurface* surface = NULL;
1132 rdpGdi* gdi = NULL;
1133 WINPR_ASSERT(context);
1134 WINPR_ASSERT(createSurface);
1135 gdi = (rdpGdi*)context->custom;
1136 WINPR_ASSERT(gdi);
1137 WINPR_ASSERT(gdi->context);
1138 EnterCriticalSection(&context->mux);
1139 surface = (gdiGfxSurface*)calloc(1, sizeof(gdiGfxSurface));
1140
1141 if (!surface)
1142 goto fail;
1143
1144 if (!freerdp_settings_get_bool(gdi->context->settings, FreeRDP_DeactivateClientDecoding))
1145 {
1146 WINPR_ASSERT(context->codecs);
1147 surface->codecs = context->codecs;
1148
1149 if (!surface->codecs)
1150 {
1151 free(surface);
1152 goto fail;
1153 }
1154 }
1155
1156 surface->surfaceId = createSurface->surfaceId;
1157 surface->width = gfx_align_scanline(createSurface->width, 16);
1158 surface->height = gfx_align_scanline(createSurface->height, 16);
1159 surface->mappedWidth = createSurface->width;
1160 surface->mappedHeight = createSurface->height;
1161 surface->outputTargetWidth = createSurface->width;
1162 surface->outputTargetHeight = createSurface->height;
1163
1164 switch (createSurface->pixelFormat)
1165 {
1166 case GFX_PIXEL_FORMAT_ARGB_8888:
1167 surface->format = PIXEL_FORMAT_BGRA32;
1168 break;
1169
1170 case GFX_PIXEL_FORMAT_XRGB_8888:
1171 surface->format = PIXEL_FORMAT_BGRX32;
1172 break;
1173
1174 default:
1175 free(surface);
1176 goto fail;
1177 }
1178
1179 surface->scanline = gfx_align_scanline(surface->width * 4UL, 16);
1180 surface->data = (BYTE*)winpr_aligned_malloc(1ull * surface->scanline * surface->height, 16);
1181
1182 if (!surface->data)
1183 {
1184 free(surface);
1185 goto fail;
1186 }
1187
1188 memset(surface->data, 0xFF, (size_t)surface->scanline * surface->height);
1189 region16_init(&surface->invalidRegion);
1190
1191 WINPR_ASSERT(context->SetSurfaceData);
1192 rc = context->SetSurfaceData(context, surface->surfaceId, (void*)surface);
1193fail:
1194 LeaveCriticalSection(&context->mux);
1195 return rc;
1196}
1197
1203static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
1204 const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
1205{
1206 UINT rc = CHANNEL_RC_OK;
1207 UINT res = ERROR_INTERNAL_ERROR;
1208 rdpCodecs* codecs = NULL;
1209 gdiGfxSurface* surface = NULL;
1210 EnterCriticalSection(&context->mux);
1211
1212 WINPR_ASSERT(context->GetSurfaceData);
1213 surface = (gdiGfxSurface*)context->GetSurfaceData(context, deleteSurface->surfaceId);
1214
1215 if (surface)
1216 {
1217 if (surface->windowMapped)
1218 rc = IFCALLRESULT(CHANNEL_RC_OK, context->UnmapWindowForSurface, context,
1219 surface->windowId);
1220
1221#ifdef WITH_GFX_H264
1222 h264_context_free(surface->h264);
1223#endif
1224 region16_uninit(&surface->invalidRegion);
1225 codecs = surface->codecs;
1226 winpr_aligned_free(surface->data);
1227 free(surface);
1228 }
1229
1230 WINPR_ASSERT(context->SetSurfaceData);
1231 res = context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
1232 if (res)
1233 rc = res;
1234
1235 if (codecs && codecs->progressive)
1236 progressive_delete_surface_context(codecs->progressive, deleteSurface->surfaceId);
1237
1238 LeaveCriticalSection(&context->mux);
1239 return rc;
1240}
1241
1242static BOOL intersect_rect(const RECTANGLE_16* rect, const gdiGfxSurface* surface,
1243 RECTANGLE_16* prect)
1244{
1245 WINPR_ASSERT(rect);
1246 WINPR_ASSERT(surface);
1247 WINPR_ASSERT(prect);
1248
1249 if (rect->left > rect->right)
1250 return FALSE;
1251 if (rect->left > surface->width)
1252 return FALSE;
1253 if (rect->top > rect->bottom)
1254 return FALSE;
1255 if (rect->top > surface->height)
1256 return FALSE;
1257 prect->left = rect->left;
1258 prect->top = rect->top;
1259
1260 prect->right = MIN(rect->right, WINPR_ASSERTING_INT_CAST(UINT16, surface->width));
1261 prect->bottom = MIN(rect->bottom, WINPR_ASSERTING_INT_CAST(UINT16, surface->height));
1262 return TRUE;
1263}
1264
1270static UINT gdi_SolidFill(RdpgfxClientContext* context, const RDPGFX_SOLID_FILL_PDU* solidFill)
1271{
1272 UINT status = ERROR_INTERNAL_ERROR;
1273 BYTE a = 0xff;
1274 RECTANGLE_16 invalidRect = { 0 };
1275 rdpGdi* gdi = (rdpGdi*)context->custom;
1276
1277 EnterCriticalSection(&context->mux);
1278
1279 WINPR_ASSERT(context->GetSurfaceData);
1280 gdiGfxSurface* surface = (gdiGfxSurface*)context->GetSurfaceData(context, solidFill->surfaceId);
1281
1282 if (!surface)
1283 goto fail;
1284
1285 const BYTE b = solidFill->fillPixel.B;
1286 const BYTE g = solidFill->fillPixel.G;
1287 const BYTE r = solidFill->fillPixel.R;
1288
1289 /* [MS-RDPEGFX] 3.3.5.4 Processing an RDPGFX_SOLIDFILL_PDU message
1290 * https://learn.microsoft.com/en-us/windows/win32/gdi/binary-raster-operations
1291 *
1292 * this sounds like the alpha value is always ignored.
1293 */
1294
1295 const UINT32 color = FreeRDPGetColor(surface->format, r, g, b, a);
1296
1297 for (UINT16 index = 0; index < solidFill->fillRectCount; index++)
1298 {
1299 const RECTANGLE_16* rect = &(solidFill->fillRects[index]);
1300
1301 if (!intersect_rect(rect, surface, &invalidRect))
1302 goto fail;
1303
1304 const UINT32 nWidth = invalidRect.right - invalidRect.left;
1305 const UINT32 nHeight = invalidRect.bottom - invalidRect.top;
1306
1307 if (!freerdp_image_fill(surface->data, surface->format, surface->scanline, invalidRect.left,
1308 invalidRect.top, nWidth, nHeight, color))
1309 goto fail;
1310
1311 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
1312 }
1313
1314 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
1315 solidFill->fillRectCount, solidFill->fillRects);
1316
1317 if (status != CHANNEL_RC_OK)
1318 goto fail;
1319
1320 LeaveCriticalSection(&context->mux);
1321
1322 return gdi_interFrameUpdate(gdi, context);
1323fail:
1324 LeaveCriticalSection(&context->mux);
1325 return status;
1326}
1327
1333static UINT gdi_SurfaceToSurface(RdpgfxClientContext* context,
1334 const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
1335{
1336 UINT status = ERROR_INTERNAL_ERROR;
1337 BOOL sameSurface = 0;
1338 UINT32 nWidth = 0;
1339 UINT32 nHeight = 0;
1340 const RECTANGLE_16* rectSrc = NULL;
1341 RECTANGLE_16 invalidRect;
1342 gdiGfxSurface* surfaceSrc = NULL;
1343 gdiGfxSurface* surfaceDst = NULL;
1344 rdpGdi* gdi = (rdpGdi*)context->custom;
1345 EnterCriticalSection(&context->mux);
1346 rectSrc = &(surfaceToSurface->rectSrc);
1347
1348 WINPR_ASSERT(context->GetSurfaceData);
1349 surfaceSrc = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdSrc);
1350 sameSurface =
1351 (surfaceToSurface->surfaceIdSrc == surfaceToSurface->surfaceIdDest) ? TRUE : FALSE;
1352
1353 if (!sameSurface)
1354 surfaceDst =
1355 (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdDest);
1356 else
1357 surfaceDst = surfaceSrc;
1358
1359 if (!surfaceSrc || !surfaceDst)
1360 goto fail;
1361
1362 if (!is_rect_valid(rectSrc, surfaceSrc->width, surfaceSrc->height))
1363 goto fail;
1364
1365 nWidth = rectSrc->right - rectSrc->left;
1366 nHeight = rectSrc->bottom - rectSrc->top;
1367
1368 for (UINT16 index = 0; index < surfaceToSurface->destPtsCount; index++)
1369 {
1370 const RDPGFX_POINT16* destPt = &surfaceToSurface->destPts[index];
1371 const RECTANGLE_16 rect = { destPt->x, destPt->y,
1372 (UINT16)MIN(UINT16_MAX, destPt->x + nWidth),
1373 (UINT16)MIN(UINT16_MAX, destPt->y + nHeight) };
1374 if (!is_rect_valid(&rect, surfaceDst->width, surfaceDst->height))
1375 goto fail;
1376
1377 if (!freerdp_image_copy(surfaceDst->data, surfaceDst->format, surfaceDst->scanline,
1378 destPt->x, destPt->y, nWidth, nHeight, surfaceSrc->data,
1379 surfaceSrc->format, surfaceSrc->scanline, rectSrc->left,
1380 rectSrc->top, NULL, FREERDP_FLIP_NONE))
1381 goto fail;
1382
1383 invalidRect = rect;
1384 region16_union_rect(&surfaceDst->invalidRegion, &surfaceDst->invalidRegion, &invalidRect);
1385 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
1386 surfaceDst->surfaceId, 1, &invalidRect);
1387
1388 if (status != CHANNEL_RC_OK)
1389 goto fail;
1390 }
1391
1392 LeaveCriticalSection(&context->mux);
1393
1394 return gdi_interFrameUpdate(gdi, context);
1395fail:
1396 LeaveCriticalSection(&context->mux);
1397 return status;
1398}
1399
1400static void gdi_GfxCacheEntryFree(gdiGfxCacheEntry* entry)
1401{
1402 if (!entry)
1403 return;
1404 free(entry->data);
1405 free(entry);
1406}
1407
1408static gdiGfxCacheEntry* gdi_GfxCacheEntryNew(UINT64 cacheKey, UINT32 width, UINT32 height,
1409 UINT32 format)
1410{
1411 gdiGfxCacheEntry* cacheEntry = (gdiGfxCacheEntry*)calloc(1, sizeof(gdiGfxCacheEntry));
1412 if (!cacheEntry)
1413 goto fail;
1414
1415 cacheEntry->cacheKey = cacheKey;
1416 cacheEntry->width = width;
1417 cacheEntry->height = height;
1418 cacheEntry->format = format;
1419 cacheEntry->scanline = gfx_align_scanline(cacheEntry->width * 4, 16);
1420
1421 if ((cacheEntry->width > 0) && (cacheEntry->height > 0))
1422 {
1423 cacheEntry->data = (BYTE*)calloc(cacheEntry->height, cacheEntry->scanline);
1424
1425 if (!cacheEntry->data)
1426 goto fail;
1427 }
1428 return cacheEntry;
1429fail:
1430 gdi_GfxCacheEntryFree(cacheEntry);
1431 return NULL;
1432}
1433
1439static UINT gdi_SurfaceToCache(RdpgfxClientContext* context,
1440 const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
1441{
1442 const RECTANGLE_16* rect = NULL;
1443 gdiGfxSurface* surface = NULL;
1444 gdiGfxCacheEntry* cacheEntry = NULL;
1445 UINT rc = ERROR_INTERNAL_ERROR;
1446 EnterCriticalSection(&context->mux);
1447 rect = &(surfaceToCache->rectSrc);
1448
1449 WINPR_ASSERT(context->GetSurfaceData);
1450 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToCache->surfaceId);
1451
1452 if (!surface)
1453 goto fail;
1454
1455 if (!is_rect_valid(rect, surface->width, surface->height))
1456 goto fail;
1457
1458 cacheEntry = gdi_GfxCacheEntryNew(surfaceToCache->cacheKey, (UINT32)(rect->right - rect->left),
1459 (UINT32)(rect->bottom - rect->top), surface->format);
1460
1461 if (!cacheEntry)
1462 goto fail;
1463
1464 if (!cacheEntry->data)
1465 goto fail;
1466
1467 if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
1468 0, 0, cacheEntry->width, cacheEntry->height, surface->data,
1469 surface->format, surface->scanline, rect->left, rect->top,
1470 NULL, FREERDP_FLIP_NONE))
1471 goto fail;
1472
1473 RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { surfaceToCache->cacheSlot };
1474 WINPR_ASSERT(context->EvictCacheEntry);
1475 context->EvictCacheEntry(context, &evict);
1476
1477 WINPR_ASSERT(context->SetCacheSlotData);
1478 rc = context->SetCacheSlotData(context, surfaceToCache->cacheSlot, (void*)cacheEntry);
1479fail:
1480 if (rc != CHANNEL_RC_OK)
1481 gdi_GfxCacheEntryFree(cacheEntry);
1482 LeaveCriticalSection(&context->mux);
1483 return rc;
1484}
1485
1491static UINT gdi_CacheToSurface(RdpgfxClientContext* context,
1492 const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
1493{
1494 UINT status = ERROR_INTERNAL_ERROR;
1495 gdiGfxSurface* surface = NULL;
1496 gdiGfxCacheEntry* cacheEntry = NULL;
1497 RECTANGLE_16 invalidRect;
1498 rdpGdi* gdi = (rdpGdi*)context->custom;
1499
1500 EnterCriticalSection(&context->mux);
1501
1502 WINPR_ASSERT(context->GetSurfaceData);
1503 surface = (gdiGfxSurface*)context->GetSurfaceData(context, cacheToSurface->surfaceId);
1504
1505 WINPR_ASSERT(context->GetCacheSlotData);
1506 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheToSurface->cacheSlot);
1507
1508 if (!surface || !cacheEntry)
1509 goto fail;
1510
1511 for (UINT16 index = 0; index < cacheToSurface->destPtsCount; index++)
1512 {
1513 const RDPGFX_POINT16* destPt = &cacheToSurface->destPts[index];
1514 const RECTANGLE_16 rect = { destPt->x, destPt->y,
1515 (UINT16)MIN(UINT16_MAX, destPt->x + cacheEntry->width),
1516 (UINT16)MIN(UINT16_MAX, destPt->y + cacheEntry->height) };
1517
1518 if (rectangle_is_empty(&rect))
1519 continue;
1520
1521 if (!is_rect_valid(&rect, surface->width, surface->height))
1522 goto fail;
1523
1524 if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline,
1525 destPt->x, destPt->y, cacheEntry->width,
1526 cacheEntry->height, cacheEntry->data, cacheEntry->format,
1527 cacheEntry->scanline, 0, 0, NULL, FREERDP_FLIP_NONE))
1528 goto fail;
1529
1530 invalidRect = rect;
1531 region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &invalidRect);
1532 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
1533 surface->surfaceId, 1, &invalidRect);
1534
1535 if (status != CHANNEL_RC_OK)
1536 goto fail;
1537 }
1538
1539 LeaveCriticalSection(&context->mux);
1540
1541 return gdi_interFrameUpdate(gdi, context);
1542
1543fail:
1544 LeaveCriticalSection(&context->mux);
1545 return status;
1546}
1547
1553static UINT gdi_CacheImportReply(RdpgfxClientContext* context,
1554 const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
1555{
1556 UINT16 count = 0;
1557 const UINT16* slots = NULL;
1558 UINT error = CHANNEL_RC_OK;
1559
1560 slots = cacheImportReply->cacheSlots;
1561 count = cacheImportReply->importedEntriesCount;
1562
1563 for (UINT16 index = 0; index < count; index++)
1564 {
1565 UINT16 cacheSlot = slots[index];
1566
1567 if (cacheSlot == 0)
1568 continue;
1569
1570 WINPR_ASSERT(context->GetCacheSlotData);
1571 gdiGfxCacheEntry* cacheEntry =
1572 (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
1573
1574 if (cacheEntry)
1575 continue;
1576
1577 cacheEntry = gdi_GfxCacheEntryNew(cacheSlot, 0, 0, PIXEL_FORMAT_BGRX32);
1578
1579 if (!cacheEntry)
1580 return ERROR_INTERNAL_ERROR;
1581
1582 WINPR_ASSERT(context->SetCacheSlotData);
1583 error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
1584
1585 if (error)
1586 {
1587 WLog_ERR(TAG, "CacheImportReply: SetCacheSlotData failed with error %" PRIu32 "",
1588 error);
1589 gdi_GfxCacheEntryFree(cacheEntry);
1590 break;
1591 }
1592 }
1593
1594 return error;
1595}
1596
1597static UINT gdi_ImportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
1598 const PERSISTENT_CACHE_ENTRY* importCacheEntry)
1599{
1600 UINT error = ERROR_INTERNAL_ERROR;
1601 gdiGfxCacheEntry* cacheEntry = NULL;
1602
1603 if (cacheSlot == 0)
1604 return CHANNEL_RC_OK;
1605
1606 cacheEntry = gdi_GfxCacheEntryNew(importCacheEntry->key64, importCacheEntry->width,
1607 importCacheEntry->height, PIXEL_FORMAT_BGRX32);
1608
1609 if (!cacheEntry)
1610 goto fail;
1611
1612 if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
1613 0, 0, cacheEntry->width, cacheEntry->height,
1614 importCacheEntry->data, PIXEL_FORMAT_BGRX32, 0, 0, 0, NULL,
1615 FREERDP_FLIP_NONE))
1616 goto fail;
1617
1618 RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { cacheSlot };
1619 WINPR_ASSERT(context->EvictCacheEntry);
1620 error = context->EvictCacheEntry(context, &evict);
1621 if (error != CHANNEL_RC_OK)
1622 goto fail;
1623
1624 WINPR_ASSERT(context->SetCacheSlotData);
1625 error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
1626
1627fail:
1628 if (error)
1629 {
1630 gdi_GfxCacheEntryFree(cacheEntry);
1631 WLog_ERR(TAG, "ImportCacheEntry: SetCacheSlotData failed with error %" PRIu32 "", error);
1632 }
1633
1634 return error;
1635}
1636
1637static UINT gdi_ExportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
1638 PERSISTENT_CACHE_ENTRY* exportCacheEntry)
1639{
1640 gdiGfxCacheEntry* cacheEntry = NULL;
1641
1642 WINPR_ASSERT(context->GetCacheSlotData);
1643 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
1644
1645 if (cacheEntry)
1646 {
1647 exportCacheEntry->key64 = cacheEntry->cacheKey;
1648 exportCacheEntry->width = (UINT16)MIN(UINT16_MAX, cacheEntry->width);
1649 exportCacheEntry->height = (UINT16)MIN(UINT16_MAX, cacheEntry->height);
1650 exportCacheEntry->size = cacheEntry->width * cacheEntry->height * 4;
1651 exportCacheEntry->flags = 0;
1652 exportCacheEntry->data = cacheEntry->data;
1653 return CHANNEL_RC_OK;
1654 }
1655
1656 return ERROR_NOT_FOUND;
1657}
1658
1664static UINT gdi_EvictCacheEntry(RdpgfxClientContext* context,
1665 const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
1666{
1667 gdiGfxCacheEntry* cacheEntry = NULL;
1668 UINT rc = ERROR_NOT_FOUND;
1669
1670 WINPR_ASSERT(context);
1671 WINPR_ASSERT(evictCacheEntry);
1672
1673 EnterCriticalSection(&context->mux);
1674
1675 WINPR_ASSERT(context->GetCacheSlotData);
1676 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, evictCacheEntry->cacheSlot);
1677
1678 gdi_GfxCacheEntryFree(cacheEntry);
1679
1680 WINPR_ASSERT(context->SetCacheSlotData);
1681 rc = context->SetCacheSlotData(context, evictCacheEntry->cacheSlot, NULL);
1682 LeaveCriticalSection(&context->mux);
1683 return rc;
1684}
1685
1691static UINT gdi_MapSurfaceToOutput(RdpgfxClientContext* context,
1692 const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
1693{
1694 UINT rc = ERROR_INTERNAL_ERROR;
1695 gdiGfxSurface* surface = NULL;
1696 EnterCriticalSection(&context->mux);
1697
1698 WINPR_ASSERT(context->GetSurfaceData);
1699 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
1700
1701 if (!surface)
1702 goto fail;
1703
1704 if (surface->windowMapped)
1705 {
1706 WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
1707 goto fail;
1708 }
1709
1710 surface->outputMapped = TRUE;
1711 surface->outputOriginX = surfaceToOutput->outputOriginX;
1712 surface->outputOriginY = surfaceToOutput->outputOriginY;
1713 surface->outputTargetWidth = surface->mappedWidth;
1714 surface->outputTargetHeight = surface->mappedHeight;
1715 region16_clear(&surface->invalidRegion);
1716 rc = CHANNEL_RC_OK;
1717fail:
1718 LeaveCriticalSection(&context->mux);
1719 return rc;
1720}
1721
1722static UINT
1723gdi_MapSurfaceToScaledOutput(RdpgfxClientContext* context,
1724 const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* surfaceToOutput)
1725{
1726 UINT rc = ERROR_INTERNAL_ERROR;
1727 gdiGfxSurface* surface = NULL;
1728 EnterCriticalSection(&context->mux);
1729
1730 WINPR_ASSERT(context->GetSurfaceData);
1731 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
1732
1733 if (!surface)
1734 goto fail;
1735
1736 if (surface->windowMapped)
1737 {
1738 WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
1739 goto fail;
1740 }
1741
1742 surface->outputMapped = TRUE;
1743 surface->outputOriginX = surfaceToOutput->outputOriginX;
1744 surface->outputOriginY = surfaceToOutput->outputOriginY;
1745 surface->outputTargetWidth = surfaceToOutput->targetWidth;
1746 surface->outputTargetHeight = surfaceToOutput->targetHeight;
1747 region16_clear(&surface->invalidRegion);
1748 rc = CHANNEL_RC_OK;
1749fail:
1750 LeaveCriticalSection(&context->mux);
1751 return rc;
1752}
1753
1759static UINT gdi_MapSurfaceToWindow(RdpgfxClientContext* context,
1760 const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
1761{
1762 UINT rc = ERROR_INTERNAL_ERROR;
1763 gdiGfxSurface* surface = NULL;
1764 EnterCriticalSection(&context->mux);
1765
1766 WINPR_ASSERT(context->GetSurfaceData);
1767 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
1768
1769 if (!surface)
1770 goto fail;
1771
1772 if (surface->outputMapped)
1773 {
1774 WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
1775 goto fail;
1776 }
1777
1778 if (surface->windowMapped)
1779 {
1780 if (surface->windowId != surfaceToWindow->windowId)
1781 {
1782 WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
1783 surface->windowId, surfaceToWindow->windowId);
1784 goto fail;
1785 }
1786 }
1787 surface->windowMapped = TRUE;
1788
1789 surface->windowId = surfaceToWindow->windowId;
1790 surface->mappedWidth = surfaceToWindow->mappedWidth;
1791 surface->mappedHeight = surfaceToWindow->mappedHeight;
1792 surface->outputTargetWidth = surfaceToWindow->mappedWidth;
1793 surface->outputTargetHeight = surfaceToWindow->mappedHeight;
1794 rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
1795 surfaceToWindow->surfaceId, surfaceToWindow->windowId);
1796fail:
1797 LeaveCriticalSection(&context->mux);
1798 return rc;
1799}
1800
1801static UINT
1802gdi_MapSurfaceToScaledWindow(RdpgfxClientContext* context,
1803 const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* surfaceToWindow)
1804{
1805 UINT rc = ERROR_INTERNAL_ERROR;
1806 gdiGfxSurface* surface = NULL;
1807 EnterCriticalSection(&context->mux);
1808
1809 WINPR_ASSERT(context->GetSurfaceData);
1810 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
1811
1812 if (!surface)
1813 goto fail;
1814
1815 if (surface->outputMapped)
1816 {
1817 WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
1818 goto fail;
1819 }
1820
1821 if (surface->windowMapped)
1822 {
1823 if (surface->windowId != surfaceToWindow->windowId)
1824 {
1825 WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
1826 surface->windowId, surfaceToWindow->windowId);
1827 goto fail;
1828 }
1829 }
1830 surface->windowMapped = TRUE;
1831
1832 surface->windowId = surfaceToWindow->windowId;
1833 surface->mappedWidth = surfaceToWindow->mappedWidth;
1834 surface->mappedHeight = surfaceToWindow->mappedHeight;
1835 surface->outputTargetWidth = surfaceToWindow->targetWidth;
1836 surface->outputTargetHeight = surfaceToWindow->targetHeight;
1837 rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
1838 surfaceToWindow->surfaceId, surfaceToWindow->windowId);
1839fail:
1840 LeaveCriticalSection(&context->mux);
1841 return rc;
1842}
1843
1844BOOL gdi_graphics_pipeline_init(rdpGdi* gdi, RdpgfxClientContext* gfx)
1845{
1846 return gdi_graphics_pipeline_init_ex(gdi, gfx, NULL, NULL, NULL);
1847}
1848
1849BOOL gdi_graphics_pipeline_init_ex(rdpGdi* gdi, RdpgfxClientContext* gfx,
1850 pcRdpgfxMapWindowForSurface map,
1851 pcRdpgfxUnmapWindowForSurface unmap,
1852 pcRdpgfxUpdateSurfaceArea update)
1853{
1854 if (!gdi || !gfx || !gdi->context || !gdi->context->settings)
1855 return FALSE;
1856
1857 rdpContext* context = gdi->context;
1858 rdpSettings* settings = context->settings;
1859
1860 gdi->gfx = gfx;
1861 gfx->custom = (void*)gdi;
1862 gfx->ResetGraphics = gdi_ResetGraphics;
1863 gfx->StartFrame = gdi_StartFrame;
1864 gfx->EndFrame = gdi_EndFrame;
1865 gfx->SurfaceCommand = gdi_SurfaceCommand;
1866 gfx->DeleteEncodingContext = gdi_DeleteEncodingContext;
1867 gfx->CreateSurface = gdi_CreateSurface;
1868 gfx->DeleteSurface = gdi_DeleteSurface;
1869 gfx->SolidFill = gdi_SolidFill;
1870 gfx->SurfaceToSurface = gdi_SurfaceToSurface;
1871 gfx->SurfaceToCache = gdi_SurfaceToCache;
1872 gfx->CacheToSurface = gdi_CacheToSurface;
1873 gfx->CacheImportReply = gdi_CacheImportReply;
1874 gfx->ImportCacheEntry = gdi_ImportCacheEntry;
1875 gfx->ExportCacheEntry = gdi_ExportCacheEntry;
1876 gfx->EvictCacheEntry = gdi_EvictCacheEntry;
1877 gfx->MapSurfaceToOutput = gdi_MapSurfaceToOutput;
1878 gfx->MapSurfaceToWindow = gdi_MapSurfaceToWindow;
1879 gfx->MapSurfaceToScaledOutput = gdi_MapSurfaceToScaledOutput;
1880 gfx->MapSurfaceToScaledWindow = gdi_MapSurfaceToScaledWindow;
1881 gfx->UpdateSurfaces = gdi_UpdateSurfaces;
1882 gfx->MapWindowForSurface = map;
1883 gfx->UnmapWindowForSurface = unmap;
1884 gfx->UpdateSurfaceArea = update;
1885
1886 if (!freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
1887 {
1888 const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
1889 const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
1890 const UINT32 flags = freerdp_settings_get_uint32(settings, FreeRDP_ThreadingFlags);
1891
1892 gfx->codecs = freerdp_client_codecs_new(flags);
1893 if (!gfx->codecs)
1894 return FALSE;
1895 if (!freerdp_client_codecs_prepare(gfx->codecs, FREERDP_CODEC_ALL, w, h))
1896 return FALSE;
1897 }
1898 InitializeCriticalSection(&gfx->mux);
1899 PROFILER_CREATE(gfx->SurfaceProfiler, "GFX-PROFILER")
1900
1901
1907 gdi->graphicsReset = TRUE;
1908 if (freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
1909 {
1910 gfx->UpdateSurfaceArea = NULL;
1911 gfx->UpdateSurfaces = NULL;
1912 gfx->SurfaceCommand = NULL;
1913 }
1914
1915 return TRUE;
1916}
1917
1918void gdi_graphics_pipeline_uninit(rdpGdi* gdi, RdpgfxClientContext* gfx)
1919{
1920 if (gdi)
1921 gdi->gfx = NULL;
1922
1923 if (!gfx)
1924 return;
1925
1926 gfx->custom = NULL;
1927 freerdp_client_codecs_free(gfx->codecs);
1928 gfx->codecs = NULL;
1929 DeleteCriticalSection(&gfx->mux);
1930 PROFILER_PRINT_HEADER
1931 PROFILER_PRINT(gfx->SurfaceProfiler)
1932 PROFILER_PRINT_FOOTER
1933 PROFILER_FREE(gfx->SurfaceProfiler)
1934}
1935
1936const char* rdpgfx_caps_version_str(UINT32 capsVersion)
1937{
1938 switch (capsVersion)
1939 {
1940 case RDPGFX_CAPVERSION_8:
1941 return "RDPGFX_CAPVERSION_8";
1942 case RDPGFX_CAPVERSION_81:
1943 return "RDPGFX_CAPVERSION_81";
1944 case RDPGFX_CAPVERSION_10:
1945 return "RDPGFX_CAPVERSION_10";
1946 case RDPGFX_CAPVERSION_101:
1947 return "RDPGFX_CAPVERSION_101";
1948 case RDPGFX_CAPVERSION_102:
1949 return "RDPGFX_CAPVERSION_102";
1950 case RDPGFX_CAPVERSION_103:
1951 return "RDPGFX_CAPVERSION_103";
1952 case RDPGFX_CAPVERSION_104:
1953 return "RDPGFX_CAPVERSION_104";
1954 case RDPGFX_CAPVERSION_105:
1955 return "RDPGFX_CAPVERSION_105";
1956 case RDPGFX_CAPVERSION_106:
1957 return "RDPGFX_CAPVERSION_106";
1958 case RDPGFX_CAPVERSION_106_ERR:
1959 return "RDPGFX_CAPVERSION_106_ERR";
1960 case RDPGFX_CAPVERSION_107:
1961 return "RDPGFX_CAPVERSION_107";
1962 default:
1963 return "RDPGFX_CAPVERSION_UNKNOWN";
1964 }
1965}
freerdp_settings_get_uint32
FREERDP_API UINT32 freerdp_settings_get_uint32(const rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id)
Returns a UINT32 settings value.
freerdp_settings_get_bool
FREERDP_API BOOL freerdp_settings_get_bool(const rdpSettings *settings, FreeRDP_Settings_Keys_Bool id)
Returns a boolean settings value.
freerdp_settings_get_codecs_flags
FREERDP_API UINT32 freerdp_settings_get_codecs_flags(const rdpSettings *settings)
helper function to get a mask of supported codec flags.
Definition common/settings.c:1987
freerdp_settings_set_uint32
FREERDP_API BOOL freerdp_settings_set_uint32(rdpSettings *settings, FreeRDP_Settings_Keys_UInt32 id, UINT32 param)
Sets a UINT32 settings value.
PERSISTENT_CACHE_ENTRY
Definition persistent.h:70
RDPGFX_AVC420_BITMAP_STREAM
Definition channels/rdpgfx.h:385
RDPGFX_AVC444_BITMAP_STREAM
Definition channels/rdpgfx.h:392
RDPGFX_CACHE_IMPORT_REPLY_PDU
Definition channels/rdpgfx.h:331
RDPGFX_CACHE_TO_SURFACE_PDU
Definition channels/rdpgfx.h:240
RDPGFX_CREATE_SURFACE_PDU
Definition channels/rdpgfx.h:253
RDPGFX_DELETE_ENCODING_CONTEXT_PDU
Definition channels/rdpgfx.h:209
RDPGFX_DELETE_SURFACE_PDU
Definition channels/rdpgfx.h:261
RDPGFX_END_FRAME_PDU
Definition channels/rdpgfx.h:276
RDPGFX_EVICT_CACHE_ENTRY_PDU
Definition channels/rdpgfx.h:248
RDPGFX_H264_METABLOCK
Definition channels/rdpgfx.h:378
RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU
Definition channels/rdpgfx.h:299
RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU
Definition channels/rdpgfx.h:307
RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU
Definition channels/rdpgfx.h:356
RDPGFX_MAP_SURFACE_TO_WINDOW_PDU
Definition channels/rdpgfx.h:348
RDPGFX_POINT16
Definition channels/rdpgfx.h:43
RDPGFX_RESET_GRAPHICS_PDU
Definition channels/rdpgfx.h:291
RDPGFX_SOLID_FILL_PDU
Definition channels/rdpgfx.h:215
RDPGFX_START_FRAME_PDU
Definition channels/rdpgfx.h:268
RDPGFX_SURFACE_COMMAND
Definition channels/rdpgfx.h:192
RDPGFX_SURFACE_TO_CACHE_PDU
Definition channels/rdpgfx.h:232
RDPGFX_SURFACE_TO_SURFACE_PDU
Definition channels/rdpgfx.h:223
RECTANGLE_16
Definition types.h:109