ReactOS  0.4.13-dev-39-g8b6696f
inbv.c
Go to the documentation of this file.
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 
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 {
70 
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
115 
116 
117 /* FADING FUNCTION ***********************************************************/
118 
120 typedef struct tagRGBQUAD
121 {
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 
135 //
136 // Bitmap Header
137 //
138 typedef struct tagBITMAPINFOHEADER
139 {
140  ULONG biSize;
141  LONG biWidth;
142  LONG biHeight;
152 /****************************/
153 
154 //
155 // Needed prototypes
156 //
159 
160 static 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 */
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 */
210  }
211 }
212 
213 /* FUNCTIONS *****************************************************************/
214 
215 INIT_FUNCTION
216 PVOID
217 NTAPI
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;
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,
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,
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  {
271  }
272  if (!NT_SUCCESS(Status)) Data = NULL;
273  }
274  }
275 
276  /* Return the pointer */
277  return Data;
278 }
279 
280 INIT_FUNCTION
281 BOOLEAN
282 NTAPI
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 */
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 */
305  {
306  /* Find bitmap resources in the kernel */
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 */
320 }
321 
322 VOID
323 NTAPI
325 {
326  KIRQL OldIrql;
327 
328  /* Check if we're at dispatch level or lower */
330  if (OldIrql <= DISPATCH_LEVEL)
331  {
332  /* Loop until the lock is free */
333  while (!KeTestSpinLock(&BootDriverLock));
334 
335  /* Raise IRQL to dispatch level */
337  }
338 
339  /* Acquire the lock */
342 }
343 
344 VOID
345 NTAPI
347 {
348  KIRQL OldIrql;
349 
350  /* Capture the old IRQL */
352 
353  /* Release the driver lock */
355 
356  /* If we were at dispatch level or lower, restore the old IRQL */
358 }
359 
360 INIT_FUNCTION
361 VOID
362 NTAPI
364 {
365  /* Check if we're installed */
367  {
368  /* Check for lost state */
370 
371  /* Acquire the lock */
372  InbvAcquireLock();
373 
374  /* Cleanup the screen if we own it */
376 
377  /* Set the new display state */
380 
381  /* Release the lock */
382  InbvReleaseLock();
383  }
384  else
385  {
386  /* Set the new display state */
389  }
390 }
391 
392 VOID
393 NTAPI
395 {
396  /* Check if we have a callback and we're just acquiring it now */
399  {
400  /* Call the callback */
402  }
403 
404  /* Acquire the display */
406 }
407 
408 VOID
409 NTAPI
411 {
412  /* Set the new display state */
413  InbvDisplayState = DisplayOwned ? INBV_DISPLAY_STATE_OWNED :
415 }
416 
417 BOOLEAN
418 NTAPI
420 {
421  /* Return if we own it or not */
423 }
424 
426 NTAPI
428 {
429  /* Return the actual state */
430  return InbvDisplayState;
431 }
432 
433 BOOLEAN
434 NTAPI
436 {
437  /* Make sure we own the display */
439  {
440  /* If we're not allowed, return success anyway */
441  if (!InbvDisplayDebugStrings) return TRUE;
442 
443  /* Check if a filter is installed */
445 
446  /* Acquire the lock */
447  InbvAcquireLock();
448 
449  /* Make sure we're installed and display the string */
451 
452  /* Print the string on the EMS port */
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
473 {
474  BOOLEAN OldSetting;
475 
476  /* Get the old setting */
477  OldSetting = InbvDisplayDebugStrings;
478 
479  /* Update it */
481 
482  /* Return the old setting */
483  return OldSetting;
484 }
485 
486 VOID
487 NTAPI
489 {
490  /* Save the filter */
492 }
493 
494 BOOLEAN
495 NTAPI
497 {
498  /* Return driver state */
500 }
501 
502 VOID
503 NTAPI
505 {
506  /* Check if we're installed */
508  {
509  /* Acquire the lock and cleanup if we own the screen */
510  InbvAcquireLock();
512 
513  /* Set the reset callback and display state */
516 
517  /* Release the lock */
518  InbvReleaseLock();
519  }
520  else
521  {
522  /* Set the reset callback and display state */
525  }
526 }
527 
528 BOOLEAN
529 NTAPI
531 {
532  /* Check if we're installed and we own it */
535  {
536  /* Do the reset */
538  return TRUE;
539  }
540 
541  /* Nothing to reset */
542  return FALSE;
543 }
544 
545 VOID
546 NTAPI
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
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
567 #endif
568  HeadlessSetColor.TextColor = InbvTerminalTextColor;
569  HeadlessSetColor.BkgdColor = InbvTerminalBkgdColor;
571  &HeadlessSetColor,
572  sizeof(HeadlessSetColor),
573  NULL,
574  NULL);
575 
576  /* Update the text color */
578 }
579 
580 VOID
581 NTAPI
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 */
592  {
593  /* Acquire the lock */
594  InbvAcquireLock();
595 
596  /* Check if we're installed */
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
608 #endif
609  HeadlessSetColor.TextColor = InbvTerminalTextColor;
610  HeadlessSetColor.BkgdColor = InbvTerminalBkgdColor;
612  &HeadlessSetColor,
613  sizeof(HeadlessSetColor),
614  NULL,
615  NULL);
617  NULL, 0,
618  NULL, NULL);
619 
620  /* Release the lock */
621  InbvReleaseLock();
622  }
623 }
624 
625 INIT_FUNCTION
626 VOID
627 NTAPI
629 {
630  ULONG FillCount, BoundedProgress;
631 
632  /* Make sure the progress bar is enabled, that we own and are installed */
633  if (ShowProgressBar &&
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 */
647  ProgressBarLeft + FillCount,
648  ProgressBarTop + 12,
649  15);
650 
651  /* Release the lock */
652  InbvReleaseLock();
653  }
654 }
655 
656 VOID
657 NTAPI
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 */
668  {
669  /* Do the blit */
670  VidBufferToScreenBlt(Buffer, X, Y, Width, Height, Delta);
671  }
672 }
673 
674 VOID
675 NTAPI
677  IN ULONG X,
678  IN ULONG Y)
679 {
680  /* Check if we're installed and we own it */
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
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 */
707  {
708  /* Do the blit */
709  VidScreenToBufferBlt(Buffer, X, Y, Width, Height, Delta);
710  }
711 }
712 
713 VOID
714 NTAPI
716  IN ULONG Top)
717 {
718  /* Update the coordinates */
719  ProgressBarLeft = Left;
721 
722  /* Enable the progress bar */
724 }
725 
726 VOID
727 NTAPI
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 INIT_FUNCTION
742 VOID
743 NTAPI
745 {
746  ULONG Percentage;
747 
748  /* Increase progress */
750 
751  /* Compute new percentage */
752  Percentage = min(100 * InbvProgressIndicator.Count /
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
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
777 {
779  UNICODE_STRING CapturedString;
781  ULONG OemLength;
783 
784  PAGED_CODE();
785 
787 
788  /* We require the TCB privilege */
791 
792  /* Capture the string */
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  {
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  {
814  goto Quit;
815  }
816  RtlInitEmptyAnsiString((PANSI_STRING)&OemString, NULL, (USHORT)OemLength);
818  if (OemString.Buffer == NULL)
819  {
821  goto Quit;
822  }
823  RtlUnicodeStringToOemString(&OemString, &CapturedString, FALSE);
824 
825  /* Display the string */
827 
828  /* Free the string buffer */
830 
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
846 {
847  ULONG X, Y, Index, Total;
848  LARGE_INTEGER Delay = {{0}};
849 
850  InbvAcquireLock();
852  {
853  Index = 0;
854  }
855  else
856  {
857  Index = 32;
858  }
859  X = ProgressBarLeft + 2;
860  Y = ProgressBarTop + 2;
861  InbvReleaseLock();
862 
864  {
865  /* Wait for a bit */
867 
868  InbvAcquireLock();
869 
870  /* Unknown unexpected command */
872 
874  {
875  /* Stop the thread */
876  InbvReleaseLock();
877  break;
878  }
879 
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 
931 }
932 
933 INIT_FUNCTION
934 VOID
935 NTAPI
937 {
939  /* Perform other initialization if needed */
940 }
941 #endif
942 
943 INIT_FUNCTION
944 VOID
945 NTAPI
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;
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();
969  InbvReleaseLock();
970  }
971 #endif
972 
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 */
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 */
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 */
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 */
1028 #endif
1029  }
1030  else
1031  {
1032  /* Display correct branding based on server suite */
1034  {
1035  /* Storage Server Edition */
1037  }
1038  else if (ExVerifySuite(ComputeServer))
1039  {
1040  /* Compute Cluster Edition */
1042  }
1043  else
1044  {
1045  /* Normal edition */
1047  }
1048 
1049 #ifdef INBV_ROTBAR_IMPLEMENTED
1050  /* Server product, use appropriate status bar color */
1052 #endif
1053  }
1054 #else
1055  /* Use default status bar */
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 */
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  {
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 */
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,
1153  NULL);
1154  if (NT_SUCCESS(Status))
1155  {
1156  /* The thread has started, close the handle as we don't need it */
1158  ObCloseHandle(ThreadHandle, KernelMode);
1159  }
1160  }
1161 #endif
1162 
1163  /* Set filter which will draw text display if needed */
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
1183  }
1184  }
1185 #endif
1186 }
1187 
1188 INIT_FUNCTION
1189 VOID
1190 NTAPI
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 */
1204 
1205  DotHack = FALSE;
1206 
1207  /* Draw text screen */
1209  }
1210 }
1211 
1212 INIT_FUNCTION
1213 VOID
1214 NTAPI
1216 {
1217  /* Acquire lock and check the display state */
1218  InbvAcquireLock();
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
1229 #endif
1230  InbvReleaseLock();
1231 }
_ROT_BAR_STATUS
Definition: inbv.c:63
static __inline NTSTATUS ProbeAndCaptureUnicodeString(OUT PUNICODE_STRING Dest, IN KPROCESSOR_MODE CurrentMode, IN const UNICODE_STRING *UnsafeSrc)
Definition: probe.h:142
VOID NTAPI InbvSetProgressBarCoordinates(IN ULONG Left, IN ULONG Top)
Definition: inbv.c:715
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
signed char * PCHAR
Definition: retypes.h:7
VOID NTAPI InbvSetProgressBarSubset(IN ULONG Floor, IN ULONG Ceiling)
Definition: inbv.c:728
*BytesInOemString PCHAR OemString
Definition: rtlfuncs.h:1561
static ULONG InbvTerminalTextColor
Definition: inbv.c:113
VOID NTAPI InbvNotifyDisplayOwnershipLost(IN INBV_RESET_DISPLAY_PARAMETERS Callback)
Definition: inbv.c:504
static BT_PROGRESS_INDICATOR InbvProgressIndicator
Definition: inbv.c:45
#define IN
Definition: typedefs.h:38
#define IDB_SERVER_FOOTER
Definition: resource.h:22
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define KeRaiseIrql(irql, oldIrql)
Definition: env_spec_w32.h:597
INBV_DISPLAY_STATE NTAPI InbvGetDisplayState(VOID)
Definition: inbv.c:427
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
struct tagBITMAPINFOHEADER * PBITMAPINFOHEADER
#define KeLowerIrql(oldIrql)
Definition: env_spec_w32.h:602
static VOID BootLogoFadeIn(VOID)
Definition: inbv.c:161
#define IDB_BAR_SERVER
Definition: resource.h:10
#define Y(I)
USHORT biBitCount
Definition: precomp.h:25
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
LONG biXPelsPerMeter
Definition: precomp.h:28
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
BOOLEAN NTAPI InbvDisplayString(IN PCHAR String)
Definition: inbv.c:435
static INBV_RESET_DISPLAY_PARAMETERS InbvResetDisplayParameters
Definition: inbv.c:46
INIT_FUNCTION VOID NTAPI InbvUpdateProgressBar(IN ULONG Progress)
Definition: inbv.c:628
unsigned char * PUCHAR
Definition: retypes.h:3
INIT_FUNCTION VOID NTAPI InbvIndicateProgress(VOID)
Definition: inbv.c:744
BOOLEAN NTAPI VidInitialize(IN BOOLEAN SetMode)
Definition: bootvid.c:278
LONG NTSTATUS
Definition: precomp.h:26
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:140
VOID NTAPI InbvBufferToScreenBlt(IN PUCHAR Buffer, IN ULONG X, IN ULONG Y, IN ULONG Width, IN ULONG Height, IN ULONG Delta)
Definition: inbv.c:658
#define PALETTE_FADE_STEPS
Definition: inbv.c:131
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
VOID NTAPI InbvSolidColorFill(IN ULONG Left, IN ULONG Top, IN ULONG Right, IN ULONG Bottom, IN ULONG Color)
Definition: inbv.c:582
BOOLEAN NTAPI SeSinglePrivilegeCheck(IN LUID PrivilegeValue, IN KPROCESSOR_MODE PreviousMode)
Definition: priv.c:524
INIT_FUNCTION VOID NTAPI InbvEnableBootDriver(IN BOOLEAN Enable)
Definition: inbv.c:363
enum _ROT_BAR_TYPE ROT_BAR_TYPE
ULONG biCompression
Definition: precomp.h:26
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:2966
#define TAG_OSTR
Definition: inbv.c:9
static WCHAR String[]
Definition: stringtable.c:55
#define PALETTE_FADE_TIME
Definition: inbv.c:132
enum _INBV_DISPLAY_STATE INBV_DISPLAY_STATE
STRING OEM_STRING
Definition: umtypes.h:203
#define IDB_MAX_RESOURCE
Definition: resource.h:26
BOOLEAN NTAPI ExVerifySuite(SUITE_TYPE SuiteType)
Definition: sysinfo.c:377
NTSYSAPI DWORD WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING *)
static UCHAR RotBarBuffer[24 *9]
Definition: inbv.c:74
ULONG_PTR Type
Definition: ldrtypes.h:180
UCHAR rgbBlue
Definition: inbv.c:122
#define PAGED_CODE()
Definition: video.h:57
NTSTATUS NTAPI HeadlessDispatch(IN HEADLESS_CMD Command, IN PVOID InputBuffer, IN SIZE_T InputBufferSize, OUT PVOID OutputBuffer, OUT PSIZE_T OutputBufferSize)
Definition: hdlsterm.c:570
static PUCHAR ResourceList[1+IDB_MAX_RESOURCE]
Definition: inbv.c:48
UCHAR rgbGreen
Definition: inbv.c:123
#define IDB_BOOT_SCREEN
Definition: resource.h:3
VOID NTAPI InbvReleaseLock(VOID)
Definition: inbv.c:346
PVOID DllBase
Definition: btrfs_drv.h:1805
UCHAR rgbRed
Definition: inbv.c:124
struct tagBITMAPINFOHEADER BITMAPINFOHEADER
UCHAR KIRQL
Definition: env_spec_w32.h:591
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
NTSTATUS NTAPI NtDisplayString(IN PUNICODE_STRING DisplayString)
Definition: inbv.c:776
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define ANSI_NULL
Definition: Header.h:8
VOID FASTCALL KiReleaseSpinLock(IN PKSPIN_LOCK SpinLock)
Definition: ntoskrnl.c:39
static UCHAR RotLineBuffer[640 *6]
Definition: inbv.c:75
long LONG
Definition: pedump.c:60
_Must_inspect_result_ _In_opt_ PFLT_FILTER Filter
Definition: fltkernel.h:1802
#define IDB_SERVER_LOGO
Definition: resource.h:20
NTSTATUS NTAPI KeDelayExecutionThread(IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Interval OPTIONAL)
Definition: wait.c:283
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
unsigned char BOOLEAN
ULONG_PTR Name
Definition: ldrtypes.h:181
VOID NTAPI VidDisplayString(IN PUCHAR String)
Definition: bootvid.c:425
smooth NULL
Definition: ftsmooth.c:416
_In_ LPGUID _In_ PVOID Data
Definition: classpnp.h:778
static BOOLEAN InbvDisplayDebugStrings
Definition: inbv.c:40
VOID NTAPI VidCleanUp(VOID)
Definition: bootvid.c:398
VOID NTAPI InbvAcquireLock(VOID)
Definition: inbv.c:324
static ROT_BAR_STATUS PltRotBarStatus
Definition: inbv.c:73
Definition: pedump.c:457
enum _ROT_BAR_STATUS ROT_BAR_STATUS
Definition: bufpool.h:45
VOID NTAPI InbvSetDisplayOwnership(IN BOOLEAN DisplayOwned)
Definition: inbv.c:410
NTSTATUS NTAPI LdrFindResource_U(_In_ PVOID BaseAddress, _In_ PLDR_RESOURCE_INFO ResourceInfo, _In_ ULONG Level, _Out_ PIMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry)
INIT_FUNCTION PVOID NTAPI FindBitmapResource(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG ResourceId)
Definition: inbv.c:218
static ULONG ProgressBarLeft
Definition: inbv.c:42
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
VOID NTAPI InbvSetTextColor(IN ULONG Color)
Definition: inbv.c:558
#define IDB_STORAGE_SERVER
Definition: resource.h:23
INIT_FUNCTION VOID NTAPI InbvRotBarInit(VOID)
Definition: inbv.c:936
NTSTATUS NTAPI LdrAccessResource(_In_ PVOID BaseAddress, _In_ PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry, _Out_opt_ PVOID *Resource, _Out_opt_ PULONG Size)
BOOLEAN FASTCALL KeTestSpinLock(IN PKSPIN_LOCK SpinLock)
Definition: spinlock.c:442
ULONG biClrImportant
Definition: precomp.h:31
struct tagRGBQUAD RGBQUAD
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
static __inline VOID ReleaseCapturedUnicodeString(IN PUNICODE_STRING CapturedString, IN KPROCESSOR_MODE CurrentMode)
Definition: probe.h:228
_In_ KPROCESSOR_MODE PreviousMode
Definition: sefuncs.h:103
VOID NTAPI VidResetDisplay(IN BOOLEAN HalReset)
Definition: bootvid.c:313
static INBV_PROGRESS_STATE InbvProgressState
Definition: inbv.c:44
static VOID NTAPI InbvRotationThread(_In_ PVOID Context)
Definition: inbv.c:844
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ROT_BAR_DEFAULT_MODE
Definition: inbv.c:54
static KIRQL InbvOldIrql
Definition: inbv.c:37
INIT_FUNCTION BOOLEAN NTAPI InbvDriverInitialize(IN PLOADER_PARAMETER_BLOCK LoaderBlock, IN ULONG Count)
Definition: inbv.c:283
static const UCHAR Index[8]
Definition: usbohci.c:18
ULONG_PTR KiBugCheckData[5]
Definition: bug.c:30
INIT_FUNCTION VOID NTAPI DisplayFilter(PCHAR *String)
Definition: inbv.c:1191
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
VOID NTAPI InbvAcquireDisplayOwnership(VOID)
Definition: inbv.c:394
static ULONG ResourceCount
Definition: inbv.c:47
#define SharedUserData
VOID NTAPI VidScreenToBufferBlt(IN PUCHAR Buffer, IN ULONG Left, IN ULONG Top, IN ULONG Width, IN ULONG Height, IN ULONG Delta)
Definition: bootvid.c:522
unsigned char UCHAR
Definition: xmlstorage.h:181
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3376
static const WCHAR L[]
Definition: oid.c:1250
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
VOID NTAPI VidBitBlt(IN PUCHAR Buffer, IN ULONG Left, IN ULONG Top)
Definition: bootvid.c:509
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToOemString(POEM_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
Definition: btrfs_drv.h:1801
VOID(NTAPI * INBV_DISPLAY_STRING_FILTER)(PCHAR *Str)
Definition: inbvtypes.h:50
Definition: typedefs.h:117
static INBV_DISPLAY_STRING_FILTER InbvDisplayFilter
Definition: inbv.c:41
static ROT_BAR_TYPE RotBarSelection
Definition: inbv.c:72
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
VOID DisplayString(LPWSTR Msg)
Definition: misc.c:211
Status
Definition: gdiplustypes.h:24
const LUID SeTcbPrivilege
Definition: priv.c:28
LONG biYPelsPerMeter
Definition: precomp.h:29
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
BOOLEAN NTAPI InbvEnableDisplayString(IN BOOLEAN Enable)
Definition: inbv.c:472
#define _In_
Definition: no_sal2.h:204
BOOLEAN NTAPI InbvIsBootDriverInstalled(VOID)
Definition: inbv.c:496
VOID NTAPI VidSolidColorFill(IN ULONG Left, IN ULONG Top, IN ULONG Right, IN ULONG Bottom, IN UCHAR Color)
Definition: bootvid.c:538
ULONG NTAPI VidSetTextColor(IN ULONG Color)
Definition: bootvid.c:338
#define RESOURCE_DATA_LEVEL
Definition: ldrtypes.h:33
BOOLEAN ExpInTextModeSetup
Definition: init.c:66
BOOLEAN NTAPI InbvResetDisplay(VOID)
Definition: inbv.c:530
_CRTIMP char *__cdecl _strupr(_Inout_z_ char *_String)
NTSYSAPI ULONG NTAPI RtlComputeCrc32(_In_ ULONG InitialCrc, _In_ PUCHAR Buffer, _In_ ULONG Length)
static LPHIST_ENTRY Bottom
Definition: history.c:54
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
#define IDB_WKSTA_FOOTER
Definition: resource.h:8
static BOOLEAN RotBarThreadActive
Definition: inbv.c:71
unsigned short USHORT
Definition: pedump.c:61
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
NTSTATUS NTAPI PsTerminateSystemThread(IN NTSTATUS ExitStatus)
Definition: kill.c:1144
static ULONG Delta
Definition: xboxvideo.c:28
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
VOID FASTCALL KiAcquireSpinLock(IN PKSPIN_LOCK SpinLock)
Definition: ntoskrnl.c:32
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
UNICODE_STRING BaseDllName
Definition: ldrtypes.h:144
VOID NTAPI InbvBitBlt(IN PUCHAR Buffer, IN ULONG X, IN ULONG Y)
Definition: inbv.c:676
#define min(a, b)
Definition: monoChain.cc:55
VOID NTAPI InbvInstallDisplayStringFilter(IN INBV_DISPLAY_STRING_FILTER Filter)
Definition: inbv.c:488
#define MAXUSHORT
Definition: typedefs.h:81
ULONG_PTR Language
Definition: ldrtypes.h:182
INIT_FUNCTION VOID NTAPI DisplayBootBitmap(IN BOOLEAN TextMode)
Definition: inbv.c:946
VOID NTAPI InbvScreenToBufferBlt(IN PUCHAR Buffer, IN ULONG X, IN ULONG Y, IN ULONG Width, IN ULONG Height, IN ULONG Delta)
Definition: inbv.c:697
ULONG Ceiling
Definition: inbv.h:6
static INBV_DISPLAY_STATE InbvDisplayState
Definition: inbv.c:38
#define IDB_ROTATING_LINE
Definition: resource.h:13
VOID NTAPI VidBufferToScreenBlt(IN PUCHAR Buffer, IN ULONG Left, IN ULONG Top, IN ULONG Width, IN ULONG Height, IN ULONG Delta)
Definition: bootvid.c:409
#define IDB_BAR_WKSTA
Definition: resource.h:11
unsigned int ULONG
Definition: retypes.h:1
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static ULONG InbvTerminalBkgdColor
Definition: inbv.c:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
Definition: console.h:34
static ULONG ProgressBarTop
Definition: inbv.c:42
PUCHAR NTAPI InbvGetResourceAddress(IN ULONG ResourceNumber)
Definition: inbv.c:765
UCHAR rgbReserved
Definition: inbv.c:125
static KSPIN_LOCK BootDriverLock
Definition: inbv.c:36
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
BOOLEAN InbvBootDriverInstalled
Definition: inbv.c:39
VOID NTAPI InbvSetScrollRegion(IN ULONG Left, IN ULONG Top, IN ULONG Right, IN ULONG Bottom)
Definition: inbv.c:547
BOOLEAN NTAPI InbvCheckDisplayOwnership(VOID)
Definition: inbv.c:419
return STATUS_SUCCESS
Definition: btrfs.c:2725
BOOLEAN(NTAPI * INBV_RESET_DISPLAY_PARAMETERS)(ULONG Cols, ULONG Rows)
Definition: inbvtypes.h:43
LPFNPSPCALLBACK Callback
Definition: desk.c:111
static RGBQUAD MainPalette[16]
Definition: inbv.c:129
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
static LPHIST_ENTRY Top
Definition: history.c:53
INIT_FUNCTION VOID NTAPI FinalizeBootLogo(VOID)
Definition: inbv.c:1215
#define IDB_CLUSTER_SERVER
Definition: resource.h:24
static BOOLEAN ShowProgressBar
Definition: inbv.c:43
#define IDB_WKSTA_HEADER
Definition: resource.h:7
#define X(b, s)
char * Text
Definition: combotst.c:136
#define IDB_SERVER_HEADER
Definition: resource.h:21
LONGLONG QuadPart
Definition: typedefs.h:112
VOID NTAPI VidSetScrollRegion(IN ULONG Left, IN ULONG Top, IN ULONG Right, IN ULONG Bottom)
Definition: bootvid.c:373
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
struct tagRGBQUAD * LPRGBQUAD