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 (!planar_decompress(surface->codecs->planar, cmd->data, cmd->length, cmd->width, cmd->height,
544 DstData, surface->format, surface->scanline, cmd->left, cmd->top,
545 cmd->width, cmd->height, FALSE))
546 return ERROR_INTERNAL_ERROR;
547
548 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
549 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
550 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
551 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
552 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
553 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
554 &invalidRect);
555
556 if (status != CHANNEL_RC_OK)
557 goto fail;
558
559 status = gdi_interFrameUpdate(gdi, context);
560
561fail:
562 return status;
563}
564
570static UINT gdi_SurfaceCommand_AVC420(rdpGdi* gdi, RdpgfxClientContext* context,
571 const RDPGFX_SURFACE_COMMAND* cmd)
572{
573#ifdef WITH_GFX_H264
574 INT32 rc = 0;
575 UINT status = CHANNEL_RC_OK;
576 gdiGfxSurface* surface = NULL;
577 RDPGFX_H264_METABLOCK* meta = NULL;
578 RDPGFX_AVC420_BITMAP_STREAM* bs = NULL;
579 WINPR_ASSERT(gdi);
580 WINPR_ASSERT(context);
581 WINPR_ASSERT(cmd);
582
583 WINPR_ASSERT(context->GetSurfaceData);
584 surface =
585 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
586
587 if (!surface)
588 {
589 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
590 return ERROR_NOT_FOUND;
591 }
592
593 if (!surface->h264)
594 {
595 surface->h264 = h264_context_new(FALSE);
596
597 if (!surface->h264)
598 {
599 WLog_ERR(TAG, "unable to create h264 context");
600 return ERROR_NOT_ENOUGH_MEMORY;
601 }
602
603 if (!h264_context_reset(surface->h264, surface->width, surface->height))
604 return ERROR_INTERNAL_ERROR;
605 }
606
607 if (!surface->h264)
608 return ERROR_NOT_SUPPORTED;
609
610 bs = (RDPGFX_AVC420_BITMAP_STREAM*)cmd->extra;
611
612 if (!bs)
613 return ERROR_INTERNAL_ERROR;
614
615 meta = &(bs->meta);
616 rc = avc420_decompress(surface->h264, bs->data, bs->length, surface->data, surface->format,
617 surface->scanline, surface->width, surface->height, meta->regionRects,
618 meta->numRegionRects);
619
620 if (rc < 0)
621 {
622 WLog_WARN(TAG, "avc420_decompress failure: %" PRId32 ", ignoring update.", rc);
623 return CHANNEL_RC_OK;
624 }
625
626 for (UINT32 i = 0; i < meta->numRegionRects; i++)
627 {
628 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
629 &(meta->regionRects[i]));
630 }
631
632 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
633 meta->numRegionRects, meta->regionRects);
634
635 if (status != CHANNEL_RC_OK)
636 goto fail;
637
638 status = gdi_interFrameUpdate(gdi, context);
639
640fail:
641 return status;
642#else
643 return ERROR_NOT_SUPPORTED;
644#endif
645}
646
652static UINT gdi_SurfaceCommand_AVC444(rdpGdi* gdi, RdpgfxClientContext* context,
653 const RDPGFX_SURFACE_COMMAND* cmd)
654{
655#ifdef WITH_GFX_H264
656 INT32 rc = 0;
657 UINT status = CHANNEL_RC_OK;
658 gdiGfxSurface* surface = NULL;
659 RDPGFX_AVC444_BITMAP_STREAM* bs = NULL;
660 RDPGFX_AVC420_BITMAP_STREAM* avc1 = NULL;
661 RDPGFX_H264_METABLOCK* meta1 = NULL;
662 RDPGFX_AVC420_BITMAP_STREAM* avc2 = NULL;
663 RDPGFX_H264_METABLOCK* meta2 = NULL;
664 WINPR_ASSERT(gdi);
665 WINPR_ASSERT(context);
666 WINPR_ASSERT(cmd);
667
668 WINPR_ASSERT(context->GetSurfaceData);
669 surface =
670 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
671
672 if (!surface)
673 {
674 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
675 return ERROR_NOT_FOUND;
676 }
677
678 if (!surface->h264)
679 {
680 surface->h264 = h264_context_new(FALSE);
681
682 if (!surface->h264)
683 {
684 WLog_ERR(TAG, "unable to create h264 context");
685 return ERROR_NOT_ENOUGH_MEMORY;
686 }
687
688 if (!h264_context_reset(surface->h264, surface->width, surface->height))
689 return ERROR_INTERNAL_ERROR;
690 }
691
692 if (!surface->h264)
693 return ERROR_NOT_SUPPORTED;
694
695 bs = (RDPGFX_AVC444_BITMAP_STREAM*)cmd->extra;
696
697 if (!bs)
698 return ERROR_INTERNAL_ERROR;
699
700 avc1 = &bs->bitstream[0];
701 avc2 = &bs->bitstream[1];
702 meta1 = &avc1->meta;
703 meta2 = &avc2->meta;
704 rc = avc444_decompress(surface->h264, bs->LC, meta1->regionRects, meta1->numRegionRects,
705 avc1->data, avc1->length, meta2->regionRects, meta2->numRegionRects,
706 avc2->data, avc2->length, surface->data, surface->format,
707 surface->scanline, surface->width, surface->height, cmd->codecId);
708
709 if (rc < 0)
710 {
711 WLog_WARN(TAG, "avc444_decompress failure: %" PRIu32 ", ignoring update.", status);
712 return CHANNEL_RC_OK;
713 }
714
715 for (UINT32 i = 0; i < meta1->numRegionRects; i++)
716 {
717 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
718 &(meta1->regionRects[i]));
719 }
720
721 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
722 meta1->numRegionRects, meta1->regionRects);
723
724 if (status != CHANNEL_RC_OK)
725 goto fail;
726
727 for (UINT32 i = 0; i < meta2->numRegionRects; i++)
728 {
729 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion),
730 &(meta2->regionRects[i]));
731 }
732
733 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
734 meta2->numRegionRects, meta2->regionRects);
735
736 if (status != CHANNEL_RC_OK)
737 goto fail;
738
739 status = gdi_interFrameUpdate(gdi, context);
740
741fail:
742 return status;
743#else
744 return ERROR_NOT_SUPPORTED;
745#endif
746}
747
748static BOOL gdi_apply_alpha(BYTE* data, UINT32 format, UINT32 stride, RECTANGLE_16* rect,
749 UINT32 startOffsetX, UINT32 count, BYTE a)
750{
751 UINT32 written = 0;
752 BOOL first = TRUE;
753 const UINT32 bpp = FreeRDPGetBytesPerPixel(format);
754 WINPR_ASSERT(rect);
755
756 for (size_t y = rect->top; y < rect->bottom; y++)
757 {
758 BYTE* line = &data[y * stride];
759
760 for (size_t x = first ? rect->left + startOffsetX : rect->left; x < rect->right; x++)
761 {
762 BYTE r = 0;
763 BYTE g = 0;
764 BYTE b = 0;
765
766 if (written == count)
767 return TRUE;
768
769 BYTE* src = &line[x * bpp];
770 UINT32 color = FreeRDPReadColor(src, format);
771 FreeRDPSplitColor(color, format, &r, &g, &b, NULL, NULL);
772 color = FreeRDPGetColor(format, r, g, b, a);
773 FreeRDPWriteColor(src, format, color);
774 written++;
775 }
776
777 first = FALSE;
778 }
779
780 return TRUE;
781}
787static UINT gdi_SurfaceCommand_Alpha(rdpGdi* gdi, RdpgfxClientContext* context,
788 const RDPGFX_SURFACE_COMMAND* cmd)
789{
790 UINT status = CHANNEL_RC_OK;
791 UINT16 alphaSig = 0;
792 UINT16 compressed = 0;
793 gdiGfxSurface* surface = NULL;
794 RECTANGLE_16 invalidRect;
795 wStream buffer;
796 wStream* s = NULL;
797 WINPR_ASSERT(gdi);
798 WINPR_ASSERT(context);
799 WINPR_ASSERT(cmd);
800
801 s = Stream_StaticConstInit(&buffer, cmd->data, cmd->length);
802
803 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
804 return ERROR_INVALID_DATA;
805
806 WINPR_ASSERT(context->GetSurfaceData);
807 surface =
808 (gdiGfxSurface*)context->GetSurfaceData(context, (UINT16)MIN(UINT16_MAX, cmd->surfaceId));
809
810 if (!surface)
811 {
812 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
813 return ERROR_NOT_FOUND;
814 }
815
816 if (!is_within_surface(surface, cmd))
817 return ERROR_INVALID_DATA;
818
819 Stream_Read_UINT16(s, alphaSig);
820 Stream_Read_UINT16(s, compressed);
821
822 if (alphaSig != 0x414C)
823 return ERROR_INVALID_DATA;
824
825 if (compressed == 0)
826 {
827 if (!Stream_CheckAndLogRequiredLengthOfSize(TAG, s, cmd->height, cmd->width))
828 return ERROR_INVALID_DATA;
829
830 for (size_t y = cmd->top; y < cmd->top + cmd->height; y++)
831 {
832 BYTE* line = &surface->data[y * surface->scanline];
833
834 for (size_t x = cmd->left; x < cmd->left + cmd->width; x++)
835 {
836 UINT32 color = 0;
837 BYTE r = 0;
838 BYTE g = 0;
839 BYTE b = 0;
840 BYTE a = 0;
841 BYTE* src = &line[x * FreeRDPGetBytesPerPixel(surface->format)];
842 Stream_Read_UINT8(s, a);
843 color = FreeRDPReadColor(src, surface->format);
844 FreeRDPSplitColor(color, surface->format, &r, &g, &b, NULL, NULL);
845 color = FreeRDPGetColor(surface->format, r, g, b, a);
846 FreeRDPWriteColor(src, surface->format, color);
847 }
848 }
849 }
850 else
851 {
852 UINT32 startOffsetX = 0;
853 RECTANGLE_16 rect = { 0 };
854 rect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
855 rect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
856 rect.right = (UINT16)MIN(UINT16_MAX, cmd->left + cmd->width);
857 rect.bottom = (UINT16)MIN(UINT16_MAX, cmd->top + cmd->height);
858
859 while (rect.top < rect.bottom)
860 {
861 UINT32 count = 0;
862 BYTE a = 0;
863
864 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
865 return ERROR_INVALID_DATA;
866
867 Stream_Read_UINT8(s, a);
868 Stream_Read_UINT8(s, count);
869
870 if (count >= 0xFF)
871 {
872 if (!Stream_CheckAndLogRequiredLength(TAG, s, 2))
873 return ERROR_INVALID_DATA;
874
875 Stream_Read_UINT16(s, count);
876
877 if (count >= 0xFFFF)
878 {
879 if (!Stream_CheckAndLogRequiredLength(TAG, s, 4))
880 return ERROR_INVALID_DATA;
881
882 Stream_Read_UINT32(s, count);
883 }
884 }
885
886 if (!gdi_apply_alpha(surface->data, surface->format, surface->scanline, &rect,
887 startOffsetX, count, a))
888 return ERROR_INTERNAL_ERROR;
889
890 startOffsetX += count;
891
892 while (startOffsetX >= cmd->width)
893 {
894 startOffsetX -= cmd->width;
895 rect.top++;
896 }
897 }
898 }
899
900 invalidRect.left = (UINT16)MIN(UINT16_MAX, cmd->left);
901 invalidRect.top = (UINT16)MIN(UINT16_MAX, cmd->top);
902 invalidRect.right = (UINT16)MIN(UINT16_MAX, cmd->right);
903 invalidRect.bottom = (UINT16)MIN(UINT16_MAX, cmd->bottom);
904 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
905 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId, 1,
906 &invalidRect);
907
908 if (status != CHANNEL_RC_OK)
909 goto fail;
910
911 status = gdi_interFrameUpdate(gdi, context);
912
913fail:
914 return status;
915}
916
917#if defined(WITH_GFX_FRAME_DUMP)
918static void dump_cmd(const RDPGFX_SURFACE_COMMAND* cmd, UINT32 frameId)
919{
920 static UINT64 xxx = 0;
921 const char* path = "/tmp/dump/";
922 WINPR_ASSERT(cmd);
923 char fname[1024] = { 0 };
924
925 snprintf(fname, sizeof(fname), "%s/%08" PRIx64 ".raw", path, xxx++);
926 FILE* fp = fopen(fname, "w");
927 if (!fp)
928 return;
929 (void)fprintf(fp, "frameid: %" PRIu32 "\n", frameId);
930 (void)fprintf(fp, "surfaceId: %" PRIu32 "\n", cmd->surfaceId);
931 (void)fprintf(fp, "codecId: %" PRIu32 "\n", cmd->codecId);
932 (void)fprintf(fp, "contextId: %" PRIu32 "\n", cmd->contextId);
933 (void)fprintf(fp, "format: %" PRIu32 "\n", cmd->format);
934 (void)fprintf(fp, "left: %" PRIu32 "\n", cmd->left);
935 (void)fprintf(fp, "top: %" PRIu32 "\n", cmd->top);
936 (void)fprintf(fp, "right: %" PRIu32 "\n", cmd->right);
937 (void)fprintf(fp, "bottom: %" PRIu32 "\n", cmd->bottom);
938 (void)fprintf(fp, "width: %" PRIu32 "\n", cmd->width);
939 (void)fprintf(fp, "height: %" PRIu32 "\n", cmd->height);
940 (void)fprintf(fp, "length: %" PRIu32 "\n", cmd->length);
941
942 char* bdata = crypto_base64_encode_ex(cmd->data, cmd->length, FALSE);
943 (void)fprintf(fp, "data: %s\n", bdata);
944 free(bdata);
945 fclose(fp);
946}
947#endif
948
954static UINT gdi_SurfaceCommand_Progressive(rdpGdi* gdi, RdpgfxClientContext* context,
955 const RDPGFX_SURFACE_COMMAND* cmd)
956{
957 INT32 rc = 0;
958 UINT status = CHANNEL_RC_OK;
959 gdiGfxSurface* surface = NULL;
960 REGION16 invalidRegion;
961 const RECTANGLE_16* rects = NULL;
962 UINT32 nrRects = 0;
968 WINPR_ASSERT(gdi);
969 WINPR_ASSERT(context);
970 WINPR_ASSERT(cmd);
971 const UINT16 surfaceId = (UINT16)MIN(UINT16_MAX, cmd->surfaceId);
972
973 WINPR_ASSERT(context->GetSurfaceData);
974 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceId);
975
976 if (!surface)
977 {
978 WLog_ERR(TAG, "unable to retrieve surfaceData for surfaceId=%" PRIu32 "", cmd->surfaceId);
979 return ERROR_NOT_FOUND;
980 }
981
982 if (!is_within_surface(surface, cmd))
983 return ERROR_INVALID_DATA;
984
985 WINPR_ASSERT(surface->codecs);
986 rc = progressive_create_surface_context(surface->codecs->progressive, surfaceId, surface->width,
987 surface->height);
988
989 if (rc < 0)
990 {
991 WLog_ERR(TAG, "progressive_create_surface_context failure: %" PRId32 "", rc);
992 return ERROR_INTERNAL_ERROR;
993 }
994
995 region16_init(&invalidRegion);
996
997 rc = progressive_decompress(surface->codecs->progressive, cmd->data, cmd->length, surface->data,
998 surface->format, surface->scanline, cmd->left, cmd->top,
999 &invalidRegion, surfaceId, gdi->frameId);
1000
1001 if (rc < 0)
1002 {
1003 WLog_ERR(TAG, "progressive_decompress failure: %" PRId32 "", rc);
1004 region16_uninit(&invalidRegion);
1005 return ERROR_INTERNAL_ERROR;
1006 }
1007
1008 rects = region16_rects(&invalidRegion, &nrRects);
1009 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
1010 nrRects, rects);
1011
1012 if (status != CHANNEL_RC_OK)
1013 goto fail;
1014
1015 for (UINT32 x = 0; x < nrRects; x++)
1016 region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &rects[x]);
1017
1018 region16_uninit(&invalidRegion);
1019
1020 status = gdi_interFrameUpdate(gdi, context);
1021
1022fail:
1023 return status;
1024}
1025
1031static UINT gdi_SurfaceCommand(RdpgfxClientContext* context, const RDPGFX_SURFACE_COMMAND* cmd)
1032{
1033 UINT status = CHANNEL_RC_OK;
1034 rdpGdi* gdi = NULL;
1035
1036 if (!context || !cmd)
1037 return ERROR_INVALID_PARAMETER;
1038
1039 gdi = (rdpGdi*)context->custom;
1040
1041 EnterCriticalSection(&context->mux);
1042 const UINT16 codecId = WINPR_ASSERTING_INT_CAST(UINT16, cmd->codecId);
1043 WLog_Print(gdi->log, WLOG_TRACE,
1044 "surfaceId=%" PRIu32 ", codec=%s [%" PRIu32 "], contextId=%" PRIu32 ", format=%s, "
1045 "left=%" PRIu32 ", top=%" PRIu32 ", right=%" PRIu32 ", bottom=%" PRIu32
1046 ", width=%" PRIu32 ", height=%" PRIu32 " "
1047 "length=%" PRIu32 ", data=%p, extra=%p",
1048 cmd->surfaceId, rdpgfx_get_codec_id_string(codecId), cmd->codecId, cmd->contextId,
1049 FreeRDPGetColorFormatName(cmd->format), cmd->left, cmd->top, cmd->right, cmd->bottom,
1050 cmd->width, cmd->height, cmd->length, (void*)cmd->data, (void*)cmd->extra);
1051#if defined(WITH_GFX_FRAME_DUMP)
1052 dump_cmd(cmd, gdi->frameId);
1053#endif
1054
1055 switch (codecId)
1056 {
1057 case RDPGFX_CODECID_UNCOMPRESSED:
1058 status = gdi_SurfaceCommand_Uncompressed(gdi, context, cmd);
1059 break;
1060
1061 case RDPGFX_CODECID_CAVIDEO:
1062 status = gdi_SurfaceCommand_RemoteFX(gdi, context, cmd);
1063 break;
1064
1065 case RDPGFX_CODECID_CLEARCODEC:
1066 status = gdi_SurfaceCommand_ClearCodec(gdi, context, cmd);
1067 break;
1068
1069 case RDPGFX_CODECID_PLANAR:
1070 status = gdi_SurfaceCommand_Planar(gdi, context, cmd);
1071 break;
1072
1073 case RDPGFX_CODECID_AVC420:
1074 status = gdi_SurfaceCommand_AVC420(gdi, context, cmd);
1075 break;
1076
1077 case RDPGFX_CODECID_AVC444v2:
1078 case RDPGFX_CODECID_AVC444:
1079 status = gdi_SurfaceCommand_AVC444(gdi, context, cmd);
1080 break;
1081
1082 case RDPGFX_CODECID_ALPHA:
1083 status = gdi_SurfaceCommand_Alpha(gdi, context, cmd);
1084 break;
1085
1086 case RDPGFX_CODECID_CAPROGRESSIVE:
1087 status = gdi_SurfaceCommand_Progressive(gdi, context, cmd);
1088 break;
1089
1090 case RDPGFX_CODECID_CAPROGRESSIVE_V2:
1091 WLog_WARN(TAG, "SurfaceCommand %s [0x%08" PRIX16 "] not implemented",
1092 rdpgfx_get_codec_id_string(codecId), codecId);
1093 break;
1094
1095 default:
1096 WLog_WARN(TAG, "Invalid SurfaceCommand %s [0x%08" PRIX16 "]",
1097 rdpgfx_get_codec_id_string(codecId), codecId);
1098 break;
1099 }
1100
1101 LeaveCriticalSection(&context->mux);
1102 return status;
1103}
1104
1110static UINT
1111gdi_DeleteEncodingContext(RdpgfxClientContext* context,
1112 const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
1113{
1114 WINPR_ASSERT(context);
1115 WINPR_ASSERT(deleteEncodingContext);
1116 WINPR_UNUSED(context);
1117 WINPR_UNUSED(deleteEncodingContext);
1118 return CHANNEL_RC_OK;
1119}
1120
1126static UINT gdi_CreateSurface(RdpgfxClientContext* context,
1127 const RDPGFX_CREATE_SURFACE_PDU* createSurface)
1128{
1129 UINT rc = ERROR_INTERNAL_ERROR;
1130 gdiGfxSurface* surface = NULL;
1131 rdpGdi* gdi = NULL;
1132 WINPR_ASSERT(context);
1133 WINPR_ASSERT(createSurface);
1134 gdi = (rdpGdi*)context->custom;
1135 WINPR_ASSERT(gdi);
1136 WINPR_ASSERT(gdi->context);
1137 EnterCriticalSection(&context->mux);
1138 surface = (gdiGfxSurface*)calloc(1, sizeof(gdiGfxSurface));
1139
1140 if (!surface)
1141 goto fail;
1142
1143 if (!freerdp_settings_get_bool(gdi->context->settings, FreeRDP_DeactivateClientDecoding))
1144 {
1145 WINPR_ASSERT(context->codecs);
1146 surface->codecs = context->codecs;
1147
1148 if (!surface->codecs)
1149 {
1150 free(surface);
1151 goto fail;
1152 }
1153 }
1154
1155 surface->surfaceId = createSurface->surfaceId;
1156 surface->width = gfx_align_scanline(createSurface->width, 16);
1157 surface->height = gfx_align_scanline(createSurface->height, 16);
1158 surface->mappedWidth = createSurface->width;
1159 surface->mappedHeight = createSurface->height;
1160 surface->outputTargetWidth = createSurface->width;
1161 surface->outputTargetHeight = createSurface->height;
1162
1163 switch (createSurface->pixelFormat)
1164 {
1165 case GFX_PIXEL_FORMAT_ARGB_8888:
1166 surface->format = PIXEL_FORMAT_BGRA32;
1167 break;
1168
1169 case GFX_PIXEL_FORMAT_XRGB_8888:
1170 surface->format = PIXEL_FORMAT_BGRX32;
1171 break;
1172
1173 default:
1174 free(surface);
1175 goto fail;
1176 }
1177
1178 surface->scanline = gfx_align_scanline(surface->width * 4UL, 16);
1179 surface->data = (BYTE*)winpr_aligned_malloc(1ull * surface->scanline * surface->height, 16);
1180
1181 if (!surface->data)
1182 {
1183 free(surface);
1184 goto fail;
1185 }
1186
1187 memset(surface->data, 0xFF, (size_t)surface->scanline * surface->height);
1188 region16_init(&surface->invalidRegion);
1189
1190 WINPR_ASSERT(context->SetSurfaceData);
1191 rc = context->SetSurfaceData(context, surface->surfaceId, (void*)surface);
1192fail:
1193 LeaveCriticalSection(&context->mux);
1194 return rc;
1195}
1196
1202static UINT gdi_DeleteSurface(RdpgfxClientContext* context,
1203 const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
1204{
1205 UINT rc = CHANNEL_RC_OK;
1206 UINT res = ERROR_INTERNAL_ERROR;
1207 rdpCodecs* codecs = NULL;
1208 gdiGfxSurface* surface = NULL;
1209 EnterCriticalSection(&context->mux);
1210
1211 WINPR_ASSERT(context->GetSurfaceData);
1212 surface = (gdiGfxSurface*)context->GetSurfaceData(context, deleteSurface->surfaceId);
1213
1214 if (surface)
1215 {
1216 if (surface->windowMapped)
1217 rc = IFCALLRESULT(CHANNEL_RC_OK, context->UnmapWindowForSurface, context,
1218 surface->windowId);
1219
1220#ifdef WITH_GFX_H264
1221 h264_context_free(surface->h264);
1222#endif
1223 region16_uninit(&surface->invalidRegion);
1224 codecs = surface->codecs;
1225 winpr_aligned_free(surface->data);
1226 free(surface);
1227 }
1228
1229 WINPR_ASSERT(context->SetSurfaceData);
1230 res = context->SetSurfaceData(context, deleteSurface->surfaceId, NULL);
1231 if (res)
1232 rc = res;
1233
1234 if (codecs && codecs->progressive)
1235 progressive_delete_surface_context(codecs->progressive, deleteSurface->surfaceId);
1236
1237 LeaveCriticalSection(&context->mux);
1238 return rc;
1239}
1240
1241static BOOL intersect_rect(const RECTANGLE_16* rect, const gdiGfxSurface* surface,
1242 RECTANGLE_16* prect)
1243{
1244 WINPR_ASSERT(rect);
1245 WINPR_ASSERT(surface);
1246 WINPR_ASSERT(prect);
1247
1248 if (rect->left > rect->right)
1249 return FALSE;
1250 if (rect->left > surface->width)
1251 return FALSE;
1252 if (rect->top > rect->bottom)
1253 return FALSE;
1254 if (rect->top > surface->height)
1255 return FALSE;
1256 prect->left = rect->left;
1257 prect->top = rect->top;
1258
1259 prect->right = MIN(rect->right, WINPR_ASSERTING_INT_CAST(UINT16, surface->width));
1260 prect->bottom = MIN(rect->bottom, WINPR_ASSERTING_INT_CAST(UINT16, surface->height));
1261 return TRUE;
1262}
1263
1269static UINT gdi_SolidFill(RdpgfxClientContext* context, const RDPGFX_SOLID_FILL_PDU* solidFill)
1270{
1271 UINT status = ERROR_INTERNAL_ERROR;
1272 BYTE a = 0xff;
1273 RECTANGLE_16 invalidRect = { 0 };
1274 rdpGdi* gdi = (rdpGdi*)context->custom;
1275
1276 EnterCriticalSection(&context->mux);
1277
1278 WINPR_ASSERT(context->GetSurfaceData);
1279 gdiGfxSurface* surface = (gdiGfxSurface*)context->GetSurfaceData(context, solidFill->surfaceId);
1280
1281 if (!surface)
1282 goto fail;
1283
1284 const BYTE b = solidFill->fillPixel.B;
1285 const BYTE g = solidFill->fillPixel.G;
1286 const BYTE r = solidFill->fillPixel.R;
1287
1288 /* [MS-RDPEGFX] 3.3.5.4 Processing an RDPGFX_SOLIDFILL_PDU message
1289 * https://learn.microsoft.com/en-us/windows/win32/gdi/binary-raster-operations
1290 *
1291 * this sounds like the alpha value is always ignored.
1292 */
1293
1294 const UINT32 color = FreeRDPGetColor(surface->format, r, g, b, a);
1295
1296 for (UINT16 index = 0; index < solidFill->fillRectCount; index++)
1297 {
1298 const RECTANGLE_16* rect = &(solidFill->fillRects[index]);
1299
1300 if (!intersect_rect(rect, surface, &invalidRect))
1301 goto fail;
1302
1303 const UINT32 nWidth = invalidRect.right - invalidRect.left;
1304 const UINT32 nHeight = invalidRect.bottom - invalidRect.top;
1305
1306 if (!freerdp_image_fill(surface->data, surface->format, surface->scanline, invalidRect.left,
1307 invalidRect.top, nWidth, nHeight, color))
1308 goto fail;
1309
1310 region16_union_rect(&(surface->invalidRegion), &(surface->invalidRegion), &invalidRect);
1311 }
1312
1313 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context, surface->surfaceId,
1314 solidFill->fillRectCount, solidFill->fillRects);
1315
1316 if (status != CHANNEL_RC_OK)
1317 goto fail;
1318
1319 LeaveCriticalSection(&context->mux);
1320
1321 return gdi_interFrameUpdate(gdi, context);
1322fail:
1323 LeaveCriticalSection(&context->mux);
1324 return status;
1325}
1326
1332static UINT gdi_SurfaceToSurface(RdpgfxClientContext* context,
1333 const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
1334{
1335 UINT status = ERROR_INTERNAL_ERROR;
1336 BOOL sameSurface = 0;
1337 UINT32 nWidth = 0;
1338 UINT32 nHeight = 0;
1339 const RECTANGLE_16* rectSrc = NULL;
1340 RECTANGLE_16 invalidRect;
1341 gdiGfxSurface* surfaceSrc = NULL;
1342 gdiGfxSurface* surfaceDst = NULL;
1343 rdpGdi* gdi = (rdpGdi*)context->custom;
1344 EnterCriticalSection(&context->mux);
1345 rectSrc = &(surfaceToSurface->rectSrc);
1346
1347 WINPR_ASSERT(context->GetSurfaceData);
1348 surfaceSrc = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdSrc);
1349 sameSurface =
1350 (surfaceToSurface->surfaceIdSrc == surfaceToSurface->surfaceIdDest) ? TRUE : FALSE;
1351
1352 if (!sameSurface)
1353 surfaceDst =
1354 (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToSurface->surfaceIdDest);
1355 else
1356 surfaceDst = surfaceSrc;
1357
1358 if (!surfaceSrc || !surfaceDst)
1359 goto fail;
1360
1361 if (!is_rect_valid(rectSrc, surfaceSrc->width, surfaceSrc->height))
1362 goto fail;
1363
1364 nWidth = rectSrc->right - rectSrc->left;
1365 nHeight = rectSrc->bottom - rectSrc->top;
1366
1367 for (UINT16 index = 0; index < surfaceToSurface->destPtsCount; index++)
1368 {
1369 const RDPGFX_POINT16* destPt = &surfaceToSurface->destPts[index];
1370 const RECTANGLE_16 rect = { destPt->x, destPt->y,
1371 (UINT16)MIN(UINT16_MAX, destPt->x + nWidth),
1372 (UINT16)MIN(UINT16_MAX, destPt->y + nHeight) };
1373 if (!is_rect_valid(&rect, surfaceDst->width, surfaceDst->height))
1374 goto fail;
1375
1376 if (!freerdp_image_copy(surfaceDst->data, surfaceDst->format, surfaceDst->scanline,
1377 destPt->x, destPt->y, nWidth, nHeight, surfaceSrc->data,
1378 surfaceSrc->format, surfaceSrc->scanline, rectSrc->left,
1379 rectSrc->top, NULL, FREERDP_FLIP_NONE))
1380 goto fail;
1381
1382 invalidRect = rect;
1383 region16_union_rect(&surfaceDst->invalidRegion, &surfaceDst->invalidRegion, &invalidRect);
1384 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
1385 surfaceDst->surfaceId, 1, &invalidRect);
1386
1387 if (status != CHANNEL_RC_OK)
1388 goto fail;
1389 }
1390
1391 LeaveCriticalSection(&context->mux);
1392
1393 return gdi_interFrameUpdate(gdi, context);
1394fail:
1395 LeaveCriticalSection(&context->mux);
1396 return status;
1397}
1398
1399static void gdi_GfxCacheEntryFree(gdiGfxCacheEntry* entry)
1400{
1401 if (!entry)
1402 return;
1403 free(entry->data);
1404 free(entry);
1405}
1406
1407static gdiGfxCacheEntry* gdi_GfxCacheEntryNew(UINT64 cacheKey, UINT32 width, UINT32 height,
1408 UINT32 format)
1409{
1410 gdiGfxCacheEntry* cacheEntry = (gdiGfxCacheEntry*)calloc(1, sizeof(gdiGfxCacheEntry));
1411 if (!cacheEntry)
1412 goto fail;
1413
1414 cacheEntry->cacheKey = cacheKey;
1415 cacheEntry->width = width;
1416 cacheEntry->height = height;
1417 cacheEntry->format = format;
1418 cacheEntry->scanline = gfx_align_scanline(cacheEntry->width * 4, 16);
1419
1420 if ((cacheEntry->width > 0) && (cacheEntry->height > 0))
1421 {
1422 cacheEntry->data = (BYTE*)calloc(cacheEntry->height, cacheEntry->scanline);
1423
1424 if (!cacheEntry->data)
1425 goto fail;
1426 }
1427 return cacheEntry;
1428fail:
1429 gdi_GfxCacheEntryFree(cacheEntry);
1430 return NULL;
1431}
1432
1438static UINT gdi_SurfaceToCache(RdpgfxClientContext* context,
1439 const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
1440{
1441 const RECTANGLE_16* rect = NULL;
1442 gdiGfxSurface* surface = NULL;
1443 gdiGfxCacheEntry* cacheEntry = NULL;
1444 UINT rc = ERROR_INTERNAL_ERROR;
1445 EnterCriticalSection(&context->mux);
1446 rect = &(surfaceToCache->rectSrc);
1447
1448 WINPR_ASSERT(context->GetSurfaceData);
1449 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToCache->surfaceId);
1450
1451 if (!surface)
1452 goto fail;
1453
1454 if (!is_rect_valid(rect, surface->width, surface->height))
1455 goto fail;
1456
1457 cacheEntry = gdi_GfxCacheEntryNew(surfaceToCache->cacheKey, (UINT32)(rect->right - rect->left),
1458 (UINT32)(rect->bottom - rect->top), surface->format);
1459
1460 if (!cacheEntry)
1461 goto fail;
1462
1463 if (!cacheEntry->data)
1464 goto fail;
1465
1466 if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
1467 0, 0, cacheEntry->width, cacheEntry->height, surface->data,
1468 surface->format, surface->scanline, rect->left, rect->top,
1469 NULL, FREERDP_FLIP_NONE))
1470 goto fail;
1471
1472 RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { surfaceToCache->cacheSlot };
1473 WINPR_ASSERT(context->EvictCacheEntry);
1474 context->EvictCacheEntry(context, &evict);
1475
1476 WINPR_ASSERT(context->SetCacheSlotData);
1477 rc = context->SetCacheSlotData(context, surfaceToCache->cacheSlot, (void*)cacheEntry);
1478fail:
1479 if (rc != CHANNEL_RC_OK)
1480 gdi_GfxCacheEntryFree(cacheEntry);
1481 LeaveCriticalSection(&context->mux);
1482 return rc;
1483}
1484
1490static UINT gdi_CacheToSurface(RdpgfxClientContext* context,
1491 const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
1492{
1493 UINT status = ERROR_INTERNAL_ERROR;
1494 gdiGfxSurface* surface = NULL;
1495 gdiGfxCacheEntry* cacheEntry = NULL;
1496 RECTANGLE_16 invalidRect;
1497 rdpGdi* gdi = (rdpGdi*)context->custom;
1498
1499 EnterCriticalSection(&context->mux);
1500
1501 WINPR_ASSERT(context->GetSurfaceData);
1502 surface = (gdiGfxSurface*)context->GetSurfaceData(context, cacheToSurface->surfaceId);
1503
1504 WINPR_ASSERT(context->GetCacheSlotData);
1505 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheToSurface->cacheSlot);
1506
1507 if (!surface || !cacheEntry)
1508 goto fail;
1509
1510 for (UINT16 index = 0; index < cacheToSurface->destPtsCount; index++)
1511 {
1512 const RDPGFX_POINT16* destPt = &cacheToSurface->destPts[index];
1513 const RECTANGLE_16 rect = { destPt->x, destPt->y,
1514 (UINT16)MIN(UINT16_MAX, destPt->x + cacheEntry->width),
1515 (UINT16)MIN(UINT16_MAX, destPt->y + cacheEntry->height) };
1516
1517 if (rectangle_is_empty(&rect))
1518 continue;
1519
1520 if (!is_rect_valid(&rect, surface->width, surface->height))
1521 goto fail;
1522
1523 if (!freerdp_image_copy_no_overlap(surface->data, surface->format, surface->scanline,
1524 destPt->x, destPt->y, cacheEntry->width,
1525 cacheEntry->height, cacheEntry->data, cacheEntry->format,
1526 cacheEntry->scanline, 0, 0, NULL, FREERDP_FLIP_NONE))
1527 goto fail;
1528
1529 invalidRect = rect;
1530 region16_union_rect(&surface->invalidRegion, &surface->invalidRegion, &invalidRect);
1531 status = IFCALLRESULT(CHANNEL_RC_OK, context->UpdateSurfaceArea, context,
1532 surface->surfaceId, 1, &invalidRect);
1533
1534 if (status != CHANNEL_RC_OK)
1535 goto fail;
1536 }
1537
1538 LeaveCriticalSection(&context->mux);
1539
1540 return gdi_interFrameUpdate(gdi, context);
1541
1542fail:
1543 LeaveCriticalSection(&context->mux);
1544 return status;
1545}
1546
1552static UINT gdi_CacheImportReply(RdpgfxClientContext* context,
1553 const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
1554{
1555 UINT16 count = 0;
1556 const UINT16* slots = NULL;
1557 UINT error = CHANNEL_RC_OK;
1558
1559 slots = cacheImportReply->cacheSlots;
1560 count = cacheImportReply->importedEntriesCount;
1561
1562 for (UINT16 index = 0; index < count; index++)
1563 {
1564 UINT16 cacheSlot = slots[index];
1565
1566 if (cacheSlot == 0)
1567 continue;
1568
1569 WINPR_ASSERT(context->GetCacheSlotData);
1570 gdiGfxCacheEntry* cacheEntry =
1571 (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
1572
1573 if (cacheEntry)
1574 continue;
1575
1576 cacheEntry = gdi_GfxCacheEntryNew(cacheSlot, 0, 0, PIXEL_FORMAT_BGRX32);
1577
1578 if (!cacheEntry)
1579 return ERROR_INTERNAL_ERROR;
1580
1581 WINPR_ASSERT(context->SetCacheSlotData);
1582 error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
1583
1584 if (error)
1585 {
1586 WLog_ERR(TAG, "CacheImportReply: SetCacheSlotData failed with error %" PRIu32 "",
1587 error);
1588 gdi_GfxCacheEntryFree(cacheEntry);
1589 break;
1590 }
1591 }
1592
1593 return error;
1594}
1595
1596static UINT gdi_ImportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
1597 const PERSISTENT_CACHE_ENTRY* importCacheEntry)
1598{
1599 UINT error = ERROR_INTERNAL_ERROR;
1600 gdiGfxCacheEntry* cacheEntry = NULL;
1601
1602 if (cacheSlot == 0)
1603 return CHANNEL_RC_OK;
1604
1605 cacheEntry = gdi_GfxCacheEntryNew(importCacheEntry->key64, importCacheEntry->width,
1606 importCacheEntry->height, PIXEL_FORMAT_BGRX32);
1607
1608 if (!cacheEntry)
1609 goto fail;
1610
1611 if (!freerdp_image_copy_no_overlap(cacheEntry->data, cacheEntry->format, cacheEntry->scanline,
1612 0, 0, cacheEntry->width, cacheEntry->height,
1613 importCacheEntry->data, PIXEL_FORMAT_BGRX32, 0, 0, 0, NULL,
1614 FREERDP_FLIP_NONE))
1615 goto fail;
1616
1617 RDPGFX_EVICT_CACHE_ENTRY_PDU evict = { cacheSlot };
1618 WINPR_ASSERT(context->EvictCacheEntry);
1619 error = context->EvictCacheEntry(context, &evict);
1620 if (error != CHANNEL_RC_OK)
1621 goto fail;
1622
1623 WINPR_ASSERT(context->SetCacheSlotData);
1624 error = context->SetCacheSlotData(context, cacheSlot, (void*)cacheEntry);
1625
1626fail:
1627 if (error)
1628 {
1629 gdi_GfxCacheEntryFree(cacheEntry);
1630 WLog_ERR(TAG, "ImportCacheEntry: SetCacheSlotData failed with error %" PRIu32 "", error);
1631 }
1632
1633 return error;
1634}
1635
1636static UINT gdi_ExportCacheEntry(RdpgfxClientContext* context, UINT16 cacheSlot,
1637 PERSISTENT_CACHE_ENTRY* exportCacheEntry)
1638{
1639 gdiGfxCacheEntry* cacheEntry = NULL;
1640
1641 WINPR_ASSERT(context->GetCacheSlotData);
1642 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, cacheSlot);
1643
1644 if (cacheEntry)
1645 {
1646 exportCacheEntry->key64 = cacheEntry->cacheKey;
1647 exportCacheEntry->width = (UINT16)MIN(UINT16_MAX, cacheEntry->width);
1648 exportCacheEntry->height = (UINT16)MIN(UINT16_MAX, cacheEntry->height);
1649 exportCacheEntry->size = cacheEntry->width * cacheEntry->height * 4;
1650 exportCacheEntry->flags = 0;
1651 exportCacheEntry->data = cacheEntry->data;
1652 return CHANNEL_RC_OK;
1653 }
1654
1655 return ERROR_NOT_FOUND;
1656}
1657
1663static UINT gdi_EvictCacheEntry(RdpgfxClientContext* context,
1664 const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
1665{
1666 gdiGfxCacheEntry* cacheEntry = NULL;
1667 UINT rc = ERROR_NOT_FOUND;
1668
1669 WINPR_ASSERT(context);
1670 WINPR_ASSERT(evictCacheEntry);
1671
1672 EnterCriticalSection(&context->mux);
1673
1674 WINPR_ASSERT(context->GetCacheSlotData);
1675 cacheEntry = (gdiGfxCacheEntry*)context->GetCacheSlotData(context, evictCacheEntry->cacheSlot);
1676
1677 gdi_GfxCacheEntryFree(cacheEntry);
1678
1679 WINPR_ASSERT(context->SetCacheSlotData);
1680 rc = context->SetCacheSlotData(context, evictCacheEntry->cacheSlot, NULL);
1681 LeaveCriticalSection(&context->mux);
1682 return rc;
1683}
1684
1690static UINT gdi_MapSurfaceToOutput(RdpgfxClientContext* context,
1691 const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
1692{
1693 UINT rc = ERROR_INTERNAL_ERROR;
1694 gdiGfxSurface* surface = NULL;
1695 EnterCriticalSection(&context->mux);
1696
1697 WINPR_ASSERT(context->GetSurfaceData);
1698 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
1699
1700 if (!surface)
1701 goto fail;
1702
1703 if (surface->windowMapped)
1704 {
1705 WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
1706 goto fail;
1707 }
1708
1709 surface->outputMapped = TRUE;
1710 surface->outputOriginX = surfaceToOutput->outputOriginX;
1711 surface->outputOriginY = surfaceToOutput->outputOriginY;
1712 surface->outputTargetWidth = surface->mappedWidth;
1713 surface->outputTargetHeight = surface->mappedHeight;
1714 region16_clear(&surface->invalidRegion);
1715 rc = CHANNEL_RC_OK;
1716fail:
1717 LeaveCriticalSection(&context->mux);
1718 return rc;
1719}
1720
1721static UINT
1722gdi_MapSurfaceToScaledOutput(RdpgfxClientContext* context,
1723 const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* surfaceToOutput)
1724{
1725 UINT rc = ERROR_INTERNAL_ERROR;
1726 gdiGfxSurface* surface = NULL;
1727 EnterCriticalSection(&context->mux);
1728
1729 WINPR_ASSERT(context->GetSurfaceData);
1730 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToOutput->surfaceId);
1731
1732 if (!surface)
1733 goto fail;
1734
1735 if (surface->windowMapped)
1736 {
1737 WLog_WARN(TAG, "surface already windowMapped when trying to set outputMapped");
1738 goto fail;
1739 }
1740
1741 surface->outputMapped = TRUE;
1742 surface->outputOriginX = surfaceToOutput->outputOriginX;
1743 surface->outputOriginY = surfaceToOutput->outputOriginY;
1744 surface->outputTargetWidth = surfaceToOutput->targetWidth;
1745 surface->outputTargetHeight = surfaceToOutput->targetHeight;
1746 region16_clear(&surface->invalidRegion);
1747 rc = CHANNEL_RC_OK;
1748fail:
1749 LeaveCriticalSection(&context->mux);
1750 return rc;
1751}
1752
1758static UINT gdi_MapSurfaceToWindow(RdpgfxClientContext* context,
1759 const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
1760{
1761 UINT rc = ERROR_INTERNAL_ERROR;
1762 gdiGfxSurface* surface = NULL;
1763 EnterCriticalSection(&context->mux);
1764
1765 WINPR_ASSERT(context->GetSurfaceData);
1766 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
1767
1768 if (!surface)
1769 goto fail;
1770
1771 if (surface->outputMapped)
1772 {
1773 WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
1774 goto fail;
1775 }
1776
1777 if (surface->windowMapped)
1778 {
1779 if (surface->windowId != surfaceToWindow->windowId)
1780 {
1781 WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
1782 surface->windowId, surfaceToWindow->windowId);
1783 goto fail;
1784 }
1785 }
1786 surface->windowMapped = TRUE;
1787
1788 surface->windowId = surfaceToWindow->windowId;
1789 surface->mappedWidth = surfaceToWindow->mappedWidth;
1790 surface->mappedHeight = surfaceToWindow->mappedHeight;
1791 surface->outputTargetWidth = surfaceToWindow->mappedWidth;
1792 surface->outputTargetHeight = surfaceToWindow->mappedHeight;
1793 rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
1794 surfaceToWindow->surfaceId, surfaceToWindow->windowId);
1795fail:
1796 LeaveCriticalSection(&context->mux);
1797 return rc;
1798}
1799
1800static UINT
1801gdi_MapSurfaceToScaledWindow(RdpgfxClientContext* context,
1802 const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* surfaceToWindow)
1803{
1804 UINT rc = ERROR_INTERNAL_ERROR;
1805 gdiGfxSurface* surface = NULL;
1806 EnterCriticalSection(&context->mux);
1807
1808 WINPR_ASSERT(context->GetSurfaceData);
1809 surface = (gdiGfxSurface*)context->GetSurfaceData(context, surfaceToWindow->surfaceId);
1810
1811 if (!surface)
1812 goto fail;
1813
1814 if (surface->outputMapped)
1815 {
1816 WLog_WARN(TAG, "surface already outputMapped when trying to set windowMapped");
1817 goto fail;
1818 }
1819
1820 if (surface->windowMapped)
1821 {
1822 if (surface->windowId != surfaceToWindow->windowId)
1823 {
1824 WLog_WARN(TAG, "surface windowId mismatch, has %" PRIu64 ", expected %" PRIu64,
1825 surface->windowId, surfaceToWindow->windowId);
1826 goto fail;
1827 }
1828 }
1829 surface->windowMapped = TRUE;
1830
1831 surface->windowId = surfaceToWindow->windowId;
1832 surface->mappedWidth = surfaceToWindow->mappedWidth;
1833 surface->mappedHeight = surfaceToWindow->mappedHeight;
1834 surface->outputTargetWidth = surfaceToWindow->targetWidth;
1835 surface->outputTargetHeight = surfaceToWindow->targetHeight;
1836 rc = IFCALLRESULT(CHANNEL_RC_OK, context->MapWindowForSurface, context,
1837 surfaceToWindow->surfaceId, surfaceToWindow->windowId);
1838fail:
1839 LeaveCriticalSection(&context->mux);
1840 return rc;
1841}
1842
1843BOOL gdi_graphics_pipeline_init(rdpGdi* gdi, RdpgfxClientContext* gfx)
1844{
1845 return gdi_graphics_pipeline_init_ex(gdi, gfx, NULL, NULL, NULL);
1846}
1847
1848BOOL gdi_graphics_pipeline_init_ex(rdpGdi* gdi, RdpgfxClientContext* gfx,
1849 pcRdpgfxMapWindowForSurface map,
1850 pcRdpgfxUnmapWindowForSurface unmap,
1851 pcRdpgfxUpdateSurfaceArea update)
1852{
1853 if (!gdi || !gfx || !gdi->context || !gdi->context->settings)
1854 return FALSE;
1855
1856 rdpContext* context = gdi->context;
1857 rdpSettings* settings = context->settings;
1858
1859 gdi->gfx = gfx;
1860 gfx->custom = (void*)gdi;
1861 gfx->ResetGraphics = gdi_ResetGraphics;
1862 gfx->StartFrame = gdi_StartFrame;
1863 gfx->EndFrame = gdi_EndFrame;
1864 gfx->SurfaceCommand = gdi_SurfaceCommand;
1865 gfx->DeleteEncodingContext = gdi_DeleteEncodingContext;
1866 gfx->CreateSurface = gdi_CreateSurface;
1867 gfx->DeleteSurface = gdi_DeleteSurface;
1868 gfx->SolidFill = gdi_SolidFill;
1869 gfx->SurfaceToSurface = gdi_SurfaceToSurface;
1870 gfx->SurfaceToCache = gdi_SurfaceToCache;
1871 gfx->CacheToSurface = gdi_CacheToSurface;
1872 gfx->CacheImportReply = gdi_CacheImportReply;
1873 gfx->ImportCacheEntry = gdi_ImportCacheEntry;
1874 gfx->ExportCacheEntry = gdi_ExportCacheEntry;
1875 gfx->EvictCacheEntry = gdi_EvictCacheEntry;
1876 gfx->MapSurfaceToOutput = gdi_MapSurfaceToOutput;
1877 gfx->MapSurfaceToWindow = gdi_MapSurfaceToWindow;
1878 gfx->MapSurfaceToScaledOutput = gdi_MapSurfaceToScaledOutput;
1879 gfx->MapSurfaceToScaledWindow = gdi_MapSurfaceToScaledWindow;
1880 gfx->UpdateSurfaces = gdi_UpdateSurfaces;
1881 gfx->MapWindowForSurface = map;
1882 gfx->UnmapWindowForSurface = unmap;
1883 gfx->UpdateSurfaceArea = update;
1884
1885 if (!freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
1886 {
1887 const UINT32 w = freerdp_settings_get_uint32(settings, FreeRDP_DesktopWidth);
1888 const UINT32 h = freerdp_settings_get_uint32(settings, FreeRDP_DesktopHeight);
1889 const UINT32 flags = freerdp_settings_get_uint32(settings, FreeRDP_ThreadingFlags);
1890
1891 gfx->codecs = freerdp_client_codecs_new(flags);
1892 if (!gfx->codecs)
1893 return FALSE;
1894 if (!freerdp_client_codecs_prepare(gfx->codecs, FREERDP_CODEC_ALL, w, h))
1895 return FALSE;
1896 }
1897 InitializeCriticalSection(&gfx->mux);
1898 PROFILER_CREATE(gfx->SurfaceProfiler, "GFX-PROFILER")
1899
1900
1906 gdi->graphicsReset = TRUE;
1907 if (freerdp_settings_get_bool(settings, FreeRDP_DeactivateClientDecoding))
1908 {
1909 gfx->UpdateSurfaceArea = NULL;
1910 gfx->UpdateSurfaces = NULL;
1911 gfx->SurfaceCommand = NULL;
1912 }
1913
1914 return TRUE;
1915}
1916
1917void gdi_graphics_pipeline_uninit(rdpGdi* gdi, RdpgfxClientContext* gfx)
1918{
1919 if (gdi)
1920 gdi->gfx = NULL;
1921
1922 if (!gfx)
1923 return;
1924
1925 gfx->custom = NULL;
1926 freerdp_client_codecs_free(gfx->codecs);
1927 gfx->codecs = NULL;
1928 DeleteCriticalSection(&gfx->mux);
1929 PROFILER_PRINT_HEADER
1930 PROFILER_PRINT(gfx->SurfaceProfiler)
1931 PROFILER_PRINT_FOOTER
1932 PROFILER_FREE(gfx->SurfaceProfiler)
1933}
1934
1935const char* rdpgfx_caps_version_str(UINT32 capsVersion)
1936{
1937 switch (capsVersion)
1938 {
1939 case RDPGFX_CAPVERSION_8:
1940 return "RDPGFX_CAPVERSION_8";
1941 case RDPGFX_CAPVERSION_81:
1942 return "RDPGFX_CAPVERSION_81";
1943 case RDPGFX_CAPVERSION_10:
1944 return "RDPGFX_CAPVERSION_10";
1945 case RDPGFX_CAPVERSION_101:
1946 return "RDPGFX_CAPVERSION_101";
1947 case RDPGFX_CAPVERSION_102:
1948 return "RDPGFX_CAPVERSION_102";
1949 case RDPGFX_CAPVERSION_103:
1950 return "RDPGFX_CAPVERSION_103";
1951 case RDPGFX_CAPVERSION_104:
1952 return "RDPGFX_CAPVERSION_104";
1953 case RDPGFX_CAPVERSION_105:
1954 return "RDPGFX_CAPVERSION_105";
1955 case RDPGFX_CAPVERSION_106:
1956 return "RDPGFX_CAPVERSION_106";
1957 case RDPGFX_CAPVERSION_106_ERR:
1958 return "RDPGFX_CAPVERSION_106_ERR";
1959 case RDPGFX_CAPVERSION_107:
1960 return "RDPGFX_CAPVERSION_107";
1961 default:
1962 return "RDPGFX_CAPVERSION_UNKNOWN";
1963 }
1964}
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