[NTOS] Addendum to 03873aee: check that the computed size of the OEM-converted string...
[reactos.git] / ntoskrnl / inbv / inbv.c
1 /* INCLUDES ******************************************************************/
2
3 #include <ntoskrnl.h>
4 #define NDEBUG
5 #include <debug.h>
6 #include "bootvid/bootvid.h"
7
8 #ifndef TAG_OSTR
9 #define TAG_OSTR 'RTSO'
10 #endif
11
12 /* GLOBALS *******************************************************************/
13
14 /*
15 * Enable this define if you want Inbv to use coloured headless mode.
16 */
17 // #define INBV_HEADLESS_COLORS
18
19 /*
20 * ReactOS uses the same boot screen for all the products.
21 * Also it doesn't use a parallel system thread for the
22 * rotating "progress" bar.
23 */
24
25 /*
26 * Enable this define when ReactOS will have different SKUs
27 * (Workstation, Server, Storage Server, Cluster Server, etc...).
28 */
29 // #define REACTOS_SKUS
30
31 /*
32 * Enable this define when Inbv will support rotating progress bar.
33 */
34 #define INBV_ROTBAR_IMPLEMENTED
35
36 static KSPIN_LOCK BootDriverLock;
37 static KIRQL InbvOldIrql;
38 static INBV_DISPLAY_STATE InbvDisplayState = INBV_DISPLAY_STATE_DISABLED;
39 BOOLEAN InbvBootDriverInstalled = FALSE;
40 static BOOLEAN InbvDisplayDebugStrings = FALSE;
41 static INBV_DISPLAY_STRING_FILTER InbvDisplayFilter = NULL;
42 static ULONG ProgressBarLeft = 0, ProgressBarTop = 0;
43 static BOOLEAN ShowProgressBar = FALSE;
44 static INBV_PROGRESS_STATE InbvProgressState;
45 static BT_PROGRESS_INDICATOR InbvProgressIndicator = {0, 25, 0};
46 static INBV_RESET_DISPLAY_PARAMETERS InbvResetDisplayParameters = NULL;
47 static ULONG ResourceCount = 0;
48 static PUCHAR ResourceList[1 + IDB_MAX_RESOURCE]; // First entry == NULL, followed by 'ResourceCount' entries.
49
50 #ifdef INBV_ROTBAR_IMPLEMENTED
51 /*
52 * Change this to modify progress bar behaviour
53 */
54 #define ROT_BAR_DEFAULT_MODE RB_PROGRESS_BAR
55
56 /*
57 * Values for PltRotBarStatus:
58 * - PltRotBarStatus == 1, do palette fading-in (done elsewhere in ReactOS);
59 * - PltRotBarStatus == 2, do rotation bar animation;
60 * - PltRotBarStatus == 3, stop the animation thread.
61 * - Any other value is ignored and the animation thread continues to run.
62 */
63 typedef enum _ROT_BAR_STATUS
64 {
65 RBS_FADEIN = 1,
66 RBS_ANIMATE,
67 RBS_STOP_ANIMATE,
68 RBS_STATUS_MAX
69 } ROT_BAR_STATUS;
70
71 static BOOLEAN RotBarThreadActive = FALSE;
72 static ROT_BAR_TYPE RotBarSelection = RB_UNSPECIFIED;
73 static ROT_BAR_STATUS PltRotBarStatus = 0;
74 static UCHAR RotBarBuffer[24 * 9];
75 static UCHAR RotLineBuffer[640 * 6];
76 #endif
77
78
79 /*
80 * Headless terminal text colors
81 */
82
83 #ifdef INBV_HEADLESS_COLORS
84
85 // Conversion table CGA to ANSI color index
86 static const UCHAR CGA_TO_ANSI_COLOR_TABLE[16] =
87 {
88 0, // Black
89 4, // Blue
90 2, // Green
91 6, // Cyan
92 1, // Red
93 5, // Magenta
94 3, // Brown/Yellow
95 7, // Grey/White
96
97 60, // Bright Black
98 64, // Bright Blue
99 62, // Bright Green
100 66, // Bright Cyan
101 61, // Bright Red
102 65, // Bright Magenta
103 63, // Bright Yellow
104 67 // Bright Grey (White)
105 };
106
107 #define CGA_TO_ANSI_COLOR(CgaColor) \
108 CGA_TO_ANSI_COLOR_TABLE[CgaColor & 0x0F]
109
110 #endif
111
112 // Default colors: text in white, background in black
113 static ULONG InbvTerminalTextColor = 37;
114 static ULONG InbvTerminalBkgdColor = 40;
115
116
117 /* FADING FUNCTION ***********************************************************/
118
119 /** From include/psdk/wingdi.h **/
120 typedef struct tagRGBQUAD
121 {
122 UCHAR rgbBlue;
123 UCHAR rgbGreen;
124 UCHAR rgbRed;
125 UCHAR rgbReserved;
126 } RGBQUAD,*LPRGBQUAD;
127 /*******************************/
128
129 static RGBQUAD MainPalette[16];
130
131 #define PALETTE_FADE_STEPS 15
132 #define PALETTE_FADE_TIME (20 * 1000) /* 20 ms */
133
134 /** From bootvid/precomp.h **/
135 //
136 // Bitmap Header
137 //
138 typedef struct tagBITMAPINFOHEADER
139 {
140 ULONG biSize;
141 LONG biWidth;
142 LONG biHeight;
143 USHORT biPlanes;
144 USHORT biBitCount;
145 ULONG biCompression;
146 ULONG biSizeImage;
147 LONG biXPelsPerMeter;
148 LONG biYPelsPerMeter;
149 ULONG biClrUsed;
150 ULONG biClrImportant;
151 } BITMAPINFOHEADER, *PBITMAPINFOHEADER;
152 /****************************/
153
154 //
155 // Needed prototypes
156 //
157 VOID NTAPI InbvAcquireLock(VOID);
158 VOID NTAPI InbvReleaseLock(VOID);
159
160 static VOID
161 BootLogoFadeIn(VOID)
162 {
163 UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) + sizeof(MainPalette)];
164 PBITMAPINFOHEADER PaletteBitmap = (PBITMAPINFOHEADER)PaletteBitmapBuffer;
165 LPRGBQUAD Palette = (LPRGBQUAD)(PaletteBitmapBuffer + sizeof(BITMAPINFOHEADER));
166 ULONG Iteration, Index, ClrUsed;
167
168 LARGE_INTEGER Delay;
169 Delay.QuadPart = - (PALETTE_FADE_TIME * 10);
170
171 /* Check if we are installed and we own the display */
172 if (!InbvBootDriverInstalled ||
173 (InbvDisplayState != INBV_DISPLAY_STATE_OWNED))
174 {
175 return;
176 }
177
178 /*
179 * Build a bitmap containing the fade-in palette. The palette entries
180 * are then processed in a loop and set using VidBitBlt function.
181 */
182 ClrUsed = RTL_NUMBER_OF(MainPalette);
183 RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
184 PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
185 PaletteBitmap->biBitCount = 4;
186 PaletteBitmap->biClrUsed = ClrUsed;
187
188 /*
189 * Main animation loop.
190 */
191 for (Iteration = 0; Iteration <= PALETTE_FADE_STEPS; ++Iteration)
192 {
193 for (Index = 0; Index < ClrUsed; Index++)
194 {
195 Palette[Index].rgbRed = (UCHAR)
196 (MainPalette[Index].rgbRed * Iteration / PALETTE_FADE_STEPS);
197 Palette[Index].rgbGreen = (UCHAR)
198 (MainPalette[Index].rgbGreen * Iteration / PALETTE_FADE_STEPS);
199 Palette[Index].rgbBlue = (UCHAR)
200 (MainPalette[Index].rgbBlue * Iteration / PALETTE_FADE_STEPS);
201 }
202
203 /* Do the animation */
204 InbvAcquireLock();
205 VidBitBlt(PaletteBitmapBuffer, 0, 0);
206 InbvReleaseLock();
207
208 /* Wait for a bit */
209 KeDelayExecutionThread(KernelMode, FALSE, &Delay);
210 }
211 }
212
213 /* FUNCTIONS *****************************************************************/
214
215 PVOID
216 NTAPI
217 INIT_FUNCTION
218 FindBitmapResource(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
219 IN ULONG ResourceId)
220 {
221 UNICODE_STRING UpString = RTL_CONSTANT_STRING(L"ntoskrnl.exe");
222 UNICODE_STRING MpString = RTL_CONSTANT_STRING(L"ntkrnlmp.exe");
223 PLIST_ENTRY NextEntry, ListHead;
224 PLDR_DATA_TABLE_ENTRY LdrEntry;
225 PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
226 LDR_RESOURCE_INFO ResourceInfo;
227 NTSTATUS Status;
228 PVOID Data = NULL;
229
230 /* Loop the driver list */
231 ListHead = &LoaderBlock->LoadOrderListHead;
232 NextEntry = ListHead->Flink;
233 while (NextEntry != ListHead)
234 {
235 /* Get the entry */
236 LdrEntry = CONTAINING_RECORD(NextEntry,
237 LDR_DATA_TABLE_ENTRY,
238 InLoadOrderLinks);
239
240 /* Check for a match */
241 if (RtlEqualUnicodeString(&LdrEntry->BaseDllName, &UpString, TRUE) ||
242 RtlEqualUnicodeString(&LdrEntry->BaseDllName, &MpString, TRUE))
243 {
244 /* Break out */
245 break;
246 }
247 }
248
249 /* Check if we found it */
250 if (NextEntry != ListHead)
251 {
252 /* Try to find the resource */
253 ResourceInfo.Type = 2; // RT_BITMAP;
254 ResourceInfo.Name = ResourceId;
255 ResourceInfo.Language = 0;
256 Status = LdrFindResource_U(LdrEntry->DllBase,
257 &ResourceInfo,
258 RESOURCE_DATA_LEVEL,
259 &ResourceDataEntry);
260 if (NT_SUCCESS(Status))
261 {
262 /* Access the resource */
263 ULONG Size = 0;
264 Status = LdrAccessResource(LdrEntry->DllBase,
265 ResourceDataEntry,
266 &Data,
267 &Size);
268 if ((Data) && (ResourceId < 3))
269 {
270 KiBugCheckData[4] ^= RtlComputeCrc32(0, Data, Size);
271 }
272 if (!NT_SUCCESS(Status)) Data = NULL;
273 }
274 }
275
276 /* Return the pointer */
277 return Data;
278 }
279
280 BOOLEAN
281 NTAPI
282 INIT_FUNCTION
283 InbvDriverInitialize(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
284 IN ULONG Count)
285 {
286 PCHAR CommandLine;
287 BOOLEAN ResetMode = FALSE; // By default do not reset the video mode
288 ULONG i;
289
290 /* Quit if we're already installed */
291 if (InbvBootDriverInstalled) return TRUE;
292
293 /* Initialize the lock and check the current display state */
294 KeInitializeSpinLock(&BootDriverLock);
295 if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
296 {
297 /* Reset the video mode in case we do not have a custom boot logo */
298 CommandLine = (LoaderBlock->LoadOptions ? _strupr(LoaderBlock->LoadOptions) : NULL);
299 ResetMode = (CommandLine == NULL) || (strstr(CommandLine, "BOOTLOGO") == NULL);
300 }
301
302 /* Initialize the video */
303 InbvBootDriverInstalled = VidInitialize(ResetMode);
304 if (InbvBootDriverInstalled)
305 {
306 /* Find bitmap resources in the kernel */
307 ResourceCount = min(Count, RTL_NUMBER_OF(ResourceList) - 1);
308 for (i = 1; i <= ResourceCount; i++)
309 {
310 /* Do the lookup */
311 ResourceList[i] = FindBitmapResource(LoaderBlock, i);
312 }
313
314 /* Set the progress bar ranges */
315 InbvSetProgressBarSubset(0, 100);
316 }
317
318 /* Return install state */
319 return InbvBootDriverInstalled;
320 }
321
322 VOID
323 NTAPI
324 InbvAcquireLock(VOID)
325 {
326 KIRQL OldIrql;
327
328 /* Check if we're at dispatch level or lower */
329 OldIrql = KeGetCurrentIrql();
330 if (OldIrql <= DISPATCH_LEVEL)
331 {
332 /* Loop until the lock is free */
333 while (!KeTestSpinLock(&BootDriverLock));
334
335 /* Raise IRQL to dispatch level */
336 KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
337 }
338
339 /* Acquire the lock */
340 KiAcquireSpinLock(&BootDriverLock);
341 InbvOldIrql = OldIrql;
342 }
343
344 VOID
345 NTAPI
346 InbvReleaseLock(VOID)
347 {
348 KIRQL OldIrql;
349
350 /* Capture the old IRQL */
351 OldIrql = InbvOldIrql;
352
353 /* Release the driver lock */
354 KiReleaseSpinLock(&BootDriverLock);
355
356 /* If we were at dispatch level or lower, restore the old IRQL */
357 if (InbvOldIrql <= DISPATCH_LEVEL) KeLowerIrql(OldIrql);
358 }
359
360 VOID
361 NTAPI
362 INIT_FUNCTION
363 InbvEnableBootDriver(IN BOOLEAN Enable)
364 {
365 /* Check if we're installed */
366 if (InbvBootDriverInstalled)
367 {
368 /* Check for lost state */
369 if (InbvDisplayState >= INBV_DISPLAY_STATE_LOST) return;
370
371 /* Acquire the lock */
372 InbvAcquireLock();
373
374 /* Cleanup the screen if we own it */
375 if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED) VidCleanUp();
376
377 /* Set the new display state */
378 InbvDisplayState = Enable ? INBV_DISPLAY_STATE_OWNED :
379 INBV_DISPLAY_STATE_DISABLED;
380
381 /* Release the lock */
382 InbvReleaseLock();
383 }
384 else
385 {
386 /* Set the new display state */
387 InbvDisplayState = Enable ? INBV_DISPLAY_STATE_OWNED :
388 INBV_DISPLAY_STATE_DISABLED;
389 }
390 }
391
392 VOID
393 NTAPI
394 InbvAcquireDisplayOwnership(VOID)
395 {
396 /* Check if we have a callback and we're just acquiring it now */
397 if ((InbvResetDisplayParameters) &&
398 (InbvDisplayState == INBV_DISPLAY_STATE_LOST))
399 {
400 /* Call the callback */
401 InbvResetDisplayParameters(80, 50);
402 }
403
404 /* Acquire the display */
405 InbvDisplayState = INBV_DISPLAY_STATE_OWNED;
406 }
407
408 VOID
409 NTAPI
410 InbvSetDisplayOwnership(IN BOOLEAN DisplayOwned)
411 {
412 /* Set the new display state */
413 InbvDisplayState = DisplayOwned ? INBV_DISPLAY_STATE_OWNED :
414 INBV_DISPLAY_STATE_LOST;
415 }
416
417 BOOLEAN
418 NTAPI
419 InbvCheckDisplayOwnership(VOID)
420 {
421 /* Return if we own it or not */
422 return InbvDisplayState != INBV_DISPLAY_STATE_LOST;
423 }
424
425 INBV_DISPLAY_STATE
426 NTAPI
427 InbvGetDisplayState(VOID)
428 {
429 /* Return the actual state */
430 return InbvDisplayState;
431 }
432
433 BOOLEAN
434 NTAPI
435 InbvDisplayString(IN PCHAR String)
436 {
437 /* Make sure we own the display */
438 if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
439 {
440 /* If we're not allowed, return success anyway */
441 if (!InbvDisplayDebugStrings) return TRUE;
442
443 /* Check if a filter is installed */
444 if (InbvDisplayFilter) InbvDisplayFilter(&String);
445
446 /* Acquire the lock */
447 InbvAcquireLock();
448
449 /* Make sure we're installed and display the string */
450 if (InbvBootDriverInstalled) VidDisplayString((PUCHAR)String);
451
452 /* Print the string on the EMS port */
453 HeadlessDispatch(HeadlessCmdPutString,
454 String,
455 strlen(String) + sizeof(ANSI_NULL),
456 NULL,
457 NULL);
458
459 /* Release the lock */
460 InbvReleaseLock();
461
462 /* All done */
463 return TRUE;
464 }
465
466 /* We don't own it, fail */
467 return FALSE;
468 }
469
470 BOOLEAN
471 NTAPI
472 InbvEnableDisplayString(IN BOOLEAN Enable)
473 {
474 BOOLEAN OldSetting;
475
476 /* Get the old setting */
477 OldSetting = InbvDisplayDebugStrings;
478
479 /* Update it */
480 InbvDisplayDebugStrings = Enable;
481
482 /* Return the old setting */
483 return OldSetting;
484 }
485
486 VOID
487 NTAPI
488 InbvInstallDisplayStringFilter(IN INBV_DISPLAY_STRING_FILTER Filter)
489 {
490 /* Save the filter */
491 InbvDisplayFilter = Filter;
492 }
493
494 BOOLEAN
495 NTAPI
496 InbvIsBootDriverInstalled(VOID)
497 {
498 /* Return driver state */
499 return InbvBootDriverInstalled;
500 }
501
502 VOID
503 NTAPI
504 InbvNotifyDisplayOwnershipLost(IN INBV_RESET_DISPLAY_PARAMETERS Callback)
505 {
506 /* Check if we're installed */
507 if (InbvBootDriverInstalled)
508 {
509 /* Acquire the lock and cleanup if we own the screen */
510 InbvAcquireLock();
511 if (InbvDisplayState != INBV_DISPLAY_STATE_LOST) VidCleanUp();
512
513 /* Set the reset callback and display state */
514 InbvResetDisplayParameters = Callback;
515 InbvDisplayState = INBV_DISPLAY_STATE_LOST;
516
517 /* Release the lock */
518 InbvReleaseLock();
519 }
520 else
521 {
522 /* Set the reset callback and display state */
523 InbvResetDisplayParameters = Callback;
524 InbvDisplayState = INBV_DISPLAY_STATE_LOST;
525 }
526 }
527
528 BOOLEAN
529 NTAPI
530 InbvResetDisplay(VOID)
531 {
532 /* Check if we're installed and we own it */
533 if (InbvBootDriverInstalled &&
534 (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
535 {
536 /* Do the reset */
537 VidResetDisplay(TRUE);
538 return TRUE;
539 }
540
541 /* Nothing to reset */
542 return FALSE;
543 }
544
545 VOID
546 NTAPI
547 InbvSetScrollRegion(IN ULONG Left,
548 IN ULONG Top,
549 IN ULONG Right,
550 IN ULONG Bottom)
551 {
552 /* Just call bootvid */
553 VidSetScrollRegion(Left, Top, Right, Bottom);
554 }
555
556 VOID
557 NTAPI
558 InbvSetTextColor(IN ULONG Color)
559 {
560 HEADLESS_CMD_SET_COLOR HeadlessSetColor;
561
562 /* Set color for EMS port */
563 #ifdef INBV_HEADLESS_COLORS
564 InbvTerminalTextColor = 30 + CGA_TO_ANSI_COLOR(Color);
565 #else
566 InbvTerminalTextColor = 37;
567 #endif
568 HeadlessSetColor.TextColor = InbvTerminalTextColor;
569 HeadlessSetColor.BkgdColor = InbvTerminalBkgdColor;
570 HeadlessDispatch(HeadlessCmdSetColor,
571 &HeadlessSetColor,
572 sizeof(HeadlessSetColor),
573 NULL,
574 NULL);
575
576 /* Update the text color */
577 VidSetTextColor(Color);
578 }
579
580 VOID
581 NTAPI
582 InbvSolidColorFill(IN ULONG Left,
583 IN ULONG Top,
584 IN ULONG Right,
585 IN ULONG Bottom,
586 IN ULONG Color)
587 {
588 HEADLESS_CMD_SET_COLOR HeadlessSetColor;
589
590 /* Make sure we own it */
591 if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
592 {
593 /* Acquire the lock */
594 InbvAcquireLock();
595
596 /* Check if we're installed */
597 if (InbvBootDriverInstalled)
598 {
599 /* Call bootvid */
600 VidSolidColorFill(Left, Top, Right, Bottom, (UCHAR)Color);
601 }
602
603 /* Set color for EMS port and clear display */
604 #ifdef INBV_HEADLESS_COLORS
605 InbvTerminalBkgdColor = 40 + CGA_TO_ANSI_COLOR(Color);
606 #else
607 InbvTerminalBkgdColor = 40;
608 #endif
609 HeadlessSetColor.TextColor = InbvTerminalTextColor;
610 HeadlessSetColor.BkgdColor = InbvTerminalBkgdColor;
611 HeadlessDispatch(HeadlessCmdSetColor,
612 &HeadlessSetColor,
613 sizeof(HeadlessSetColor),
614 NULL,
615 NULL);
616 HeadlessDispatch(HeadlessCmdClearDisplay,
617 NULL, 0,
618 NULL, NULL);
619
620 /* Release the lock */
621 InbvReleaseLock();
622 }
623 }
624
625 VOID
626 NTAPI
627 INIT_FUNCTION
628 InbvUpdateProgressBar(IN ULONG Progress)
629 {
630 ULONG FillCount, BoundedProgress;
631
632 /* Make sure the progress bar is enabled, that we own and are installed */
633 if (ShowProgressBar &&
634 InbvBootDriverInstalled &&
635 (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
636 {
637 /* Compute fill count */
638 BoundedProgress = (InbvProgressState.Floor / 100) + Progress;
639 FillCount = 121 * (InbvProgressState.Bias * BoundedProgress) / 1000000;
640
641 /* Acquire the lock */
642 InbvAcquireLock();
643
644 /* Fill the progress bar */
645 VidSolidColorFill(ProgressBarLeft,
646 ProgressBarTop,
647 ProgressBarLeft + FillCount,
648 ProgressBarTop + 12,
649 15);
650
651 /* Release the lock */
652 InbvReleaseLock();
653 }
654 }
655
656 VOID
657 NTAPI
658 InbvBufferToScreenBlt(IN PUCHAR Buffer,
659 IN ULONG X,
660 IN ULONG Y,
661 IN ULONG Width,
662 IN ULONG Height,
663 IN ULONG Delta)
664 {
665 /* Check if we're installed and we own it */
666 if (InbvBootDriverInstalled &&
667 (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
668 {
669 /* Do the blit */
670 VidBufferToScreenBlt(Buffer, X, Y, Width, Height, Delta);
671 }
672 }
673
674 VOID
675 NTAPI
676 InbvBitBlt(IN PUCHAR Buffer,
677 IN ULONG X,
678 IN ULONG Y)
679 {
680 /* Check if we're installed and we own it */
681 if (InbvBootDriverInstalled &&
682 (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
683 {
684 /* Acquire the lock */
685 InbvAcquireLock();
686
687 /* Do the blit */
688 VidBitBlt(Buffer, X, Y);
689
690 /* Release the lock */
691 InbvReleaseLock();
692 }
693 }
694
695 VOID
696 NTAPI
697 InbvScreenToBufferBlt(IN PUCHAR Buffer,
698 IN ULONG X,
699 IN ULONG Y,
700 IN ULONG Width,
701 IN ULONG Height,
702 IN ULONG Delta)
703 {
704 /* Check if we're installed and we own it */
705 if (InbvBootDriverInstalled &&
706 (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
707 {
708 /* Do the blit */
709 VidScreenToBufferBlt(Buffer, X, Y, Width, Height, Delta);
710 }
711 }
712
713 VOID
714 NTAPI
715 InbvSetProgressBarCoordinates(IN ULONG Left,
716 IN ULONG Top)
717 {
718 /* Update the coordinates */
719 ProgressBarLeft = Left;
720 ProgressBarTop = Top;
721
722 /* Enable the progress bar */
723 ShowProgressBar = TRUE;
724 }
725
726 VOID
727 NTAPI
728 InbvSetProgressBarSubset(IN ULONG Floor,
729 IN ULONG Ceiling)
730 {
731 /* Sanity checks */
732 ASSERT(Floor < Ceiling);
733 ASSERT(Ceiling <= 100);
734
735 /* Update the progress bar state */
736 InbvProgressState.Floor = Floor * 100;
737 InbvProgressState.Ceiling = Ceiling * 100;
738 InbvProgressState.Bias = (Ceiling * 100) - Floor;
739 }
740
741 VOID
742 NTAPI
743 INIT_FUNCTION
744 InbvIndicateProgress(VOID)
745 {
746 ULONG Percentage;
747
748 /* Increase progress */
749 InbvProgressIndicator.Count++;
750
751 /* Compute new percentage */
752 Percentage = min(100 * InbvProgressIndicator.Count /
753 InbvProgressIndicator.Expected,
754 99);
755 if (Percentage != InbvProgressIndicator.Percentage)
756 {
757 /* Percentage has moved, update the progress bar */
758 InbvProgressIndicator.Percentage = Percentage;
759 InbvUpdateProgressBar(Percentage);
760 }
761 }
762
763 PUCHAR
764 NTAPI
765 InbvGetResourceAddress(IN ULONG ResourceNumber)
766 {
767 /* Validate the resource number */
768 if (ResourceNumber > ResourceCount) return NULL;
769
770 /* Return the address */
771 return ResourceList[ResourceNumber];
772 }
773
774 NTSTATUS
775 NTAPI
776 NtDisplayString(IN PUNICODE_STRING DisplayString)
777 {
778 NTSTATUS Status;
779 UNICODE_STRING CapturedString;
780 OEM_STRING OemString;
781 ULONG OemLength;
782 KPROCESSOR_MODE PreviousMode;
783
784 PAGED_CODE();
785
786 PreviousMode = ExGetPreviousMode();
787
788 /* We require the TCB privilege */
789 if (!SeSinglePrivilegeCheck(SeTcbPrivilege, PreviousMode))
790 return STATUS_PRIVILEGE_NOT_HELD;
791
792 /* Capture the string */
793 Status = ProbeAndCaptureUnicodeString(&CapturedString, PreviousMode, DisplayString);
794 if (!NT_SUCCESS(Status))
795 return Status;
796
797 /* Do not display the string if it is empty */
798 if (CapturedString.Length == 0 || CapturedString.Buffer == NULL)
799 {
800 Status = STATUS_SUCCESS;
801 goto Quit;
802 }
803
804 /*
805 * Convert the string since INBV understands only ANSI/OEM. Allocate the
806 * string buffer in non-paged pool because INBV passes it down to BOOTVID.
807 * We cannot perform the allocation using RtlUnicodeStringToOemString()
808 * since its allocator uses PagedPool.
809 */
810 OemLength = RtlUnicodeStringToOemSize(&CapturedString);
811 if (OemLength > MAXUSHORT)
812 {
813 Status = STATUS_BUFFER_OVERFLOW;
814 goto Quit;
815 }
816 RtlInitEmptyAnsiString((PANSI_STRING)&OemString, NULL, (USHORT)OemLength);
817 OemString.Buffer = ExAllocatePoolWithTag(NonPagedPool, OemLength, TAG_OSTR);
818 if (OemString.Buffer == NULL)
819 {
820 Status = STATUS_NO_MEMORY;
821 goto Quit;
822 }
823 RtlUnicodeStringToOemString(&OemString, &CapturedString, FALSE);
824
825 /* Display the string */
826 InbvDisplayString(OemString.Buffer);
827
828 /* Free the string buffer */
829 ExFreePoolWithTag(OemString.Buffer, TAG_OSTR);
830
831 Status = STATUS_SUCCESS;
832
833 Quit:
834 /* Free the captured string */
835 ReleaseCapturedUnicodeString(&CapturedString, PreviousMode);
836
837 return Status;
838 }
839
840 #ifdef INBV_ROTBAR_IMPLEMENTED
841 static
842 VOID
843 NTAPI
844 InbvRotationThread(
845 _In_ PVOID Context)
846 {
847 ULONG X, Y, Index, Total;
848 LARGE_INTEGER Delay = {{0}};
849
850 InbvAcquireLock();
851 if (RotBarSelection == RB_SQUARE_CELLS)
852 {
853 Index = 0;
854 }
855 else
856 {
857 Index = 32;
858 }
859 X = ProgressBarLeft + 2;
860 Y = ProgressBarTop + 2;
861 InbvReleaseLock();
862
863 while (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
864 {
865 /* Wait for a bit */
866 KeDelayExecutionThread(KernelMode, FALSE, &Delay);
867
868 InbvAcquireLock();
869
870 /* Unknown unexpected command */
871 ASSERT(PltRotBarStatus < RBS_STATUS_MAX);
872
873 if (PltRotBarStatus == RBS_STOP_ANIMATE)
874 {
875 /* Stop the thread */
876 InbvReleaseLock();
877 break;
878 }
879
880 if (RotBarSelection == RB_SQUARE_CELLS)
881 {
882 Delay.QuadPart = -800000; // 80 ms
883 Total = 18;
884 Index %= Total;
885
886 if (Index >= 3)
887 {
888 /* Fill previous bar position */
889 VidSolidColorFill(X + ((Index - 3) * 8), Y, (X + ((Index - 3) * 8)) + 8 - 1, Y + 9 - 1, 0);
890 }
891 if (Index < Total - 1)
892 {
893 /* Draw the progress bar bit */
894 if (Index < 2)
895 {
896 /* Appearing from the left */
897 VidBufferToScreenBlt(RotBarBuffer + 8 * (2 - Index) / 2, X, Y, 22 - 8 * (2 - Index), 9, 24);
898 }
899 else if (Index >= Total - 3)
900 {
901 /* Hiding to the right */
902 VidBufferToScreenBlt(RotBarBuffer, X + ((Index - 2) * 8), Y, 22 - 8 * (4 - (Total - Index)), 9, 24);
903 }
904 else
905 {
906 VidBufferToScreenBlt(RotBarBuffer, X + ((Index - 2) * 8), Y, 22, 9, 24);
907 }
908 }
909 Index++;
910 }
911 else if (RotBarSelection == RB_PROGRESS_BAR)
912 {
913 Delay.QuadPart = -600000; // 60 ms
914 Total = 640;
915 Index %= Total;
916
917 /* Right part */
918 VidBufferToScreenBlt(RotLineBuffer, Index, 474, 640 - Index, 6, 640);
919 if (Index > 0)
920 {
921 /* Left part */
922 VidBufferToScreenBlt(RotLineBuffer + (640 - Index) / 2, 0, 474, Index - 2, 6, 640);
923 }
924 Index += 32;
925 }
926
927 InbvReleaseLock();
928 }
929
930 PsTerminateSystemThread(STATUS_SUCCESS);
931 }
932
933 VOID
934 NTAPI
935 INIT_FUNCTION
936 InbvRotBarInit(VOID)
937 {
938 PltRotBarStatus = RBS_FADEIN;
939 /* Perform other initialization if needed */
940 }
941 #endif
942
943 VOID
944 NTAPI
945 INIT_FUNCTION
946 DisplayBootBitmap(IN BOOLEAN TextMode)
947 {
948 PVOID Header = NULL, Footer = NULL, Screen = NULL;
949
950 #ifdef INBV_ROTBAR_IMPLEMENTED
951 UCHAR Buffer[24 * 9];
952 PVOID Bar = NULL, LineBmp = NULL;
953 ROT_BAR_TYPE TempRotBarSelection = RB_UNSPECIFIED;
954 NTSTATUS Status;
955 HANDLE ThreadHandle = NULL;
956 #endif
957
958 #ifdef REACTOS_SKUS
959 PVOID Text = NULL;
960 #endif
961
962 #ifdef INBV_ROTBAR_IMPLEMENTED
963 /* Check if the animation thread has already been created */
964 if (RotBarThreadActive)
965 {
966 /* Yes, just reset the progress bar but keep the thread alive */
967 InbvAcquireLock();
968 RotBarSelection = RB_UNSPECIFIED;
969 InbvReleaseLock();
970 }
971 #endif
972
973 ShowProgressBar = FALSE;
974
975 /* Check if this is text mode */
976 if (TextMode)
977 {
978 /* Check the type of the OS: workstation or server */
979 if (SharedUserData->NtProductType == NtProductWinNt)
980 {
981 /* Workstation; set colors */
982 InbvSetTextColor(15);
983 InbvSolidColorFill(0, 0, 639, 479, 7);
984 InbvSolidColorFill(0, 421, 639, 479, 1);
985
986 /* Get resources */
987 Header = InbvGetResourceAddress(IDB_WKSTA_HEADER);
988 Footer = InbvGetResourceAddress(IDB_WKSTA_FOOTER);
989 }
990 else
991 {
992 /* Server; set colors */
993 InbvSetTextColor(14);
994 InbvSolidColorFill(0, 0, 639, 479, 6);
995 InbvSolidColorFill(0, 421, 639, 479, 1);
996
997 /* Get resources */
998 Header = InbvGetResourceAddress(IDB_SERVER_HEADER);
999 Footer = InbvGetResourceAddress(IDB_SERVER_FOOTER);
1000 }
1001
1002 /* Set the scrolling region */
1003 InbvSetScrollRegion(32, 80, 631, 400);
1004
1005 /* Make sure we have resources */
1006 if (Header && Footer)
1007 {
1008 /* BitBlt them on the screen */
1009 InbvBitBlt(Footer, 0, 419);
1010 InbvBitBlt(Header, 0, 0);
1011 }
1012 }
1013 else
1014 {
1015 /* Is the boot driver installed? */
1016 if (!InbvBootDriverInstalled) return;
1017
1018 /* Load the standard boot screen */
1019 Screen = InbvGetResourceAddress(IDB_BOOT_SCREEN);
1020
1021 #ifdef REACTOS_SKUS
1022 Text = NULL;
1023 if (SharedUserData->NtProductType == NtProductWinNt)
1024 {
1025 #ifdef INBV_ROTBAR_IMPLEMENTED
1026 /* Workstation product, use appropriate status bar color */
1027 Bar = InbvGetResourceAddress(IDB_BAR_WKSTA);
1028 #endif
1029 }
1030 else
1031 {
1032 /* Display correct branding based on server suite */
1033 if (ExVerifySuite(StorageServer))
1034 {
1035 /* Storage Server Edition */
1036 Text = InbvGetResourceAddress(IDB_STORAGE_SERVER);
1037 }
1038 else if (ExVerifySuite(ComputeServer))
1039 {
1040 /* Compute Cluster Edition */
1041 Text = InbvGetResourceAddress(IDB_CLUSTER_SERVER);
1042 }
1043 else
1044 {
1045 /* Normal edition */
1046 Text = InbvGetResourceAddress(IDB_SERVER_LOGO);
1047 }
1048
1049 #ifdef INBV_ROTBAR_IMPLEMENTED
1050 /* Server product, use appropriate status bar color */
1051 Bar = InbvGetResourceAddress(IDB_BAR_SERVER);
1052 #endif
1053 }
1054 #else
1055 /* Use default status bar */
1056 Bar = InbvGetResourceAddress(IDB_BAR_WKSTA);
1057 #endif
1058
1059 /* Make sure we have a logo */
1060 if (Screen)
1061 {
1062 PBITMAPINFOHEADER BitmapInfoHeader;
1063 LPRGBQUAD Palette;
1064
1065 /*
1066 * Save the main image palette and replace it with black palette,
1067 * so that we can do fade-in effect later.
1068 */
1069 BitmapInfoHeader = (PBITMAPINFOHEADER)Screen;
1070 Palette = (LPRGBQUAD)((PUCHAR)Screen + BitmapInfoHeader->biSize);
1071 RtlCopyMemory(MainPalette, Palette, sizeof(MainPalette));
1072 RtlZeroMemory(Palette, sizeof(MainPalette));
1073
1074 /* Blit the background */
1075 InbvBitBlt(Screen, 0, 0);
1076
1077 #ifdef INBV_ROTBAR_IMPLEMENTED
1078 /* Choose progress bar */
1079 TempRotBarSelection = ROT_BAR_DEFAULT_MODE;
1080 #endif
1081
1082 /* Set progress bar coordinates and display it */
1083 InbvSetProgressBarCoordinates(259, 352);
1084
1085 #ifdef REACTOS_SKUS
1086 /* Check for non-workstation products */
1087 if (SharedUserData->NtProductType != NtProductWinNt)
1088 {
1089 /* Overwrite part of the logo for a server product */
1090 InbvScreenToBufferBlt(Buffer, 413, 237, 7, 7, 8);
1091 InbvSolidColorFill(418, 230, 454, 256, 0);
1092 InbvBufferToScreenBlt(Buffer, 413, 237, 7, 7, 8);
1093
1094 /* In setup mode, you haven't selected a SKU yet */
1095 if (ExpInTextModeSetup) Text = NULL;
1096 }
1097 #endif
1098 }
1099
1100 #ifdef REACTOS_SKUS
1101 /* Draw the SKU text if it exits */
1102 if (Text) InbvBitBlt(Text, 180, 121);
1103 #endif
1104
1105 #ifdef INBV_ROTBAR_IMPLEMENTED
1106 if (Bar)
1107 {
1108 /* Save previous screen pixels to buffer */
1109 InbvScreenToBufferBlt(Buffer, 0, 0, 22, 9, 24);
1110 /* Draw the progress bar bit */
1111 InbvBitBlt(Bar, 0, 0);
1112 /* Store it in global buffer */
1113 InbvScreenToBufferBlt(RotBarBuffer, 0, 0, 22, 9, 24);
1114 /* Restore screen pixels */
1115 InbvBufferToScreenBlt(Buffer, 0, 0, 22, 9, 24);
1116 }
1117
1118 /*
1119 * Add a rotating bottom horizontal bar when using a progress bar,
1120 * to show that ReactOS can be still alive when the bar does not
1121 * appear to progress.
1122 */
1123 if (TempRotBarSelection == RB_PROGRESS_BAR)
1124 {
1125 LineBmp = InbvGetResourceAddress(IDB_ROTATING_LINE);
1126 if (LineBmp)
1127 {
1128 /* Draw the line and store it in global buffer */
1129 InbvBitBlt(LineBmp, 0, 474);
1130 InbvScreenToBufferBlt(RotLineBuffer, 0, 474, 640, 6, 640);
1131 }
1132 }
1133 else
1134 {
1135 /* Hide the simple progress bar if not used */
1136 ShowProgressBar = FALSE;
1137 }
1138 #endif
1139
1140 /* Display the boot logo and fade it in */
1141 BootLogoFadeIn();
1142
1143 #ifdef INBV_ROTBAR_IMPLEMENTED
1144 if (!RotBarThreadActive && TempRotBarSelection != RB_UNSPECIFIED)
1145 {
1146 /* Start the animation thread */
1147 Status = PsCreateSystemThread(&ThreadHandle,
1148 0,
1149 NULL,
1150 NULL,
1151 NULL,
1152 InbvRotationThread,
1153 NULL);
1154 if (NT_SUCCESS(Status))
1155 {
1156 /* The thread has started, close the handle as we don't need it */
1157 RotBarThreadActive = TRUE;
1158 ObCloseHandle(ThreadHandle, KernelMode);
1159 }
1160 }
1161 #endif
1162
1163 /* Set filter which will draw text display if needed */
1164 InbvInstallDisplayStringFilter(DisplayFilter);
1165 }
1166
1167 #ifdef INBV_ROTBAR_IMPLEMENTED
1168 /* Do we have the animation thread? */
1169 if (RotBarThreadActive)
1170 {
1171 /* We do, initialize the progress bar */
1172 InbvAcquireLock();
1173 RotBarSelection = TempRotBarSelection;
1174 InbvRotBarInit();
1175 InbvReleaseLock();
1176
1177 // FIXME: This was added to allow animation start before the processor hangs
1178 if (TempRotBarSelection != RB_UNSPECIFIED)
1179 {
1180 LARGE_INTEGER Delay;
1181 Delay.QuadPart = -3000000; // 300 ms
1182 KeDelayExecutionThread(KernelMode, FALSE, &Delay);
1183 }
1184 }
1185 #endif
1186 }
1187
1188 VOID
1189 NTAPI
1190 INIT_FUNCTION
1191 DisplayFilter(PCHAR *String)
1192 {
1193 /* Windows hack to skip first dots */
1194 static BOOLEAN DotHack = TRUE;
1195
1196 /* If "." is given set *String to empty string */
1197 if(DotHack && strcmp(*String, ".") == 0)
1198 *String = "";
1199
1200 if(**String)
1201 {
1202 /* Remove the filter */
1203 InbvInstallDisplayStringFilter(NULL);
1204
1205 DotHack = FALSE;
1206
1207 /* Draw text screen */
1208 DisplayBootBitmap(TRUE);
1209 }
1210 }
1211
1212 VOID
1213 NTAPI
1214 INIT_FUNCTION
1215 FinalizeBootLogo(VOID)
1216 {
1217 /* Acquire lock and check the display state */
1218 InbvAcquireLock();
1219 if (InbvGetDisplayState() == INBV_DISPLAY_STATE_OWNED)
1220 {
1221 /* Clear the screen */
1222 VidSolidColorFill(0, 0, 639, 479, 0);
1223 }
1224
1225 /* Reset progress bar and lock */
1226 #ifdef INBV_ROTBAR_IMPLEMENTED
1227 PltRotBarStatus = RBS_STOP_ANIMATE;
1228 RotBarThreadActive = FALSE;
1229 #endif
1230 InbvReleaseLock();
1231 }