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 /* GLOBALS *******************************************************************/
   9
  10 KSPIN_LOCK BootDriverLock;
  11 KIRQL InbvOldIrql;
  12 INBV_DISPLAY_STATE InbvDisplayState;
  13 BOOLEAN InbvBootDriverInstalled = FALSE;
  14 BOOLEAN InbvDisplayDebugStrings = FALSE;
  15 INBV_DISPLAY_STRING_FILTER InbvDisplayFilter;
  16 ULONG ProgressBarLeft, ProgressBarTop;
  17 BOOLEAN ShowProgressBar = FALSE;
  18 INBV_PROGRESS_STATE InbvProgressState;
  19 INBV_RESET_DISPLAY_PARAMETERS InbvResetDisplayParameters;
  20 ULONG ResourceCount;
  21 PUCHAR ResourceList[64];
  22 BOOLEAN SysThreadCreated = FALSE;
  23 ROT_BAR_TYPE RotBarSelection;
  24 ULONG PltRotBarStatus;
  25 BT_PROGRESS_INDICATOR InbvProgressIndicator = {0, 25, 0};
  26
  27 /* FADING FUNCTION ***********************************************************/
  28
  29 /** From include/psdk/wingdi.h **/
  30 typedef struct tagRGBQUAD
  31 {
  32     UCHAR    rgbBlue;
  33     UCHAR    rgbGreen;
  34     UCHAR    rgbRed;
  35     UCHAR    rgbReserved;
  36 } RGBQUAD,*LPRGBQUAD;
  37 /*******************************/
  38
  39 static RGBQUAD _MainPalette[16];
  40
  41 #define PALETTE_FADE_STEPS  15
  42 #define PALETTE_FADE_TIME   20 * 1000 /* 20ms */
  43
  44 /** From bootvid/precomp.h **/
  45 //
  46 // Bitmap Header
  47 //
  48 typedef struct tagBITMAPINFOHEADER
  49 {
  50     ULONG biSize;
  51     LONG biWidth;
  52     LONG biHeight;
  53     USHORT biPlanes;
  54     USHORT biBitCount;
  55     ULONG biCompression;
  56     ULONG biSizeImage;
  57     LONG biXPelsPerMeter;
  58     LONG biYPelsPerMeter;
  59     ULONG biClrUsed;
  60     ULONG biClrImportant;
  61 } BITMAPINFOHEADER, *PBITMAPINFOHEADER;
  62 /****************************/
  63
  64 //
  65 // Needed prototypes
  66 //
  67 VOID NTAPI InbvAcquireLock(VOID);
  68 VOID NTAPI InbvReleaseLock(VOID);
  69
  70 static VOID
  71 NTAPI
  72 BootImageFadeIn(VOID)
  73 {
  74     UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) + sizeof(_MainPalette)];
  75     PBITMAPINFOHEADER PaletteBitmap = (PBITMAPINFOHEADER)PaletteBitmapBuffer;
  76     LPRGBQUAD Palette = (LPRGBQUAD)(PaletteBitmapBuffer + sizeof(BITMAPINFOHEADER));
  77
  78     ULONG Iteration, Index, ClrUsed;
  79
  80     /* Check if we're installed and we own it */
  81     if ((InbvBootDriverInstalled) &&
  82         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
  83     {
  84         /* Acquire the lock */
  85         InbvAcquireLock();
  86
  87         /*
  88          * Build a bitmap containing the fade in palette. The palette entries
  89          * are then processed in a loop and set using VidBitBlt function.
  90          */
  91         ClrUsed = sizeof(_MainPalette) / sizeof(_MainPalette[0]);
  92         RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
  93         PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
  94         PaletteBitmap->biBitCount = 4;
  95         PaletteBitmap->biClrUsed = ClrUsed;
  96
  97         /*
  98          * Main animation loop.
  99          */
 100         for (Iteration = 0; Iteration <= PALETTE_FADE_STEPS; ++Iteration)
 101         {
 102             for (Index = 0; Index < ClrUsed; Index++)
 103             {
 104                 Palette[Index].rgbRed = (UCHAR)
 105                     (_MainPalette[Index].rgbRed * Iteration / PALETTE_FADE_STEPS);
 106                 Palette[Index].rgbGreen = (UCHAR)
 107                     (_MainPalette[Index].rgbGreen * Iteration / PALETTE_FADE_STEPS);
 108                 Palette[Index].rgbBlue = (UCHAR)
 109                     (_MainPalette[Index].rgbBlue * Iteration / PALETTE_FADE_STEPS);
 110             }
 111
 112             VidBitBlt(PaletteBitmapBuffer, 0, 0);
 113
 114             /* Wait for a bit. */
 115             KeStallExecutionProcessor(PALETTE_FADE_TIME);
 116         }
 117
 118         /* Release the lock */
 119         InbvReleaseLock();
 120
 121         /* Wait for a bit. */
 122         KeStallExecutionProcessor(PALETTE_FADE_TIME);
 123     }
 124 }
 125
 126 /* FUNCTIONS *****************************************************************/
 127
 128 PVOID
 129 NTAPI
 130 INIT_FUNCTION
 131 FindBitmapResource(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 132                    IN ULONG ResourceId)
 133 {
 134     UNICODE_STRING UpString = RTL_CONSTANT_STRING(L"ntoskrnl.exe");
 135     UNICODE_STRING MpString = RTL_CONSTANT_STRING(L"ntkrnlmp.exe");
 136     PLIST_ENTRY NextEntry, ListHead;
 137     PLDR_DATA_TABLE_ENTRY LdrEntry;
 138     PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
 139     LDR_RESOURCE_INFO ResourceInfo;
 140     NTSTATUS Status;
 141     PVOID Data = NULL;
 142
 143     /* Loop the driver list */
 144     ListHead = &LoaderBlock->LoadOrderListHead;
 145     NextEntry = ListHead->Flink;
 146     while (NextEntry != ListHead)
 147     {
 148         /* Get the entry */
 149         LdrEntry = CONTAINING_RECORD(NextEntry,
 150                                      LDR_DATA_TABLE_ENTRY,
 151                                      InLoadOrderLinks);
 152
 153         /* Check for a match */
 154         if ((RtlEqualUnicodeString(&LdrEntry->BaseDllName, &UpString, TRUE)) ||
 155             (RtlEqualUnicodeString(&LdrEntry->BaseDllName, &MpString, TRUE)))
 156         {
 157             /* Break out */
 158             break;
 159         }
 160     }
 161
 162     /* Check if we found it */
 163     if (NextEntry != ListHead)
 164     {
 165         /* Try to find the resource */
 166         ResourceInfo.Type = 2; //RT_BITMAP;
 167         ResourceInfo.Name = ResourceId;
 168         ResourceInfo.Language = 0;
 169         Status = LdrFindResource_U(LdrEntry->DllBase,
 170                                    &ResourceInfo,
 171                                    RESOURCE_DATA_LEVEL,
 172                                    &ResourceDataEntry);
 173         if (NT_SUCCESS(Status))
 174         {
 175             /* Access the resource */
 176             ULONG Size = 0;
 177             Status = LdrAccessResource(LdrEntry->DllBase,
 178                                        ResourceDataEntry,
 179                                        &Data,
 180                                        &Size);
 181             if ((Data) && (ResourceId < 3))
 182             {
 183                 KiBugCheckData[4] ^= RtlComputeCrc32(0, Data, Size);
 184             }
 185             if (!NT_SUCCESS(Status)) Data = NULL;
 186         }
 187     }
 188
 189     /* Return the pointer */
 190     return Data;
 191 }
 192
 193 BOOLEAN
 194 NTAPI
 195 INIT_FUNCTION
 196 InbvDriverInitialize(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
 197                      IN ULONG Count)
 198 {
 199     PCHAR CommandLine;
 200     BOOLEAN CustomLogo = FALSE;
 201     ULONG i;
 202
 203     /* Quit if we're already installed */
 204     if (InbvBootDriverInstalled) return TRUE;
 205
 206     /* Initialize the lock and check the current display state */
 207     KeInitializeSpinLock(&BootDriverLock);
 208     if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
 209     {
 210         /* Check if we have a custom boot logo */
 211         CommandLine = _strupr(LoaderBlock->LoadOptions);
 212         CustomLogo = strstr(CommandLine, "BOOTLOGO") ? TRUE: FALSE;
 213     }
 214
 215     /* Initialize the video */
 216     InbvBootDriverInstalled = VidInitialize(FALSE);
 217     if (InbvBootDriverInstalled)
 218     {
 219         /* Now reset the display, but only if there's a custom boot logo */
 220         VidResetDisplay(CustomLogo);
 221
 222         /* Find bitmap resources in the kernel */
 223         ResourceCount = min(IDB_CLUSTER_SERVER, Count);
 224         for (i = 1; i <= Count; i++)
 225         {
 226             /* Do the lookup */
 227             ResourceList[i] = FindBitmapResource(LoaderBlock, i);
 228         }
 229
 230         /* Set the progress bar ranges */
 231         InbvSetProgressBarSubset(0, 100);
 232     }
 233
 234     /* Return install state */
 235     return InbvBootDriverInstalled;
 236 }
 237
 238 VOID
 239 NTAPI
 240 InbvAcquireLock(VOID)
 241 {
 242     KIRQL OldIrql;
 243
 244     /* Check if we're at dispatch level or lower */
 245     OldIrql = KeGetCurrentIrql();
 246     if (OldIrql <= DISPATCH_LEVEL)
 247     {
 248         /* Loop until the lock is free */
 249         while (!KeTestSpinLock(&BootDriverLock));
 250
 251         /* Raise IRQL to dispatch level */
 252         KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 253     }
 254
 255     /* Acquire the lock */
 256     KiAcquireSpinLock(&BootDriverLock);
 257     InbvOldIrql = OldIrql;
 258 }
 259
 260 VOID
 261 NTAPI
 262 InbvReleaseLock(VOID)
 263 {
 264     KIRQL OldIrql;
 265
 266     /* Capture the old IRQL */
 267     OldIrql = InbvOldIrql;
 268
 269     /* Release the driver lock */
 270     KiReleaseSpinLock(&BootDriverLock);
 271
 272     /* If we were at dispatch level or lower, restore the old IRQL */
 273     if (InbvOldIrql <= DISPATCH_LEVEL) KeLowerIrql(OldIrql);
 274 }
 275
 276 VOID
 277 NTAPI
 278 INIT_FUNCTION
 279 InbvEnableBootDriver(IN BOOLEAN Enable)
 280 {
 281     /* Check if we're installed */
 282     if (InbvBootDriverInstalled)
 283     {
 284         /* Check for lost state */
 285         if (InbvDisplayState >= INBV_DISPLAY_STATE_LOST) return;
 286
 287         /* Acquire the lock */
 288         InbvAcquireLock();
 289
 290         /* Cleanup the screen if we own it */
 291         if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED) VidCleanUp();
 292
 293         /* Set the new display state */
 294         InbvDisplayState = Enable ? INBV_DISPLAY_STATE_OWNED:
 295                                     INBV_DISPLAY_STATE_DISABLED;
 296
 297         /* Release the lock */
 298         InbvReleaseLock();
 299     }
 300     else
 301     {
 302         /* Set the new display state */
 303         InbvDisplayState = Enable ? INBV_DISPLAY_STATE_OWNED:
 304                                     INBV_DISPLAY_STATE_DISABLED;
 305     }
 306 }
 307
 308 VOID
 309 NTAPI
 310 InbvAcquireDisplayOwnership(VOID)
 311 {
 312     /* Check if we have a callback and we're just acquiring it now */
 313     if ((InbvResetDisplayParameters) &&
 314         (InbvDisplayState == INBV_DISPLAY_STATE_LOST))
 315     {
 316         /* Call the callback */
 317         InbvResetDisplayParameters(80, 50);
 318     }
 319
 320     /* Acquire the display */
 321     InbvDisplayState = INBV_DISPLAY_STATE_OWNED;
 322 }
 323
 324 VOID
 325 NTAPI
 326 InbvSetDisplayOwnership(IN BOOLEAN DisplayOwned)
 327 {
 328     /* Set the new display state */
 329     InbvDisplayState = DisplayOwned ? INBV_DISPLAY_STATE_OWNED:
 330                                       INBV_DISPLAY_STATE_LOST;
 331 }
 332
 333 BOOLEAN
 334 NTAPI
 335 InbvCheckDisplayOwnership(VOID)
 336 {
 337     /* Return if we own it or not */
 338     return InbvDisplayState != INBV_DISPLAY_STATE_LOST;
 339 }
 340
 341 INBV_DISPLAY_STATE
 342 NTAPI
 343 InbvGetDisplayState(VOID)
 344 {
 345     /* Return the actual state */
 346     return InbvDisplayState;
 347 }
 348
 349 BOOLEAN
 350 NTAPI
 351 InbvDisplayString(IN PCHAR String)
 352 {
 353     /* Make sure we own the display */
 354     if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
 355     {
 356         /* If we're not allowed, return success anyway */
 357         if (!InbvDisplayDebugStrings) return TRUE;
 358
 359         /* Check if a filter is installed */
 360         if (InbvDisplayFilter) InbvDisplayFilter(&String);
 361
 362         /* Acquire the lock */
 363         InbvAcquireLock();
 364
 365         /* Make sure we're installed and display the string */
 366         if (InbvBootDriverInstalled) VidDisplayString((PUCHAR)String);
 367
 368         /* Print the string on the EMS port */
 369         HeadlessDispatch(HeadlessCmdPutString,
 370                          String,
 371                          strlen(String) + sizeof(ANSI_NULL),
 372                          NULL,
 373                          NULL);
 374
 375         /* Release the lock */
 376         InbvReleaseLock();
 377
 378         /* All done */
 379         return TRUE;
 380     }
 381
 382     /* We don't own it, fail */
 383     return FALSE;
 384 }
 385
 386 BOOLEAN
 387 NTAPI
 388 InbvEnableDisplayString(IN BOOLEAN Enable)
 389 {
 390     BOOLEAN OldSetting;
 391
 392     /* Get the old setting */
 393     OldSetting = InbvDisplayDebugStrings;
 394
 395     /* Update it */
 396     InbvDisplayDebugStrings = Enable;
 397
 398     /* Return the old setting */
 399     return OldSetting;
 400 }
 401
 402 VOID
 403 NTAPI
 404 InbvInstallDisplayStringFilter(IN INBV_DISPLAY_STRING_FILTER Filter)
 405 {
 406     /* Save the filter */
 407     InbvDisplayFilter = Filter;
 408 }
 409
 410 BOOLEAN
 411 NTAPI
 412 InbvIsBootDriverInstalled(VOID)
 413 {
 414     /* Return driver state */
 415     return InbvBootDriverInstalled;
 416 }
 417
 418 VOID
 419 NTAPI
 420 InbvNotifyDisplayOwnershipLost(IN INBV_RESET_DISPLAY_PARAMETERS Callback)
 421 {
 422     /* Check if we're installed */
 423     if (InbvBootDriverInstalled)
 424     {
 425         /* Acquire the lock and cleanup if we own the screen */
 426         InbvAcquireLock();
 427         if (InbvDisplayState != INBV_DISPLAY_STATE_LOST) VidCleanUp();
 428
 429         /* Set the reset callback and display state */
 430         InbvResetDisplayParameters = Callback;
 431         InbvDisplayState = INBV_DISPLAY_STATE_LOST;
 432
 433         /* Release the lock */
 434         InbvReleaseLock();
 435     }
 436     else
 437     {
 438         /* Set the reset callback and display state */
 439         InbvResetDisplayParameters = Callback;
 440         InbvDisplayState = INBV_DISPLAY_STATE_LOST;
 441     }
 442 }
 443
 444 BOOLEAN
 445 NTAPI
 446 InbvResetDisplay(VOID)
 447 {
 448     /* Check if we're installed and we own it */
 449     if ((InbvBootDriverInstalled) &&
 450         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
 451     {
 452         /* Do the reset */
 453         VidResetDisplay(TRUE);
 454         return TRUE;
 455     }
 456
 457     /* Nothing to reset */
 458     return FALSE;
 459 }
 460
 461 VOID
 462 NTAPI
 463 InbvSetScrollRegion(IN ULONG Left,
 464                     IN ULONG Top,
 465                     IN ULONG Right,
 466                     IN ULONG Bottom)
 467 {
 468     /* Just call bootvid */
 469     VidSetScrollRegion(Left, Top, Right, Bottom);
 470 }
 471
 472 VOID
 473 NTAPI
 474 InbvSetTextColor(IN ULONG Color)
 475 {
 476     /* FIXME: Headless */
 477
 478     /* Update the text color */
 479     VidSetTextColor(Color);
 480 }
 481
 482 VOID
 483 NTAPI
 484 InbvSolidColorFill(IN ULONG Left,
 485                    IN ULONG Top,
 486                    IN ULONG Right,
 487                    IN ULONG Bottom,
 488                    IN ULONG Color)
 489 {
 490     /* Make sure we own it */
 491     if (InbvDisplayState == INBV_DISPLAY_STATE_OWNED)
 492     {
 493         /* Acquire the lock */
 494         InbvAcquireLock();
 495
 496         /* Check if we're installed */
 497         if (InbvBootDriverInstalled)
 498         {
 499             /* Call bootvid */
 500             VidSolidColorFill(Left, Top, Right, Bottom, (UCHAR)Color);
 501         }
 502
 503         /* FIXME: Headless */
 504
 505         /* Release the lock */
 506         InbvReleaseLock();
 507     }
 508 }
 509
 510 VOID
 511 NTAPI
 512 INIT_FUNCTION
 513 InbvUpdateProgressBar(IN ULONG Progress)
 514 {
 515     ULONG FillCount, BoundedProgress;
 516
 517     /* Make sure the progress bar is enabled, that we own and are installed */
 518     if ((ShowProgressBar) &&
 519         (InbvBootDriverInstalled) &&
 520         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
 521     {
 522         /* Compute fill count */
 523         BoundedProgress = (InbvProgressState.Floor / 100) + Progress;
 524         FillCount = 121 * (InbvProgressState.Bias * BoundedProgress) / 1000000;
 525
 526         /* Acquire the lock */
 527         InbvAcquireLock();
 528
 529         /* Fill the progress bar */
 530         VidSolidColorFill(ProgressBarLeft,
 531                           ProgressBarTop,
 532                           ProgressBarLeft + FillCount,
 533                           ProgressBarTop + 12,
 534                           15);
 535
 536         /* Release the lock */
 537         InbvReleaseLock();
 538     }
 539 }
 540
 541 VOID
 542 NTAPI
 543 InbvBufferToScreenBlt(IN PUCHAR Buffer,
 544                       IN ULONG X,
 545                       IN ULONG Y,
 546                       IN ULONG Width,
 547                       IN ULONG Height,
 548                       IN ULONG Delta)
 549 {
 550     /* Check if we're installed and we own it */
 551     if ((InbvBootDriverInstalled) &&
 552         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
 553     {
 554         /* Do the blit */
 555         VidBufferToScreenBlt(Buffer, X, Y, Width, Height, Delta);
 556     }
 557 }
 558
 559 VOID
 560 NTAPI
 561 InbvBitBlt(IN PUCHAR Buffer,
 562            IN ULONG X,
 563            IN ULONG Y)
 564 {
 565     /* Check if we're installed and we own it */
 566     if ((InbvBootDriverInstalled) &&
 567         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
 568     {
 569         /* Acquire the lock */
 570         InbvAcquireLock();
 571
 572         /* Do the blit */
 573         VidBitBlt(Buffer, X, Y);
 574
 575         /* Release the lock */
 576         InbvReleaseLock();
 577     }
 578 }
 579
 580 VOID
 581 NTAPI
 582 InbvScreenToBufferBlt(IN PUCHAR Buffer,
 583                       IN ULONG X,
 584                       IN ULONG Y,
 585                       IN ULONG Width,
 586                       IN ULONG Height,
 587                       IN ULONG Delta)
 588 {
 589     /* Check if we're installed and we own it */
 590     if ((InbvBootDriverInstalled) &&
 591         (InbvDisplayState == INBV_DISPLAY_STATE_OWNED))
 592     {
 593         /* Do the blit */
 594         VidScreenToBufferBlt(Buffer, X, Y, Width, Height, Delta);
 595     }
 596 }
 597
 598 VOID
 599 NTAPI
 600 InbvSetProgressBarCoordinates(IN ULONG Left,
 601                               IN ULONG Top)
 602 {
 603     /* Update the coordinates */
 604     ProgressBarLeft = Left;
 605     ProgressBarTop = Top;
 606
 607     /* Enable the progress bar */
 608     ShowProgressBar = TRUE;
 609 }
 610
 611 VOID
 612 NTAPI
 613 InbvSetProgressBarSubset(IN ULONG Floor,
 614                          IN ULONG Ceiling)
 615 {
 616     /* Sanity checks */
 617     ASSERT(Floor < Ceiling);
 618     ASSERT(Ceiling <= 100);
 619
 620     /* Update the progress bar state */
 621     InbvProgressState.Floor = Floor * 100;
 622     InbvProgressState.Ceiling = Ceiling * 100;
 623     InbvProgressState.Bias = (Ceiling * 100) - Floor;
 624 }
 625
 626 VOID
 627 NTAPI
 628 INIT_FUNCTION
 629 InbvIndicateProgress(VOID)
 630 {
 631     ULONG Percentage;
 632
 633     /* Increase progress */
 634     InbvProgressIndicator.Count++;
 635
 636     /* Compute new percentage */
 637     Percentage = min(100 * InbvProgressIndicator.Count /
 638                            InbvProgressIndicator.Expected,
 639                      99);
 640     if (Percentage != InbvProgressIndicator.Percentage)
 641     {
 642         /* Percentage has moved, update the progress bar */
 643         InbvProgressIndicator.Percentage = Percentage;
 644         InbvUpdateProgressBar(Percentage);
 645     }
 646 }
 647
 648 PUCHAR
 649 NTAPI
 650 InbvGetResourceAddress(IN ULONG ResourceNumber)
 651 {
 652     /* Validate the resource number */
 653     if (ResourceNumber > ResourceCount) return NULL;
 654
 655     /* Return the address */
 656     return ResourceList[ResourceNumber--];
 657 }
 658
 659 NTSTATUS
 660 NTAPI
 661 NtDisplayString(IN PUNICODE_STRING DisplayString)
 662 {
 663     OEM_STRING OemString;
 664
 665     /* Convert the string to OEM and display it */
 666     RtlUnicodeStringToOemString(&OemString, DisplayString, TRUE);
 667     InbvDisplayString(OemString.Buffer);
 668     RtlFreeOemString(&OemString);
 669
 670     /* Return success */
 671     return STATUS_SUCCESS;
 672 }
 673
 674 VOID
 675 NTAPI
 676 INIT_FUNCTION
 677 DisplayBootBitmap(IN BOOLEAN TextMode)
 678 {
 679     PBITMAPINFOHEADER BitmapInfoHeader;
 680     LPRGBQUAD Palette;
 681
 682     PVOID Header, Band, Text, Screen;
 683     ROT_BAR_TYPE TempRotBarSelection = RB_UNSPECIFIED;
 684
 685 #ifdef CORE_6781_resolved
 686     UCHAR Buffer[64];
 687 #endif
 688
 689     /* Check if the system thread has already been created */
 690     if (SysThreadCreated)
 691     {
 692         /* Reset the progress bar */
 693         InbvAcquireLock();
 694         RotBarSelection = RB_UNSPECIFIED;
 695         InbvReleaseLock();
 696     }
 697
 698     /* Check if this is text mode */
 699     ShowProgressBar = FALSE;
 700     if (TextMode)
 701     {
 702         /* Check if this is a server OS */
 703         if (SharedUserData->NtProductType == NtProductWinNt)
 704         {
 705             /* It's not, set workstation settings */
 706             InbvSetTextColor(15);
 707             InbvSolidColorFill(0, 0, 639, 479, 7);
 708             InbvSolidColorFill(0, 421, 639, 479, 1);
 709
 710             /* Get resources */
 711             Header = InbvGetResourceAddress(IDB_LOGO_HEADER);
 712             Band = InbvGetResourceAddress(IDB_LOGO_BAND);
 713         }
 714         else
 715         {
 716             /* Set server settings */
 717             InbvSetTextColor(14);
 718             InbvSolidColorFill(0, 0, 639, 479, 6);
 719             InbvSolidColorFill(0, 421, 639, 479, 1);
 720
 721             /* Get resources */
 722             Header = InbvGetResourceAddress(IDB_SERVER_HEADER);
 723             Band = InbvGetResourceAddress(IDB_SERVER_BAND);
 724         }
 725
 726         /* Set the scrolling region */
 727         InbvSetScrollRegion(32, 80, 631, 400);
 728
 729         /* Make sure we have resources */
 730         if ((Header) && (Band))
 731         {
 732             /* BitBlt them on the screen */
 733             InbvBitBlt(Band, 0, 419);
 734             InbvBitBlt(Header, 0, 0);
 735         }
 736     }
 737     else
 738     {
 739         /* Is the boot driver installed? */
 740         Text = NULL;
 741         if (!InbvBootDriverInstalled) return;
 742
 743         /* Load the standard boot screen */
 744         Screen = InbvGetResourceAddress(IDB_BOOT_LOGO);
 745         if (SharedUserData->NtProductType == NtProductWinNt)
 746         {
 747             /* Workstation product, display appropriate status bar color */
 748             InbvGetResourceAddress(IDB_BAR_PRO);
 749         }
 750         else
 751         {
 752             /* Display correct branding based on server suite */
 753             if (ExVerifySuite(StorageServer))
 754             {
 755                 /* Storage Server Edition */
 756                 Text = InbvGetResourceAddress(IDB_STORAGE_SERVER);
 757             }
 758             else if (ExVerifySuite(ComputeServer))
 759             {
 760                 /* Compute Cluster Edition */
 761                 Text = InbvGetResourceAddress(IDB_CLUSTER_SERVER);
 762             }
 763             else
 764             {
 765                 /* Normal edition */
 766                 Text = InbvGetResourceAddress(IDB_SERVER_LOGO);
 767             }
 768
 769             /* Server product, display appropriate status bar color */
 770             InbvGetResourceAddress(IDB_BAR_SERVER);
 771         }
 772
 773         /* Make sure we had a logo */
 774         if (Screen)
 775         {
 776             /* Choose progress bar */
 777             TempRotBarSelection = RB_SQUARE_CELLS;
 778
 779             /*
 780              * Save the main image palette and replace it with black palette, so
 781              * we can do fade in effect later.
 782              */
 783             BitmapInfoHeader = (PBITMAPINFOHEADER)Screen;
 784             Palette = (LPRGBQUAD)((PUCHAR)Screen + BitmapInfoHeader->biSize);
 785             RtlCopyMemory(_MainPalette, Palette, sizeof(_MainPalette));
 786             RtlZeroMemory(Palette, sizeof(_MainPalette));
 787
 788             /* Blit the background */
 789             InbvBitBlt(Screen, 0, 0);
 790
 791             /* Set progress bar coordinates and display it */
 792             InbvSetProgressBarCoordinates(257, 352);
 793
 794             /* Display the boot logo and fade it in */
 795             BootImageFadeIn();
 796
 797 #ifdef CORE_6781_resolved
 798             /* Check for non-workstation products */
 799             if (SharedUserData->NtProductType != NtProductWinNt)
 800             {
 801                 /* Overwrite part of the logo for a server product */
 802                 InbvScreenToBufferBlt(Buffer, 413, 237, 7, 7, 8);
 803                 InbvSolidColorFill(418, 230, 454, 256, 0);
 804                 InbvBufferToScreenBlt(Buffer, 413, 237, 7, 7, 8);
 805
 806                 /* In setup mode, you haven't selected a SKU yet */
 807                 if (ExpInTextModeSetup) Text = NULL;
 808             }
 809 #endif
 810         }
 811
 812 #ifdef CORE_6781_resolved
 813         /* Draw the SKU text if it exits */
 814         if (Text) InbvBitBlt(Text, 180, 121);
 815 #else
 816         DBG_UNREFERENCED_LOCAL_VARIABLE(Text);
 817 #endif
 818
 819         /* Draw the progress bar bit */
 820 //      if (Bar) InbvBitBlt(Bar, 0, 0);
 821
 822         /* Set filter which will draw text display if needed */
 823         InbvInstallDisplayStringFilter(DisplayFilter);
 824     }
 825
 826     /* Do we have a system thread? */
 827     if (SysThreadCreated)
 828     {
 829         /* We do, set the progress bar location */
 830         InbvAcquireLock();
 831         RotBarSelection = TempRotBarSelection;
 832         //InbvRotBarInit();
 833         InbvReleaseLock();
 834     }
 835 }
 836
 837 VOID
 838 NTAPI
 839 INIT_FUNCTION
 840 DisplayFilter(PCHAR *String)
 841 {
 842     /* Windows hack to skip first dots */
 843     static BOOLEAN DotHack = TRUE;
 844
 845     /* If "." is given set *String to empty string */
 846     if(DotHack && strcmp(*String, ".") == 0)
 847         *String = "";
 848
 849     if(**String)
 850     {
 851         /* Remove the filter */
 852         InbvInstallDisplayStringFilter(NULL);
 853
 854         DotHack = FALSE;
 855
 856         /* Draw text screen */
 857         DisplayBootBitmap(TRUE);
 858     }
 859 }
 860
 861 VOID
 862 NTAPI
 863 INIT_FUNCTION
 864 FinalizeBootLogo(VOID)
 865 {
 866     /* Acquire lock and check the display state */
 867     InbvAcquireLock();
 868     if (InbvGetDisplayState() == INBV_DISPLAY_STATE_OWNED)
 869     {
 870         /* Clear the screen */
 871         VidSolidColorFill(0, 0, 639, 479, 0);
 872     }
 873
 874     /* Reset progress bar and lock */
 875     PltRotBarStatus = 3;
 876     InbvReleaseLock();
 877 }