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