VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/FrameBufferBltLib/FrameBufferBltLib.c

Last change on this file was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 24.0 KB
Line 
1/** @file
2 FrameBufferBltLib - Library to perform blt operations on a frame buffer.
3
4 Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include <Uefi/UefiBaseType.h>
10#include <Protocol/GraphicsOutput.h>
11
12#include <Library/BaseLib.h>
13#include <Library/BaseMemoryLib.h>
14#include <Library/DebugLib.h>
15#include <Library/FrameBufferBltLib.h>
16
17struct FRAME_BUFFER_CONFIGURE {
18 UINT32 PixelsPerScanLine;
19 UINT32 BytesPerPixel;
20 UINT32 Width;
21 UINT32 Height;
22 UINT8 *FrameBuffer;
23 EFI_GRAPHICS_PIXEL_FORMAT PixelFormat;
24 EFI_PIXEL_BITMASK PixelMasks;
25 INT8 PixelShl[4]; // R-G-B-Rsvd
26 INT8 PixelShr[4]; // R-G-B-Rsvd
27 UINT8 LineBuffer[0];
28};
29
30CONST EFI_PIXEL_BITMASK mRgbPixelMasks = {
31 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
32};
33
34CONST EFI_PIXEL_BITMASK mBgrPixelMasks = {
35 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000
36};
37
38/**
39 Initialize the bit mask in frame buffer configure.
40
41 @param BitMask The bit mask of pixel.
42 @param BytesPerPixel Size in bytes of pixel.
43 @param PixelShl Left shift array.
44 @param PixelShr Right shift array.
45**/
46VOID
47FrameBufferBltLibConfigurePixelFormat (
48 IN CONST EFI_PIXEL_BITMASK *BitMask,
49 OUT UINT32 *BytesPerPixel,
50 OUT INT8 *PixelShl,
51 OUT INT8 *PixelShr
52 )
53{
54 UINT8 Index;
55 UINT32 *Masks;
56 UINT32 MergedMasks;
57
58 ASSERT (BytesPerPixel != NULL);
59
60 MergedMasks = 0;
61 Masks = (UINT32 *)BitMask;
62 for (Index = 0; Index < 3; Index++) {
63 ASSERT ((MergedMasks & Masks[Index]) == 0);
64
65 PixelShl[Index] = (INT8)HighBitSet32 (Masks[Index]) - 23 + (Index * 8);
66 if (PixelShl[Index] < 0) {
67 PixelShr[Index] = -PixelShl[Index];
68 PixelShl[Index] = 0;
69 } else {
70 PixelShr[Index] = 0;
71 }
72
73 DEBUG ((
74 DEBUG_INFO,
75 "%d: shl:%d shr:%d mask:%x\n",
76 Index,
77 PixelShl[Index],
78 PixelShr[Index],
79 Masks[Index]
80 ));
81
82 MergedMasks = (UINT32)(MergedMasks | Masks[Index]);
83 }
84
85 MergedMasks = (UINT32)(MergedMasks | Masks[3]);
86
87 ASSERT (MergedMasks != 0);
88 *BytesPerPixel = (UINT32)((HighBitSet32 (MergedMasks) + 7) / 8);
89 DEBUG ((DEBUG_INFO, "Bytes per pixel: %d\n", *BytesPerPixel));
90}
91
92/**
93 Create the configuration for a video frame buffer.
94
95 The configuration is returned in the caller provided buffer.
96
97 @param[in] FrameBuffer Pointer to the start of the frame buffer.
98 @param[in] FrameBufferInfo Describes the frame buffer characteristics.
99 @param[in,out] Configure The created configuration information.
100 @param[in,out] ConfigureSize Size of the configuration information.
101
102 @retval RETURN_SUCCESS The configuration was successful created.
103 @retval RETURN_BUFFER_TOO_SMALL The Configure is to too small. The required
104 size is returned in ConfigureSize.
105 @retval RETURN_UNSUPPORTED The requested mode is not supported by
106 this implementaion.
107
108**/
109RETURN_STATUS
110EFIAPI
111FrameBufferBltConfigure (
112 IN VOID *FrameBuffer,
113 IN EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *FrameBufferInfo,
114 IN OUT FRAME_BUFFER_CONFIGURE *Configure,
115 IN OUT UINTN *ConfigureSize
116 )
117{
118 CONST EFI_PIXEL_BITMASK *BitMask;
119 UINT32 BytesPerPixel;
120 INT8 PixelShl[4];
121 INT8 PixelShr[4];
122
123 if (ConfigureSize == NULL) {
124 return RETURN_INVALID_PARAMETER;
125 }
126
127 switch (FrameBufferInfo->PixelFormat) {
128 case PixelRedGreenBlueReserved8BitPerColor:
129 BitMask = &mRgbPixelMasks;
130 break;
131
132 case PixelBlueGreenRedReserved8BitPerColor:
133 BitMask = &mBgrPixelMasks;
134 break;
135
136 case PixelBitMask:
137 BitMask = &FrameBufferInfo->PixelInformation;
138 break;
139
140 case PixelBltOnly:
141 ASSERT (FrameBufferInfo->PixelFormat != PixelBltOnly);
142 return RETURN_UNSUPPORTED;
143
144 default:
145 ASSERT (FALSE);
146 return RETURN_INVALID_PARAMETER;
147 }
148
149 if (FrameBufferInfo->PixelsPerScanLine < FrameBufferInfo->HorizontalResolution) {
150 return RETURN_UNSUPPORTED;
151 }
152
153 FrameBufferBltLibConfigurePixelFormat (BitMask, &BytesPerPixel, PixelShl, PixelShr);
154
155 if (*ConfigureSize < sizeof (FRAME_BUFFER_CONFIGURE)
156 + FrameBufferInfo->HorizontalResolution * BytesPerPixel)
157 {
158 *ConfigureSize = sizeof (FRAME_BUFFER_CONFIGURE)
159 + FrameBufferInfo->HorizontalResolution * BytesPerPixel;
160 return RETURN_BUFFER_TOO_SMALL;
161 }
162
163 if (Configure == NULL) {
164 return RETURN_INVALID_PARAMETER;
165 }
166
167 CopyMem (&Configure->PixelMasks, BitMask, sizeof (*BitMask));
168 CopyMem (Configure->PixelShl, PixelShl, sizeof (PixelShl));
169 CopyMem (Configure->PixelShr, PixelShr, sizeof (PixelShr));
170 Configure->BytesPerPixel = BytesPerPixel;
171 Configure->PixelFormat = FrameBufferInfo->PixelFormat;
172 Configure->FrameBuffer = (UINT8 *)FrameBuffer;
173 Configure->Width = FrameBufferInfo->HorizontalResolution;
174 Configure->Height = FrameBufferInfo->VerticalResolution;
175 Configure->PixelsPerScanLine = FrameBufferInfo->PixelsPerScanLine;
176
177 return RETURN_SUCCESS;
178}
179
180/**
181 Performs a UEFI Graphics Output Protocol Blt Video Fill.
182
183 @param[in] Configure Pointer to a configuration which was successfully
184 created by FrameBufferBltConfigure ().
185 @param[in] Color Color to fill the region with.
186 @param[in] DestinationX X location to start fill operation.
187 @param[in] DestinationY Y location to start fill operation.
188 @param[in] Width Width (in pixels) to fill.
189 @param[in] Height Height to fill.
190
191 @retval RETURN_INVALID_PARAMETER Invalid parameter was passed in.
192 @retval RETURN_SUCCESS The video was filled successfully.
193
194**/
195EFI_STATUS
196FrameBufferBltLibVideoFill (
197 IN FRAME_BUFFER_CONFIGURE *Configure,
198 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Color,
199 IN UINTN DestinationX,
200 IN UINTN DestinationY,
201 IN UINTN Width,
202 IN UINTN Height
203 )
204{
205 UINTN IndexX;
206 UINTN IndexY;
207 UINT8 *Destination;
208 UINT8 Uint8;
209 UINT32 Uint32;
210 UINT64 WideFill;
211 BOOLEAN UseWideFill;
212 BOOLEAN LineBufferReady;
213 UINTN Offset;
214 UINTN WidthInBytes;
215 UINTN SizeInBytes;
216
217 //
218 // BltBuffer to Video: Source is BltBuffer, destination is Video
219 //
220 if (DestinationY + Height > Configure->Height) {
221 DEBUG ((DEBUG_VERBOSE, "VideoFill: Past screen (Y)\n"));
222 return RETURN_INVALID_PARAMETER;
223 }
224
225 if (DestinationX + Width > Configure->Width) {
226 DEBUG ((DEBUG_VERBOSE, "VideoFill: Past screen (X)\n"));
227 return RETURN_INVALID_PARAMETER;
228 }
229
230 if ((Width == 0) || (Height == 0)) {
231 DEBUG ((DEBUG_VERBOSE, "VideoFill: Width or Height is 0\n"));
232 return RETURN_INVALID_PARAMETER;
233 }
234
235 WidthInBytes = Width * Configure->BytesPerPixel;
236
237 Uint32 = *(UINT32 *)Color;
238 WideFill =
239 (UINT32)(
240 (((Uint32 << Configure->PixelShl[0]) >> Configure->PixelShr[0]) &
241 Configure->PixelMasks.RedMask) |
242 (((Uint32 << Configure->PixelShl[1]) >> Configure->PixelShr[1]) &
243 Configure->PixelMasks.GreenMask) |
244 (((Uint32 << Configure->PixelShl[2]) >> Configure->PixelShr[2]) &
245 Configure->PixelMasks.BlueMask)
246 );
247 DEBUG ((
248 DEBUG_VERBOSE,
249 "VideoFill: color=0x%x, wide-fill=0x%x\n",
250 Uint32,
251 WideFill
252 ));
253
254 //
255 // If the size of the pixel data evenly divides the sizeof
256 // WideFill, then a wide fill operation can be used
257 //
258 UseWideFill = TRUE;
259 if ((sizeof (WideFill) % Configure->BytesPerPixel) == 0) {
260 for (IndexX = Configure->BytesPerPixel; IndexX < sizeof (WideFill); IndexX++) {
261 ((UINT8 *)&WideFill)[IndexX] = ((UINT8 *)&WideFill)[IndexX % Configure->BytesPerPixel];
262 }
263 } else {
264 //
265 // If all the bytes in the pixel are the same value, then use
266 // a wide fill operation.
267 //
268 for (
269 IndexX = 1, Uint8 = ((UINT8 *)&WideFill)[0];
270 IndexX < Configure->BytesPerPixel;
271 IndexX++)
272 {
273 if (Uint8 != ((UINT8 *)&WideFill)[IndexX]) {
274 UseWideFill = FALSE;
275 break;
276 }
277 }
278
279 if (UseWideFill) {
280 SetMem (&WideFill, sizeof (WideFill), Uint8);
281 }
282 }
283
284 if (UseWideFill && (DestinationX == 0) && (Width == Configure->PixelsPerScanLine)) {
285 DEBUG ((DEBUG_VERBOSE, "VideoFill (wide, one-shot)\n"));
286 Offset = DestinationY * Configure->PixelsPerScanLine;
287 Offset = Configure->BytesPerPixel * Offset;
288 Destination = Configure->FrameBuffer + Offset;
289 SizeInBytes = WidthInBytes * Height;
290 if (SizeInBytes >= 8) {
291 SetMem32 (Destination, SizeInBytes & ~3, (UINT32)WideFill);
292 Destination += SizeInBytes & ~3;
293 SizeInBytes &= 3;
294 }
295
296 if (SizeInBytes > 0) {
297 SetMem (Destination, SizeInBytes, (UINT8)(UINTN)WideFill);
298 }
299 } else {
300 LineBufferReady = FALSE;
301 for (IndexY = DestinationY; IndexY < (Height + DestinationY); IndexY++) {
302 Offset = (IndexY * Configure->PixelsPerScanLine) + DestinationX;
303 Offset = Configure->BytesPerPixel * Offset;
304 Destination = Configure->FrameBuffer + Offset;
305
306 if (UseWideFill && (((UINTN)Destination & 7) == 0)) {
307 DEBUG ((DEBUG_VERBOSE, "VideoFill (wide)\n"));
308 SizeInBytes = WidthInBytes;
309 if (SizeInBytes >= 8) {
310 SetMem64 (Destination, SizeInBytes & ~7, WideFill);
311 Destination += SizeInBytes & ~7;
312 SizeInBytes &= 7;
313 }
314
315 if (SizeInBytes > 0) {
316 CopyMem (Destination, &WideFill, SizeInBytes);
317 }
318 } else {
319 DEBUG ((DEBUG_VERBOSE, "VideoFill (not wide)\n"));
320 if (!LineBufferReady) {
321 CopyMem (Configure->LineBuffer, &WideFill, Configure->BytesPerPixel);
322 for (IndexX = 1; IndexX < Width; ) {
323 CopyMem (
324 (Configure->LineBuffer + (IndexX * Configure->BytesPerPixel)),
325 Configure->LineBuffer,
326 MIN (IndexX, Width - IndexX) * Configure->BytesPerPixel
327 );
328 IndexX += MIN (IndexX, Width - IndexX);
329 }
330
331 LineBufferReady = TRUE;
332 }
333
334 CopyMem (Destination, Configure->LineBuffer, WidthInBytes);
335 }
336 }
337 }
338
339 return RETURN_SUCCESS;
340}
341
342/**
343 Performs a UEFI Graphics Output Protocol Blt Video to Buffer operation
344 with extended parameters.
345
346 @param[in] Configure Pointer to a configuration which was successfully
347 created by FrameBufferBltConfigure ().
348 @param[out] BltBuffer Output buffer for pixel color data.
349 @param[in] SourceX X location within video.
350 @param[in] SourceY Y location within video.
351 @param[in] DestinationX X location within BltBuffer.
352 @param[in] DestinationY Y location within BltBuffer.
353 @param[in] Width Width (in pixels).
354 @param[in] Height Height.
355 @param[in] Delta Number of bytes in a row of BltBuffer.
356
357 @retval RETURN_INVALID_PARAMETER Invalid parameter were passed in.
358 @retval RETURN_SUCCESS The Blt operation was performed successfully.
359**/
360RETURN_STATUS
361FrameBufferBltLibVideoToBltBuffer (
362 IN FRAME_BUFFER_CONFIGURE *Configure,
363 OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
364 IN UINTN SourceX,
365 IN UINTN SourceY,
366 IN UINTN DestinationX,
367 IN UINTN DestinationY,
368 IN UINTN Width,
369 IN UINTN Height,
370 IN UINTN Delta
371 )
372{
373 UINTN DstY;
374 UINTN SrcY;
375 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
376 UINT8 *Source;
377 UINT8 *Destination;
378 UINTN IndexX;
379 UINT32 Uint32;
380 UINTN Offset;
381 UINTN WidthInBytes;
382
383 //
384 // Video to BltBuffer: Source is Video, destination is BltBuffer
385 //
386 if (SourceY + Height > Configure->Height) {
387 return RETURN_INVALID_PARAMETER;
388 }
389
390 if (SourceX + Width > Configure->Width) {
391 return RETURN_INVALID_PARAMETER;
392 }
393
394 if ((Width == 0) || (Height == 0)) {
395 return RETURN_INVALID_PARAMETER;
396 }
397
398 //
399 // If Delta is zero, then the entire BltBuffer is being used, so Delta is
400 // the number of bytes in each row of BltBuffer. Since BltBuffer is Width
401 // pixels size, the number of bytes in each row can be computed.
402 //
403 if (Delta == 0) {
404 Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
405 }
406
407 WidthInBytes = Width * Configure->BytesPerPixel;
408
409 //
410 // Video to BltBuffer: Source is Video, destination is BltBuffer
411 //
412 for (SrcY = SourceY, DstY = DestinationY;
413 DstY < (Height + DestinationY);
414 SrcY++, DstY++)
415 {
416 Offset = (SrcY * Configure->PixelsPerScanLine) + SourceX;
417 Offset = Configure->BytesPerPixel * Offset;
418 Source = Configure->FrameBuffer + Offset;
419
420 if (Configure->PixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
421 Destination = (UINT8 *)BltBuffer + (DstY * Delta) + (DestinationX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
422 } else {
423 Destination = Configure->LineBuffer;
424 }
425
426 CopyMem (Destination, Source, WidthInBytes);
427
428 if (Configure->PixelFormat != PixelBlueGreenRedReserved8BitPerColor) {
429 for (IndexX = 0; IndexX < Width; IndexX++) {
430 Blt = (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)
431 ((UINT8 *)BltBuffer + (DstY * Delta) +
432 (DestinationX + IndexX) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
433 Uint32 = *(UINT32 *)(Configure->LineBuffer + (IndexX * Configure->BytesPerPixel));
434 *(UINT32 *)Blt =
435 (UINT32)(
436 (((Uint32 & Configure->PixelMasks.RedMask) >>
437 Configure->PixelShl[0]) << Configure->PixelShr[0]) |
438 (((Uint32 & Configure->PixelMasks.GreenMask) >>
439 Configure->PixelShl[1]) << Configure->PixelShr[1]) |
440 (((Uint32 & Configure->PixelMasks.BlueMask) >>
441 Configure->PixelShl[2]) << Configure->PixelShr[2])
442 );
443 }
444 }
445 }
446
447 return RETURN_SUCCESS;
448}
449
450/**
451 Performs a UEFI Graphics Output Protocol Blt Buffer to Video operation
452 with extended parameters.
453
454 @param[in] Configure Pointer to a configuration which was successfully
455 created by FrameBufferBltConfigure ().
456 @param[in] BltBuffer Output buffer for pixel color data.
457 @param[in] SourceX X location within BltBuffer.
458 @param[in] SourceY Y location within BltBuffer.
459 @param[in] DestinationX X location within video.
460 @param[in] DestinationY Y location within video.
461 @param[in] Width Width (in pixels).
462 @param[in] Height Height.
463 @param[in] Delta Number of bytes in a row of BltBuffer.
464
465 @retval RETURN_INVALID_PARAMETER Invalid parameter were passed in.
466 @retval RETURN_SUCCESS The Blt operation was performed successfully.
467**/
468RETURN_STATUS
469FrameBufferBltLibBufferToVideo (
470 IN FRAME_BUFFER_CONFIGURE *Configure,
471 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer,
472 IN UINTN SourceX,
473 IN UINTN SourceY,
474 IN UINTN DestinationX,
475 IN UINTN DestinationY,
476 IN UINTN Width,
477 IN UINTN Height,
478 IN UINTN Delta
479 )
480{
481 UINTN DstY;
482 UINTN SrcY;
483 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt;
484 UINT8 *Source;
485 UINT8 *Destination;
486 UINTN IndexX;
487 UINT32 Uint32;
488 UINTN Offset;
489 UINTN WidthInBytes;
490
491 //
492 // BltBuffer to Video: Source is BltBuffer, destination is Video
493 //
494 if (DestinationY + Height > Configure->Height) {
495 return RETURN_INVALID_PARAMETER;
496 }
497
498 if (DestinationX + Width > Configure->Width) {
499 return RETURN_INVALID_PARAMETER;
500 }
501
502 if ((Width == 0) || (Height == 0)) {
503 return RETURN_INVALID_PARAMETER;
504 }
505
506 //
507 // If Delta is zero, then the entire BltBuffer is being used, so Delta is
508 // the number of bytes in each row of BltBuffer. Since BltBuffer is Width
509 // pixels size, the number of bytes in each row can be computed.
510 //
511 if (Delta == 0) {
512 Delta = Width * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
513 }
514
515 WidthInBytes = Width * Configure->BytesPerPixel;
516
517 for (SrcY = SourceY, DstY = DestinationY;
518 SrcY < (Height + SourceY);
519 SrcY++, DstY++)
520 {
521 Offset = (DstY * Configure->PixelsPerScanLine) + DestinationX;
522 Offset = Configure->BytesPerPixel * Offset;
523 Destination = Configure->FrameBuffer + Offset;
524
525 if (Configure->PixelFormat == PixelBlueGreenRedReserved8BitPerColor) {
526 Source = (UINT8 *)BltBuffer + (SrcY * Delta) + SourceX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL);
527 } else {
528 for (IndexX = 0; IndexX < Width; IndexX++) {
529 Blt =
530 (EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)(
531 (UINT8 *)BltBuffer +
532 (SrcY * Delta) +
533 ((SourceX + IndexX) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL))
534 );
535 Uint32 = *(UINT32 *)Blt;
536 *(UINT32 *)(Configure->LineBuffer + (IndexX * Configure->BytesPerPixel)) =
537 (UINT32)(
538 (((Uint32 << Configure->PixelShl[0]) >> Configure->PixelShr[0]) &
539 Configure->PixelMasks.RedMask) |
540 (((Uint32 << Configure->PixelShl[1]) >> Configure->PixelShr[1]) &
541 Configure->PixelMasks.GreenMask) |
542 (((Uint32 << Configure->PixelShl[2]) >> Configure->PixelShr[2]) &
543 Configure->PixelMasks.BlueMask)
544 );
545 }
546
547 Source = Configure->LineBuffer;
548 }
549
550 CopyMem (Destination, Source, WidthInBytes);
551 }
552
553 return RETURN_SUCCESS;
554}
555
556/**
557 Performs a UEFI Graphics Output Protocol Blt Video to Video operation
558
559 @param[in] Configure Pointer to a configuration which was successfully
560 created by FrameBufferBltConfigure ().
561 @param[in] SourceX X location within video.
562 @param[in] SourceY Y location within video.
563 @param[in] DestinationX X location within video.
564 @param[in] DestinationY Y location within video.
565 @param[in] Width Width (in pixels).
566 @param[in] Height Height.
567
568 @retval RETURN_INVALID_PARAMETER Invalid parameter were passed in.
569 @retval RETURN_SUCCESS The Blt operation was performed successfully.
570**/
571RETURN_STATUS
572FrameBufferBltLibVideoToVideo (
573 IN FRAME_BUFFER_CONFIGURE *Configure,
574 IN UINTN SourceX,
575 IN UINTN SourceY,
576 IN UINTN DestinationX,
577 IN UINTN DestinationY,
578 IN UINTN Width,
579 IN UINTN Height
580 )
581{
582 UINT8 *Source;
583 UINT8 *Destination;
584 UINTN Offset;
585 UINTN WidthInBytes;
586 INTN LineStride;
587
588 //
589 // Video to Video: Source is Video, destination is Video
590 //
591 if (SourceY + Height > Configure->Height) {
592 return RETURN_INVALID_PARAMETER;
593 }
594
595 if (SourceX + Width > Configure->Width) {
596 return RETURN_INVALID_PARAMETER;
597 }
598
599 if (DestinationY + Height > Configure->Height) {
600 return RETURN_INVALID_PARAMETER;
601 }
602
603 if (DestinationX + Width > Configure->Width) {
604 return RETURN_INVALID_PARAMETER;
605 }
606
607 if ((Width == 0) || (Height == 0)) {
608 return RETURN_INVALID_PARAMETER;
609 }
610
611 WidthInBytes = Width * Configure->BytesPerPixel;
612
613 Offset = (SourceY * Configure->PixelsPerScanLine) + SourceX;
614 Offset = Configure->BytesPerPixel * Offset;
615 Source = Configure->FrameBuffer + Offset;
616
617 Offset = (DestinationY * Configure->PixelsPerScanLine) + DestinationX;
618 Offset = Configure->BytesPerPixel * Offset;
619 Destination = Configure->FrameBuffer + Offset;
620
621 LineStride = Configure->BytesPerPixel * Configure->PixelsPerScanLine;
622 if (Destination > Source) {
623 //
624 // Copy from last line to avoid source is corrupted by copying
625 //
626 Source += Height * LineStride;
627 Destination += Height * LineStride;
628 LineStride = -LineStride;
629 }
630
631 while (Height-- > 0) {
632 CopyMem (Destination, Source, WidthInBytes);
633
634 Source += LineStride;
635 Destination += LineStride;
636 }
637
638 return RETURN_SUCCESS;
639}
640
641/**
642 Performs a UEFI Graphics Output Protocol Blt operation.
643
644 @param[in] Configure Pointer to a configuration which was successfully
645 created by FrameBufferBltConfigure ().
646 @param[in,out] BltBuffer The data to transfer to screen.
647 @param[in] BltOperation The operation to perform.
648 @param[in] SourceX The X coordinate of the source for BltOperation.
649 @param[in] SourceY The Y coordinate of the source for BltOperation.
650 @param[in] DestinationX The X coordinate of the destination for
651 BltOperation.
652 @param[in] DestinationY The Y coordinate of the destination for
653 BltOperation.
654 @param[in] Width The width of a rectangle in the blt rectangle
655 in pixels.
656 @param[in] Height The height of a rectangle in the blt rectangle
657 in pixels.
658 @param[in] Delta Not used for EfiBltVideoFill and
659 EfiBltVideoToVideo operation. If a Delta of 0
660 is used, the entire BltBuffer will be operated
661 on. If a subrectangle of the BltBuffer is
662 used, then Delta represents the number of
663 bytes in a row of the BltBuffer.
664
665 @retval RETURN_INVALID_PARAMETER Invalid parameter were passed in.
666 @retval RETURN_SUCCESS The Blt operation was performed successfully.
667**/
668RETURN_STATUS
669EFIAPI
670FrameBufferBlt (
671 IN FRAME_BUFFER_CONFIGURE *Configure,
672 IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer OPTIONAL,
673 IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
674 IN UINTN SourceX,
675 IN UINTN SourceY,
676 IN UINTN DestinationX,
677 IN UINTN DestinationY,
678 IN UINTN Width,
679 IN UINTN Height,
680 IN UINTN Delta
681 )
682{
683 if (Configure == NULL) {
684 return RETURN_INVALID_PARAMETER;
685 }
686
687 switch (BltOperation) {
688 case EfiBltVideoToBltBuffer:
689 return FrameBufferBltLibVideoToBltBuffer (
690 Configure,
691 BltBuffer,
692 SourceX,
693 SourceY,
694 DestinationX,
695 DestinationY,
696 Width,
697 Height,
698 Delta
699 );
700
701 case EfiBltVideoToVideo:
702 return FrameBufferBltLibVideoToVideo (
703 Configure,
704 SourceX,
705 SourceY,
706 DestinationX,
707 DestinationY,
708 Width,
709 Height
710 );
711
712 case EfiBltVideoFill:
713 return FrameBufferBltLibVideoFill (
714 Configure,
715 BltBuffer,
716 DestinationX,
717 DestinationY,
718 Width,
719 Height
720 );
721
722 case EfiBltBufferToVideo:
723 return FrameBufferBltLibBufferToVideo (
724 Configure,
725 BltBuffer,
726 SourceX,
727 SourceY,
728 DestinationX,
729 DestinationY,
730 Width,
731 Height,
732 Delta
733 );
734
735 default:
736 return RETURN_INVALID_PARAMETER;
737 }
738}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette