[ros-dev] [ros-diffs] [fireball] 27186: - Resurrect "old" bootvid. The plan is to * make it working in trunk * add framebuffer support for olpc and xbox kind of devices.

Alex Ionescu ionucu at videotron.ca
Fri Jun 15 20:51:06 CEST 2007


Screwing up compatibility continues! Here's an idea, let's rename all the kernel exports!

-----Original Message-----
From: ros-diffs-bounces at reactos.org [mailto:ros-diffs-bounces at reactos.org] On Behalf Of fireball at svn.reactos.org
Sent: Friday, June 15, 2007 3:59 AM
To: ros-diffs at reactos.org
Subject: [ros-diffs] [fireball] 27186: - Resurrect "old" bootvid. The plan is to * make it working in trunk * add framebuffer support for olpc and xbox kind of devices.

Author: fireball
Date: Fri Jun 15 14:58:37 2007
New Revision: 27186

URL: http://svn.reactos.org/svn/reactos?rev=27186&view=rev
Log:
- Resurrect "old" bootvid. The plan is to
 * make it working in trunk
 * add framebuffer support for olpc and xbox kind of devices.

Added:
    branches/olpc/drivers/base/bootvid/bar.bmp
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bar.bmp
    branches/olpc/drivers/base/bootvid/bootimage.bmp
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bootimage.bmp
    branches/olpc/drivers/base/bootvid/bootvid.h
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/bootvid.h
    branches/olpc/drivers/base/bootvid/resource.h
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/resource.h
    branches/olpc/drivers/base/bootvid/vid.c
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid.c
    branches/olpc/drivers/base/bootvid/vid_vga.c
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_vga.c
    branches/olpc/drivers/base/bootvid/vid_vgatext.c
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_vgatext.c
    branches/olpc/drivers/base/bootvid/vid_xbox.c
      - copied unchanged from r25677, trunk/reactos/drivers/base/bootvid/vid_xbox.c
Removed:
    branches/olpc/drivers/base/bootvid/bootdata.c
    branches/olpc/drivers/base/bootvid/precomp.h
    branches/olpc/drivers/base/bootvid/vga.c
Modified:
    branches/olpc/drivers/base/bootvid/bootvid.c   (contents, props changed)
    branches/olpc/drivers/base/bootvid/bootvid.def   (contents, props changed)
    branches/olpc/drivers/base/bootvid/bootvid.rbuild   (contents, props changed)
    branches/olpc/drivers/base/bootvid/bootvid.rc   (contents, props changed)

Removed: branches/olpc/drivers/base/bootvid/bootdata.c
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootdata.c?rev=27185&view=auto
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootdata.c (original)
+++ branches/olpc/drivers/base/bootvid/bootdata.c (removed)
@@ -1,309 +1,0 @@
-#include "precomp.h"
-
-USHORT AT_Initialization[] =
-{
-    0x10 | CMD_STREAM_READ,     // Major Command = 0x10. Minor Command = 0x08.
-    0x3DA,                      // Index Status 1 Register Port Address
-
-    //
-    // This Stream performs a USHORT Array Indexed Write at port 0x3C0
-    //
-    0x20 | 0x01,                // Major Command = 0x20. Minor Command = 0x01.
-    0x3C0,                      // Attribute Controller Data Register
-    0x10,                       // Loop Count = 16 (Number of Pallette Entries)
-    0x0,                        // Index to select (Index = 0, palettes)
-    0x00,                       // Palette 0
-    0x01,                       // Palette 1
-    0x02,                       // Palette 2
-    0x03,                       // Palette 3
-    0x04,                       // Palette 4
-    0x05,                       // Palette 5
-    0x06,                       // Palette 6
-    0x07,                       // Palette 7
-    0x08,                       // Palette 8
-    0x09,                       // Palette 9
-    0x0A,                       // Palette 10
-    0x0B,                       // Palette 11
-    0x0C,                       // Palette 12
-    0x0D,                       // Palette 13
-    0x0E,                       // Palette 14
-    0x0F,                       // Palette 15
-
-    //
-    // This Stream performs a UCHAR READ of port 0x3DA
-    //
-    0x10 | CMD_STREAM_READ,     // Major Command = 0x10. Minor Command = 0x08.
-    0x3DA,                      // Index Status 1 Register Port Address
-
-    //
-    // This Stream performs a UCHAR WRITE of value 0x20 at port 0x3C0
-    //
-    0x10 | CMD_STREAM_WRITE,    // Major Command = 0x10. Minor Command = 0x00.
-    0x3C0,                      // Attribute Controller Data Register
-    0x20,                       // Set Palette Address Source
-
-    //
-    // End of Stream Marker
-    //
-    0x0                         // End of command stream
-};
-
-UCHAR FontData[256 * 13] =
-{
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 0
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 13
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 26
-    0x18, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 39
-    0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 52
-    0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 65
-    0x24, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 78
-    0x10, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 91
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, // 104
-    0x14, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 117
-    0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 130
-    0x10, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 143
-    0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 156
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, // 169
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 182
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 195
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 208
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 221
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 234
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 247
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 260
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 273
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 286
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 299
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 312
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 325
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 338
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 351
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 364
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 377
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 390
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 403
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 416
-    0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // 429
-    0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 442
-    0x00, 0x14, 0x14, 0x14, 0x7F, 0x28, 0xFE, 0x50, 0x50, 0x50, 0x00, 0x00, 0x00, // 455
-    0x10, 0x3C, 0x50, 0x50, 0x70, 0x38, 0x1C, 0x14, 0x14, 0x78, 0x10, 0x00, 0x00, // 468
-    0x00, 0x61, 0x92, 0x94, 0x68, 0x18, 0x16, 0x29, 0x49, 0x86, 0x00, 0x00, 0x00, // 481
-    0x00, 0x18, 0x24, 0x24, 0x38, 0x71, 0x89, 0x8E, 0xC6, 0x7E, 0x00, 0x00, 0x00, // 494
-    0x10, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 507
-    0x06, 0x08, 0x10, 0x30, 0x20, 0x20, 0x20, 0x20, 0x30, 0x10, 0x08, 0x06, 0x00, // 520
-    0x60, 0x10, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x10, 0x60, 0x00, // 533
-    0x00, 0x10, 0x52, 0x24, 0x3C, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 546
-    0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, // 559
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20, 0x00, // 572
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 585
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, // 598
-    0x01, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x40, 0x40, 0x80, 0x00, // 611
-    0x00, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x3C, 0x00, 0x00, 0x00, // 624
-    0x00, 0x30, 0xD0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFE, 0x00, 0x00, 0x00, // 637
-    0x00, 0x78, 0x04, 0x04, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7C, 0x00, 0x00, 0x00, // 650
-    0x00, 0x78, 0x04, 0x04, 0x08, 0x30, 0x0C, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, // 663
-    0x00, 0x08, 0x18, 0x28, 0x28, 0x48, 0x88, 0xFC, 0x08, 0x08, 0x00, 0x00, 0x00, // 676
-    0x00, 0x3C, 0x20, 0x20, 0x38, 0x04, 0x04, 0x04, 0x04, 0x38, 0x00, 0x00, 0x00, // 689
-    0x00, 0x1C, 0x20, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x22, 0x1C, 0x00, 0x00, 0x00, // 702
-    0x00, 0x7E, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0x00, 0x00, 0x00, // 715
-    0x00, 0x3C, 0x42, 0x42, 0x24, 0x3C, 0x46, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 728
-    0x00, 0x38, 0x44, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x04, 0x38, 0x00, 0x00, 0x00, // 741
-    0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, // 754
-    0x00, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00, 0x00, 0x30, 0x30, 0x10, 0x20, 0x00, // 767
-    0x00, 0x00, 0x00, 0x02, 0x0C, 0x10, 0x60, 0x10, 0x0C, 0x02, 0x00, 0x00, 0x00, // 780
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, 0x00, // 793
-    0x00, 0x00, 0x00, 0x40, 0x30, 0x08, 0x06, 0x08, 0x30, 0x40, 0x00, 0x00, 0x00, // 806
-    0x00, 0x7C, 0x42, 0x02, 0x04, 0x08, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // 819
-    0x00, 0x3C, 0x62, 0xDE, 0xB2, 0xA2, 0xA6, 0x9B, 0x44, 0x3C, 0x00, 0x00, 0x00, // 832
-    0x00, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, // 845
-    0x00, 0x00, 0x7C, 0x42, 0x42, 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x00, 0x00, 0x00, // 858
-    0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80, 0x80, 0x40, 0x3E, 0x00, 0x00, 0x00, // 871
-    0x00, 0x00, 0x78, 0x44, 0x42, 0x42, 0x42, 0x42, 0x44, 0x78, 0x00, 0x00, 0x00, // 884
-    0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, // 897
-    0x00, 0x00, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, // 910
-    0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x8E, 0x82, 0x42, 0x3E, 0x00, 0x00, 0x00, // 923
-    0x00, 0x00, 0x42, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, // 936
-    0x00, 0x00, 0x7C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x7C, 0x00, 0x00, 0x00, // 949
-    0x00, 0x00, 0x3C, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, // 962
-    0x00, 0x00, 0x42, 0x44, 0x48, 0x70, 0x50, 0x48, 0x44, 0x42, 0x00, 0x00, 0x00, // 975
-    0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, // 988
-    0x00, 0x00, 0xC6, 0xC6, 0xAA, 0xAA, 0xAA, 0x92, 0x82, 0x82, 0x00, 0x00, 0x00, // 1001
-    0x00, 0x00, 0x42, 0x62, 0x52, 0x52, 0x4A, 0x4A, 0x46, 0x42, 0x00, 0x00, 0x00, // 1014
-    0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, // 1027
-    0x00, 0x00, 0x7C, 0x42, 0x42, 0x42, 0x7C, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, // 1040
-    0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x06, 0x03, 0x00, // 1053
-    0x00, 0x00, 0x78, 0x44, 0x44, 0x44, 0x78, 0x48, 0x44, 0x42, 0x00, 0x00, 0x00, // 1066
-    0x00, 0x00, 0x3E, 0x40, 0x40, 0x38, 0x04, 0x02, 0x02, 0x7C, 0x00, 0x00, 0x00, // 1079
-    0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, // 1092
-    0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 1105
-    0x00, 0x00, 0x81, 0x42, 0x42, 0x44, 0x24, 0x28, 0x38, 0x10, 0x00, 0x00, 0x00, // 1118
-    0x00, 0x00, 0x81, 0x81, 0x92, 0x5A, 0x5A, 0x6A, 0x66, 0x24, 0x00, 0x00, 0x00, // 1131
-    0x00, 0x00, 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81, 0x00, 0x00, 0x00, // 1144
-    0x00, 0x00, 0x82, 0x44, 0x28, 0x28, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, // 1157
-    0x00, 0x00, 0xFE, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0xFE, 0x00, 0x00, 0x00, // 1170
-    0x1E, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1E, 0x00, // 1183
-    0x80, 0x40, 0x40, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02, 0x02, 0x01, 0x00, // 1196
-    0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x78, 0x00, // 1209
-    0x00, 0x08, 0x08, 0x18, 0x14, 0x24, 0x24, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, // 1222
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, // 1235
-    0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 1248
-    0x00, 0x00, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 1261
-    0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x62, 0x5C, 0x00, 0x00, 0x00, // 1274
-    0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40, 0x40, 0x20, 0x1E, 0x00, 0x00, 0x00, // 1287
-    0x02, 0x02, 0x02, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 1300
-    0x00, 0x00, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, // 1313
-    0x1E, 0x20, 0x20, 0xFE, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, // 1326
-    0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x02, 0x3C, // 1339
-    0x40, 0x40, 0x40, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, // 1352
-    0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 1365
-    0x18, 0x18, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x70, // 1378
-    0x40, 0x40, 0x40, 0x44, 0x48, 0x50, 0x60, 0x50, 0x48, 0x44, 0x00, 0x00, 0x00, // 1391
-    0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 1404
-    0x00, 0x00, 0x00, 0xB6, 0xDA, 0x92, 0x92, 0x92, 0x92, 0x92, 0x00, 0x00, 0x00, // 1417
-    0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, // 1430
-    0x00, 0x00, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 1443
-    0x00, 0x00, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x62, 0x5C, 0x40, 0x40, 0x40, // 1456
-    0x00, 0x00, 0x00, 0x3A, 0x46, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x02, 0x02, 0x02, // 1469
-    0x00, 0x00, 0x00, 0x5C, 0x64, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00, 0x00, // 1482
-    0x00, 0x00, 0x00, 0x3C, 0x40, 0x60, 0x18, 0x04, 0x04, 0x78, 0x00, 0x00, 0x00, // 1495
-    0x00, 0x00, 0x20, 0xFC, 0x20, 0x20, 0x20, 0x20, 0x20, 0x1C, 0x00, 0x00, 0x00, // 1508
-    0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 1521
-    0x00, 0x00, 0x00, 0x82, 0x44, 0x44, 0x44, 0x28, 0x28, 0x10, 0x00, 0x00, 0x00, // 1534
-    0x00, 0x00, 0x00, 0x81, 0x91, 0x5A, 0x5A, 0x6A, 0x24, 0x24, 0x00, 0x00, 0x00, // 1547
-    0x00, 0x00, 0x00, 0x42, 0x24, 0x18, 0x18, 0x18, 0x24, 0x42, 0x00, 0x00, 0x00, // 1560
-    0x00, 0x00, 0x00, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x10, 0x30, 0xE0, // 1573
-    0x00, 0x00, 0x00, 0x7E, 0x02, 0x04, 0x08, 0x10, 0x20, 0x7E, 0x00, 0x00, 0x00, // 1586
-    0x1C, 0x10, 0x10, 0x10, 0x10, 0x60, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0C, 0x00, // 1599
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, // 1612
-    0x30, 0x08, 0x08, 0x08, 0x08, 0x06, 0x08, 0x08, 0x08, 0x08, 0x08, 0x30, 0x00, // 1625
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x8E, 0x00, 0x00, 0x00, 0x00, 0x00, // 1638
-    0x00, 0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x3C, 0x00, 0x00, 0x00, // 1651
-    0x00, 0x00, 0x3E, 0x40, 0x80, 0x80, 0x80, 0x80, 0x40, 0x3E, 0x04, 0x02, 0x06, // 1664
-    0x00, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 1677
-    0x08, 0x10, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, // 1690
-    0x18, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 1703
-    0x00, 0x24, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 1716
-    0x10, 0x08, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 1729
-    0x10, 0x28, 0x10, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 1742
-    0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x40, 0x40, 0x20, 0x1E, 0x08, 0x04, 0x0C, // 1755
-    0x18, 0x24, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, // 1768
-    0x00, 0x12, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, // 1781
-    0x10, 0x08, 0x00, 0x3C, 0x22, 0x42, 0x7E, 0x40, 0x40, 0x3E, 0x00, 0x00, 0x00, // 1794
-    0x00, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 1807
-    0x18, 0x24, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 1820
-    0x10, 0x08, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 1833
-    0x24, 0x00, 0x18, 0x18, 0x24, 0x24, 0x24, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, // 1846
-    0x10, 0x28, 0x10, 0x28, 0x28, 0x24, 0x44, 0x7E, 0x42, 0x81, 0x00, 0x00, 0x00, // 1859
-    0x08, 0x10, 0x7E, 0x40, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x7E, 0x00, 0x00, 0x00, // 1872
-    0x00, 0x00, 0x00, 0xFC, 0x12, 0x12, 0x7E, 0x90, 0x90, 0x6E, 0x00, 0x00, 0x00, // 1885
-    0x00, 0x00, 0x0F, 0x18, 0x18, 0x28, 0x2E, 0x78, 0x48, 0x8F, 0x00, 0x00, 0x00, // 1898
-    0x18, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 1911
-    0x00, 0x24, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 1924
-    0x20, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 1937
-    0x18, 0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 1950
-    0x20, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 1963
-    0x00, 0x24, 0x00, 0x81, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x10, 0x30, 0xE0, // 1976
-    0x24, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, // 1989
-    0x24, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 2002
-    0x00, 0x08, 0x1C, 0x28, 0x48, 0x48, 0x48, 0x68, 0x1C, 0x08, 0x00, 0x00, 0x00, // 2015
-    0x00, 0x0E, 0x10, 0x10, 0x10, 0x38, 0x10, 0x10, 0x20, 0x3E, 0x00, 0x00, 0x00, // 2028
-    0x00, 0x81, 0x42, 0x24, 0x18, 0x7C, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00, 0x00, // 2041
-    0x00, 0xE0, 0x90, 0x90, 0xE0, 0x96, 0xBC, 0x94, 0x92, 0x9E, 0x00, 0x00, 0x00, // 2054
-    0x0E, 0x10, 0x10, 0x3C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xE0, // 2067
-    0x08, 0x10, 0x00, 0x38, 0x04, 0x04, 0x3C, 0x44, 0x44, 0x3E, 0x00, 0x00, 0x00, // 2080
-    0x08, 0x10, 0x00, 0x78, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00, // 2093
-    0x08, 0x10, 0x00, 0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 2106
-    0x08, 0x10, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3A, 0x00, 0x00, 0x00, // 2119
-    0x14, 0x28, 0x00, 0x5C, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00, 0x00, // 2132
-    0x14, 0x28, 0x42, 0x62, 0x52, 0x52, 0x4A, 0x4A, 0x46, 0x42, 0x00, 0x00, 0x00, // 2145
-    0x00, 0x78, 0x08, 0x38, 0x48, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2158
-    0x00, 0x38, 0x44, 0x44, 0x44, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2171
-    0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x08, 0x10, 0x20, 0x40, 0x42, 0x3E, 0x00, // 2184
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x40, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, // 2197
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, // 2210
-    0x00, 0xC4, 0x48, 0x48, 0x50, 0x37, 0x21, 0x43, 0x44, 0x87, 0x00, 0x00, 0x00, // 2223
-    0x00, 0xC4, 0x48, 0x48, 0x50, 0x22, 0x26, 0x4A, 0x4F, 0x82, 0x00, 0x00, 0x00, // 2236
-    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, // 2249
-    0x00, 0x00, 0x00, 0x00, 0x12, 0x24, 0x48, 0x24, 0x12, 0x00, 0x00, 0x00, 0x00, // 2262
-    0x00, 0x00, 0x00, 0x00, 0x48, 0x24, 0x12, 0x24, 0x48, 0x00, 0x00, 0x00, 0x00, // 2275
-    0x94, 0x00, 0x00, 0x94, 0x00, 0x94, 0x00, 0x00, 0x94, 0x00, 0x94, 0x00, 0x00, // 2288
-    0x49, 0x94, 0x00, 0x49, 0x94, 0x49, 0x00, 0x94, 0x49, 0x94, 0x49, 0x00, 0x94, // 2301
-    0xFF, 0x94, 0x94, 0xFF, 0x94, 0xFF, 0x94, 0x94, 0xFF, 0x94, 0xFF, 0x94, 0x94, // 2314
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2327
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2340
-    0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, // 2353
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2366
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2379
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, // 2392
-    0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, // 2405
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2418
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x04, 0xF4, 0x14, 0x14, 0x14, 0x14, 0x14, // 2431
-    0x14, 0x14, 0x14, 0x14, 0x14, 0xF4, 0x04, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, // 2444
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2457
-    0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, // 2470
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2483
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2496
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2509
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2522
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2535
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2548
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2561
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, // 2574
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2587
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, // 2600
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, // 2613
-    0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, // 2626
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x14, 0x14, // 2639
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x17, 0x10, 0x17, 0x14, 0x14, 0x14, 0x14, 0x14, // 2652
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, // 2665
-    0x14, 0x14, 0x14, 0x14, 0x14, 0xF7, 0x00, 0xF7, 0x14, 0x14, 0x14, 0x14, 0x14, // 2678
-    0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, // 2691
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2704
-    0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, // 2717
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2730
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2743
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x1F, 0x10, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, // 2756
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, // 2769
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2782
-    0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0xFF, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // 2795
-    0x10, 0x10, 0x10, 0x10, 0x10, 0xFF, 0x10, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, // 2808
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2821
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 2834
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 2847
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 2860
-    0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, // 2873
-    0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, // 2886
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2899
-    0x00, 0x00, 0x00, 0x31, 0x49, 0x86, 0x84, 0x84, 0x8A, 0x71, 0x00, 0x00, 0x00, // 2912
-    0x38, 0x48, 0x48, 0x50, 0x50, 0x58, 0x44, 0x42, 0x42, 0x5C, 0x00, 0x00, 0x00, // 2925
-    0x00, 0x00, 0x3F, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x00, 0x00, // 2938
-    0x00, 0x00, 0x00, 0x7F, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, // 2951
-    0x00, 0x00, 0xFF, 0x40, 0x20, 0x10, 0x10, 0x20, 0x40, 0xFF, 0x00, 0x00, 0x00, // 2964
-    0x00, 0x00, 0x00, 0x7F, 0x84, 0x84, 0x84, 0x84, 0x84, 0x78, 0x00, 0x00, 0x00, // 2977
-    0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x66, 0x5A, 0x40, 0x40, 0x40, // 2990
-    0x00, 0x00, 0x00, 0xFE, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00, 0x00, // 3003
-    0x00, 0x00, 0x10, 0x7C, 0x92, 0x92, 0x92, 0x92, 0x7C, 0x10, 0x00, 0x00, 0x00, // 3016
-    0x00, 0x00, 0x38, 0x44, 0x82, 0xBA, 0x82, 0x82, 0x44, 0x38, 0x00, 0x00, 0x00, // 3029
-    0x00, 0x00, 0x7C, 0xC6, 0x82, 0x82, 0x82, 0x84, 0x44, 0xEE, 0x00, 0x00, 0x00, // 3042
-    0x38, 0x40, 0x60, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42, 0x3C, 0x00, 0x00, 0x00, // 3055
-    0x00, 0x00, 0x00, 0x00, 0x66, 0x99, 0x99, 0x99, 0x66, 0x00, 0x00, 0x00, 0x00, // 3068
-    0x10, 0x10, 0x10, 0x7C, 0x92, 0x91, 0x91, 0x91, 0x92, 0x7C, 0x10, 0x10, 0x10, // 3081
-    0x00, 0x00, 0x00, 0x1E, 0x20, 0x40, 0x7C, 0x40, 0x60, 0x1E, 0x00, 0x00, 0x00, // 3094
-    0x00, 0x00, 0x00, 0x38, 0x44, 0x82, 0x82, 0x82, 0x82, 0x82, 0x00, 0x00, 0x00, // 3107
-    0x00, 0x00, 0x00, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x7E, 0x00, 0x00, 0x00, 0x00, // 3120
-    0x00, 0x00, 0x00, 0x10, 0x10, 0xFE, 0x10, 0x10, 0x00, 0xFE, 0x00, 0x00, 0x00, // 3133
-    0x00, 0x00, 0x40, 0x30, 0x08, 0x06, 0x08, 0x30, 0x40, 0x00, 0x7E, 0x00, 0x00, // 3146
-    0x00, 0x00, 0x02, 0x0C, 0x10, 0x60, 0x10, 0x0C, 0x02, 0x00, 0x7E, 0x00, 0x00, // 3159
-    0x0C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 3172
-    0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x60, // 3185
-    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, // 3198
-    0x00, 0x00, 0x00, 0x00, 0x72, 0x4E, 0x00, 0x72, 0x4E, 0x00, 0x00, 0x00, 0x00, // 3211
-    0x00, 0x10, 0x28, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3224
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // 3237
-    0x00, 0x00, 0x00, 0x00, 0x18, 0x3C, 0x3C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, // 3250
-    0x01, 0x01, 0x02, 0x02, 0x02, 0x04, 0x04, 0xC4, 0x28, 0x28, 0x18, 0x10, 0x00, // 3263
-    0x00, 0x3C, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3276
-    0x00, 0x3C, 0x04, 0x18, 0x3C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 3289
-    0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, // 3302
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // 3315
-};

Modified: branches/olpc/drivers/base/bootvid/bootvid.c
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvid.c?rev=27186&r1=27185&r2=27186&view=diff
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.c (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.c Fri Jun 15 14:58:37 2007
@@ -1,475 +1,290 @@
-#include "precomp.h"
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-BOOLEAN
-NTAPI
-VgaInterpretCmdStream(IN PUSHORT CmdStream)
-{
-    PUCHAR Base = (PUCHAR)VgaRegisterBase;
-    USHORT Cmd;
-    UCHAR Major, Minor;
-    USHORT Count;
-    UCHAR Index;
-    PUSHORT Buffer;
-    PUSHORT ShortPort;
-    PUCHAR Port;
-    UCHAR Value;
-    USHORT ShortValue;
-
-    /* First make sure that we have a Command Stream */
-    if (!CmdStream) return TRUE;
-
-    /* Loop as long as we have commands */
-    while (*CmdStream)
-    {
-        /* Get the Major and Minor Function */
-        Cmd = *CmdStream;
-        Major = Cmd & 0xF0;
-        Minor = Cmd & 0x0F;
-
-        /* Move to the next command */
-        CmdStream++;
-
-        /* Check which major function this was */
-        if (Major == 0x10)
-        {
-            /* Now let's see the minor function */
-            if (Minor & CMD_STREAM_READ)
-            {
-                /* Now check the sub-type */
-                if (Minor & CMD_STREAM_USHORT)
-                {
-                    /* The port is what is in the stream right now */
-                    ShortPort = UlongToPtr((ULONG)*CmdStream);
-
-                    /* Move to the next command */
-                    CmdStream++;
-
-                    /* Read USHORT from the port */
-                    READ_PORT_USHORT(PtrToUlong(Base) + ShortPort);
-                }
-                else
-                {
-                    /* The port is what is in the stream right now */
-                    Port = UlongToPtr((ULONG)*CmdStream);
-
-                    /* Move to the next command */
-                    CmdStream++;
-
-                    /* Read UCHAR from the port */
-                    READ_PORT_UCHAR(PtrToUlong(Base) + Port);
-                }
-            }
-            else if (Minor & CMD_STREAM_WRITE_ARRAY)
-            {
-                /* Now check the sub-type */
-                if (Minor & CMD_STREAM_USHORT)
-                {
-                    /* The port is what is in the stream right now */
-                    ShortPort = UlongToPtr(Cmd);
-
-                    /* Move to the next command and get the count */
-                    Count = *(CmdStream++);
-
-                    /* The buffer is what's next in the command stream */
-                    Buffer = CmdStream++;
-
-                    /* Write USHORT to the port */
-                    WRITE_PORT_BUFFER_USHORT(PtrToUshort(Base) + ShortPort, Buffer, Count);
-
-                    /* Move past the buffer in the command stream */
-                    CmdStream += Count;
-                }
-                else
-                {
-                    /* The port is what is in the stream right now */
-                    Port = UlongToPtr(Cmd);
-
-                    /* Move to the next command and get the count */
-                    Count = *(CmdStream++);
-
-                    /* Add the base to the port */
-                    Port = PtrToUlong(Port) + Base;
-
-                    /* Move to next command */
-                    CmdStream++;
-
-                    /* Loop the cmd array */
-                    for (; Count; Count--, CmdStream++)
-                    {
-                        /* Get the byte we're writing */
-                        Value = (UCHAR)*CmdStream;
-
-                        /* Write UCHAR to the port */
-                        WRITE_PORT_UCHAR(Port, Value);
-                    }
-                }
-            }
-            else if (Minor & CMD_STREAM_USHORT)
-            {
-                /* Get the ushort we're writing and advance in the stream */
-                ShortValue = *CmdStream;
-                CmdStream++;
-
-                /* Write USHORT to the port (which is in cmd) */
-                WRITE_PORT_USHORT((PUSHORT)Base + Cmd, ShortValue);
-            }
-            else
-            {
-                /* The port is what is in the stream right now */
-                Port = UlongToPtr((ULONG)*CmdStream);
-
-                /* Get the uchar we're writing */
-                Value = (UCHAR)*++CmdStream;
-
-                /* Move to the next command */
-                CmdStream++;
-
-                /* Write UCHAR to the port (which is in cmd) */
-                WRITE_PORT_UCHAR(PtrToUlong(Base) + Port, Value);
-            }
-        }
-        else if (Major == 0x20)
-        {
-            /* Check the minor function. Note these are not flags anymore. */
-            switch (Minor)
-            {
-                case 0:
-                    /* The port is what is in the stream right now */
-                    ShortPort = UlongToPtr(*CmdStream);
-
-                    /* Move to the next command and get the count */
-                    Count = *(CmdStream++);
-
-                    /* Move to the next command and get the value to write */
-                    ShortValue = *(CmdStream++);
-
-                    /* Add the base to the port */
-                    ShortPort = PtrToUlong(ShortPort) + (PUSHORT)Base;
-
-                    /* Move to next command */
-                    CmdStream++;
-
-                    /* Make sure we have data */
-                    if (!ShortValue) continue;
-
-                    /* Loop the cmd array */
-                    for (; Count; Count--, CmdStream++, Value++)
-                    {
-                        /* Get the byte we're writing */
-                        ShortValue += (*CmdStream) << 8;
-
-                        /* Write USHORT to the port */
-                        WRITE_PORT_USHORT(ShortPort, ShortValue);
-                    }
-                    break;
-                case 1:
-                    /* The port is what is in the stream right now. Add the base too */
-                    Port = *CmdStream + Base;
-
-                    /* Move to the next command and get the count */
-                    Count = *++CmdStream;
-
-                    /* Move to the next command and get the index to write */
-                    Index = (UCHAR)*++CmdStream;
-
-                    /* Move to next command */
-                    CmdStream++;
-
-                    /* Loop the cmd array */
-                    for (; Count; Count--, Index++)
-                    {
-                        /* Write the index */
-                        WRITE_PORT_UCHAR(Port, Index);
-
-                        /* Get the byte we're writing */
-                        Value = (UCHAR)*CmdStream;
-
-                        /* Move to next command */
-                        CmdStream++;
-
-                        /* Write UCHAR value to the port */
-                        WRITE_PORT_UCHAR(Port, Value);
-                    }
-                    break;
-                case 2:
-                    /* The port is what is in the stream right now. Add the base too */
-                    Port = *CmdStream + Base;
-
-                    /* Read the current value and add the stream data */
-                    Value = READ_PORT_UCHAR(Port);
-                    Value &= *CmdStream++;
-                    Value ^= *CmdStream++;
-
-                    /* Write the value */
-                    WRITE_PORT_UCHAR(Port, Value);
-                    break;
-                default:
-                    /* Unknown command, fail */
-                    return FALSE;
-            }
-        }
-        else if (Major != 0xF0)
-        {
-            /* Unknown major function, fail */
-            return FALSE;
-        }
-
-        /* Get the next command */
-        Cmd = *CmdStream;
-    }
-
-    /* If we got here, return success */
-    return TRUE;
-}
-
-BOOLEAN
-NTAPI
-VgaIsPresent(VOID)
-{
-    UCHAR VgaReg, VgaReg2, VgaReg3;
-    UCHAR SeqReg, SeqReg2;
-    UCHAR i;
-
-    /* Read the VGA Address Register */
-    VgaReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE);
-
-    /* Select Read Map Select Register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
-    /* Read it back...it should be 4 */
-    if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) != 4) return FALSE;
-
-    /* Read the VGA Data Register */
-    VgaReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
-    /* Enable all planes */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 3);
-
-    /* Read it back...it should be 3 */
-    if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 0x3)
-    {
-        /* Reset the registers and fail */
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
-        return FALSE;
-    }
-
-    /* Select Bit Mask Register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
-    /* Read it back...it should be 8 */
-    if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE)) & 0xF) != 8)
-    {
-        /* Reset the registers and fail */
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
-        return FALSE;
-    }
-
-    /* Read the VGA Data Register */
-    VgaReg3 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF);
-
-    /* Loop bitmasks */
-    for (i = 0xBB; i; i >>= 1)
-    {
-        /*  Set bitmask */
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, i);
-
-        /* Read it back...it should be the same */
-        if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != i)
-        {
-            /* Reset the registers and fail */
-            WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
-            WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-            WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
-            return FALSE;
-        }
-    }
-
-    /* Select Read Map Select Register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 4);
-
-    /* Read it back...it should be 3 */
-    if (READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) != 3)
-    {
-        /* Reset the registers and fail */
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0);
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 0xFF);
-        return FALSE;
-    }
-
-    /* Write the registers we read earlier */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg);
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, VgaReg2);
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, VgaReg3);
-
-    /* Read sequencer address */
-    SeqReg = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4);
-
-    /* Select memory mode register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, 4);
-
-    /* Read it back...it should still be 4 */
-    if (((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4)) & 7) != 4)
-    {
-        /*  Fail */
-        return FALSE;
-    }
-
-    /* Read sequencer Data */
-    SeqReg2 = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5);
-
-    /* Write null plane */
-    WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x100);
-
-    /* Write sequencer flag */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2 ^ 8);
-
-    /* Read it back */
-    if ((READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5)) != (SeqReg2 ^ 8))
-    {
-        /* Not the same value...restore registers and fail */
-        WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, 2);
-        WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
-        return FALSE;
-    }
-
-    /* Now write the registers we read */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C5, SeqReg2);
-    WRITE_PORT_USHORT((PUSHORT)VgaRegisterBase + 0x3C4, 0x300);
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3C4, SeqReg);
-
-    /* VGA is present! */
-    return TRUE;
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
 /*
- * @implemented
+ * ReactOS Boot video driver
+ *
+ * Copyright (C) 2003 Casper S. Hornstroup
+ * Copyright (C) 2004, 2005 Filip Navara
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Id$
  */
-BOOLEAN
-NTAPI
-VidInitialize(IN BOOLEAN SetMode)
-{
-    ULONG Context = 0;
-    PHYSICAL_ADDRESS TranslatedAddress;
-    PHYSICAL_ADDRESS NullAddress = {{0}};
-    ULONG AddressSpace = 1;
-    BOOLEAN Result;
-    ULONG_PTR Base;
-
-    /* Make sure that we have a bus translation function */
-    if (!HalFindBusAddressTranslation) return FALSE;
-
-    /* Get the VGA Register address */
-    Result = HalFindBusAddressTranslation(NullAddress,
-                                          &AddressSpace,
-                                          &TranslatedAddress,
-                                          &Context,
-                                          TRUE);
-    if (!Result) return FALSE;
-
-    /* See if this is I/O Space, which we need to map */
-TryAgain:
-    if (!AddressSpace)
-    {
-        /* Map it */
-        Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress, 0x400, MmNonCached);
-    }
-    else
-    {
-        /* The base is the translated address, no need to map I/O space */
-        Base = TranslatedAddress.LowPart;
-    }
-
-    /* Set the VGA Register base and now check if we have a VGA device */
-    VgaRegisterBase = Base;
-    if (VgaIsPresent())
-    {
-        /* Translate the VGA Memory Address */
-        NullAddress.LowPart = 0xA0000;
-        AddressSpace = 0;
-        Result = HalFindBusAddressTranslation(NullAddress,
-                                              &AddressSpace,
-                                              &TranslatedAddress,
-                                              &Context,
-                                              FALSE);
-        if (Result)
-        {
-            /* Success! See if this is I/O Space, which we need to map */
-            if (!AddressSpace)
-            {
-                /* Map it */
-                Base = (ULONG_PTR)MmMapIoSpace(TranslatedAddress,
-                                               0x20000,
-                                               MmNonCached);
-            }
-            else
-            {
-                /* The base is the translated address, no need to map I/O space */
-                Base = TranslatedAddress.LowPart;
-            }
-
-            /* Set the VGA Memory Base */
-            VgaBase = Base;
-
-            /* Now check if we have to set the mode */
-            if (SetMode)
-            {
-                //
-                // Reset the display
-                //
-                //HalResetDisplay();
-                curr_x = 0;
-                curr_y = 0;
-
-                /* Initialize it */
-                VgaInterpretCmdStream(AT_Initialization);
-                return TRUE;
-            }
-        }
-    }
-    else
-    {
-        /* It's not, so unmap the I/O space if we mapped it */
-        if (!AddressSpace) MmUnmapIoSpace((PVOID)VgaRegisterBase, 0x400);
-    }
-
-    /* If we got here, then we failed...let's try again */
-    Result = HalFindBusAddressTranslation(NullAddress,
-                                          &AddressSpace,
-                                          &TranslatedAddress,
-                                          &Context,
-                                          TRUE);
-    if (Result) goto TryAgain;
-
-    /* If we got here, then we failed even past our re-try... */
-    return FALSE;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidResetDisplay(IN BOOLEAN HalReset)
-{
-    /* Clear the current position */
-    curr_x = 0;
-    curr_y = 0;
-
-    /* Clear the screen with HAL if we were asked to */
-    //if (HalReset) HalResetDisplay();
-
-    /* Re-initialize the VGA Display */
-    VgaInterpretCmdStream(AT_Initialization);
-
-    /* Re-initialize the palette and fill the screen black */
-    InitializePalette();
-    VidSolidColorFill(0, 0, 639, 479, 0);
-}
-
+
+/* INCLUDES ******************************************************************/
+
+#include "bootvid.h"
+#include "resource.h"
+
+#define NDEBUG
+#include <debug.h>
+
+//#define USE_PROGRESS_BAR
+
+/* GLOBALS *******************************************************************/
+
+static volatile LONG ShutdownNotify;
+static KEVENT ShutdownCompleteEvent;
+
+/* DATA **********************************************************************/
+
+static RGBQUAD _MainPalette[16];
+static UCHAR _Square1[9 * 4];
+static UCHAR _Square2[9 * 4];
+static UCHAR _Square3[9 * 4];
+
+/* FUNCTIONS *****************************************************************/
+
+static VOID NTAPI
+BootVidAnimationThread(PVOID Ignored)
+{
+   UCHAR PaletteBitmapBuffer[sizeof(BITMAPINFOHEADER) + sizeof(_MainPalette)];
+   PBITMAPINFOHEADER PaletteBitmap = (PBITMAPINFOHEADER)PaletteBitmapBuffer;
+   LPRGBQUAD Palette = (LPRGBQUAD)(PaletteBitmapBuffer + sizeof(BITMAPINFOHEADER));
+   ULONG Iteration, Index, ClrUsed;
+   UINT AnimBarPos;
+   LARGE_INTEGER Interval;
+   
+   /*
+    * Build a bitmap containing the fade in palette. The palette entries
+    * are then processed in a loop and set using VidBitBlt function.
+    */
+   
+   ClrUsed = sizeof(_MainPalette) / sizeof(_MainPalette[0]);
+   RtlZeroMemory(PaletteBitmap, sizeof(BITMAPINFOHEADER));
+   PaletteBitmap->biSize = sizeof(BITMAPINFOHEADER);
+   PaletteBitmap->biBitCount = 4; 
+   PaletteBitmap->biClrUsed = ClrUsed;
+
+   /*
+    * Main animation loop.
+    */
+
+   for (Iteration = 0, AnimBarPos = 0; !ShutdownNotify; Iteration++)
+   {
+      if (Iteration <= PALETTE_FADE_STEPS)
+      {
+         for (Index = 0; Index < ClrUsed; Index++)
+         {
+            Palette[Index].rgbRed =
+               _MainPalette[Index].rgbRed * Iteration / PALETTE_FADE_STEPS;
+            Palette[Index].rgbGreen =
+               _MainPalette[Index].rgbGreen * Iteration / PALETTE_FADE_STEPS;
+            Palette[Index].rgbBlue =
+               _MainPalette[Index].rgbBlue * Iteration / PALETTE_FADE_STEPS;
+         }
+
+         VidBitBlt(PaletteBitmapBuffer, 0, 0);
+      }
+#ifdef USE_PROGRESS_BAR
+      else
+      {
+         break;
+      }
+
+      Interval.QuadPart = -PALETTE_FADE_TIME;
+#else
+
+#if 0
+      if (AnimBarPos == 0)
+      {
+         VidSolidColorFill(0x173, 354, 0x178, 354 + 9, 0);
+      }
+      else if (AnimBarPos > 3)
+      {
+         VidSolidColorFill(0xe3 + AnimBarPos * 8, 354,
+                           0xe8 + AnimBarPos * 8, 354 + 9,
+                           0);
+      }
+
+      if (AnimBarPos >= 3)
+      {
+         VidBufferToScreenBlt(_Square1, 0xeb + AnimBarPos * 8, 354, 6, 9, 4);
+      }
+      if (AnimBarPos >= 2 && AnimBarPos <= 16)
+      {
+         VidBufferToScreenBlt(_Square2, 0xf3 + AnimBarPos * 8, 354, 6, 9, 4);
+      }
+      if (AnimBarPos >= 1 && AnimBarPos <= 15)
+      {
+         VidBufferToScreenBlt(_Square3, 0xfb + AnimBarPos * 8, 354, 6, 9, 4);
+      }
+#endif
+
+      if (Iteration <= PALETTE_FADE_STEPS)
+      {
+         Interval.QuadPart = -PALETTE_FADE_TIME;
+         if ((Iteration % 5) == 0)
+            AnimBarPos++;
+      }
+      else
+      {
+         Interval.QuadPart = -PALETTE_FADE_TIME * 5;
+         AnimBarPos++;
+      }
+      AnimBarPos = Iteration % 18;
+#endif
+
+      /* Wait for a bit. */
+      KeDelayExecutionThread(KernelMode, FALSE, &Interval);
+   }
+
+   DPRINT("Finishing bootvid thread.\n");
+   KeSetEvent(&ShutdownCompleteEvent, 0, FALSE);
+
+   PsTerminateSystemThread(0);
+}
+
+
+NTSTATUS NTAPI
+BootVidDisplayBootLogo(PVOID ImageBase)
+{
+   PBITMAPINFOHEADER BitmapInfoHeader;
+   LPRGBQUAD Palette;
+   static const ULONG BitmapIds[2] = {IDB_BOOTIMAGE, IDB_BAR};
+   PUCHAR BitmapData[2];
+   ULONG Index;
+   HANDLE BitmapThreadHandle;
+   CLIENT_ID BitmapThreadId;
+   NTSTATUS Status;
+
+   KeInitializeEvent(&ShutdownCompleteEvent, NotificationEvent, FALSE);
+
+   /*
+    * Get the bitmaps from the executable.
+    */
+
+   for (Index = 0; Index < sizeof(BitmapIds) / sizeof(BitmapIds[0]); Index++)
+   {
+      PIMAGE_RESOURCE_DATA_ENTRY ResourceDataEntry;
+      LDR_RESOURCE_INFO ResourceInfo;
+      ULONG Size;
+
+      ResourceInfo.Type = /* RT_BITMAP */ 2;
+      ResourceInfo.Name = BitmapIds[Index];
+      ResourceInfo.Language = 0x09;
+
+      Status = LdrFindResource_U(
+         ImageBase,
+         &ResourceInfo,
+         RESOURCE_DATA_LEVEL,
+         &ResourceDataEntry);
+
+      if (!NT_SUCCESS(Status))
+      {
+         DPRINT("LdrFindResource_U() failed with status 0x%.08x\n", Status);
+         return Status;
+      }
+
+      Status = LdrAccessResource(
+         ImageBase,
+         ResourceDataEntry,
+         (PVOID*)&BitmapData[Index],
+         &Size);
+
+      if (!NT_SUCCESS(Status))
+      {
+         DPRINT("LdrAccessResource() failed with status 0x%.08x\n", Status);
+         return Status;
+      }
+   }
+
+
+   /*
+    * Initialize the graphics output.
+    */
+
+   if (!VidInitialize(TRUE))
+   {
+      return STATUS_UNSUCCESSFUL;
+   }
+
+   /*
+    * Load the bar bitmap and get the square data from it.
+    */
+
+   VidBitBlt(BitmapData[1], 0, 0);   
+   VidScreenToBufferBlt(_Square1, 0, 0, 6, 9, 4);
+   VidScreenToBufferBlt(_Square2, 8, 0, 6, 9, 4);
+   VidScreenToBufferBlt(_Square3, 16, 0, 6, 9, 4);
+
+   /*
+    * Save the main image palette and replace it with black palette, so
+    * we can do fade in effect later.
+    */
+
+   BitmapInfoHeader = (PBITMAPINFOHEADER)BitmapData[0];
+   Palette = (LPRGBQUAD)(BitmapData[0] + BitmapInfoHeader->biSize);
+   RtlCopyMemory(_MainPalette, Palette, sizeof(_MainPalette));
+   RtlZeroMemory(Palette, sizeof(_MainPalette));
+
+   /*
+    * Display the main image.
+    */
+
+   VidBitBlt(BitmapData[0], 0, 0);
+
+   /*
+    * Start a thread that handles the fade in and bar animation effects.
+    */
+
+   Status = PsCreateSystemThread(
+      &BitmapThreadHandle,
+      THREAD_ALL_ACCESS,
+      NULL,
+      NULL,
+      &BitmapThreadId,
+      BootVidAnimationThread,
+      NULL);
+
+   if (!NT_SUCCESS(Status))
+   {
+      VidCleanUp();
+      return Status;
+   }
+
+   ZwClose(BitmapThreadHandle);
+
+   return STATUS_SUCCESS;
+}
+
+
+VOID NTAPI
+BootVidUpdateProgress(ULONG Progress)
+{
+#ifdef USE_PROGRESS_BAR
+   if (ShutdownNotify == 0)
+   {
+      VidSolidColorFill(0x103, 354, 0x103 + (Progress * 120 / 100), 354 + 9, 1);
+   }
+#endif
+}
+
+
+VOID NTAPI
+BootVidFinalizeBootLogo(VOID)
+{
+   InterlockedIncrement(&ShutdownNotify);
+   DPRINT1("Waiting for bootvid thread to finish.\n");
+   KeWaitForSingleObject(&ShutdownCompleteEvent, Executive, KernelMode,
+                         FALSE, NULL);
+   DPRINT1("Bootvid thread to finish.\n");
+   //VidResetDisplay();
+}
+
+
+NTSTATUS STDCALL
+DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
+{
+   return STATUS_SUCCESS;
+}

Propchange: branches/olpc/drivers/base/bootvid/bootvid.c
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*

Modified: branches/olpc/drivers/base/bootvid/bootvid.def
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvid.def?rev=27186&r1=27185&r2=27186&view=diff
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.def (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.def Fri Jun 15 14:58:37 2007
@@ -1,15 +1,14 @@
-LIBRARY BOOTVID.DLL
+LIBRARY bootvid.sys
 
 EXPORTS
-VidBitBlt at 12
-VidBufferToScreenBlt at 24
-VidCleanUp at 0
-VidDisplayString at 4
-VidDisplayStringXY
-VidInitialize at 4
-VidResetDisplay at 4
-VidScreenToBufferBlt at 24
-VidSetScrollRegion at 16
-VidSetTextColor at 4
-VidSolidColorFill at 20
-
+VidInitialize
+VidCleanUp
+VidResetDisplay
+VidBufferToScreenBlt
+VidScreenToBufferBlt
+VidBitBlt
+VidSolidColorFill
+VidDisplayString
+BootVidDisplayBootLogo
+BootVidUpdateProgress
+BootVidFinalizeBootLogo

Propchange: branches/olpc/drivers/base/bootvid/bootvid.def
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*

Modified: branches/olpc/drivers/base/bootvid/bootvid.rbuild
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvid.rbuild?rev=27186&r1=27185&r2=27186&view=diff
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.rbuild (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.rbuild Fri Jun 15 14:58:37 2007
@@ -2,11 +2,13 @@
 	<importlibrary definition="bootvid.def"></importlibrary>
 	<bootstrap base="$(CDOUTPUT)" nameoncd="bootvid.dll" />
 	<include base="bootvid">.</include>
-	<define name="__USE_W32API" />
+        <define name="__USE_W32API" />
 	<library>ntoskrnl</library>
 	<library>hal</library>
 	<file>bootvid.c</file>
-	<file>bootdata.c</file>
-	<file>vga.c</file>
+	<file>vid.c</file>
+	<file>vid_vga.c</file>
+	<file>vid_vgatext.c</file>
+	<file>vid_xbox.c</file>
 	<file>bootvid.rc</file>
-</module>
+</module>

Propchange: branches/olpc/drivers/base/bootvid/bootvid.rbuild
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*

Modified: branches/olpc/drivers/base/bootvid/bootvid.rc
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/bootvid.rc?rev=27186&r1=27185&r2=27186&view=diff
==============================================================================
--- branches/olpc/drivers/base/bootvid/bootvid.rc (original)
+++ branches/olpc/drivers/base/bootvid/bootvid.rc Fri Jun 15 14:58:37 2007
@@ -3,8 +3,12 @@
 #include "resource.h"
 
 #define REACTOS_VERSION_DLL
-#define REACTOS_STR_FILE_DESCRIPTION	"VGA Boot Driver\0"
-#define REACTOS_STR_INTERNAL_NAME	"bootvid.dll\0"
-#define REACTOS_STR_ORIGINAL_FILENAME	"bootvid.dll\0"
+#define REACTOS_STR_FILE_DESCRIPTION	"ReactOS Boot Video\0"
+#define REACTOS_STR_INTERNAL_NAME	"bootvid\0"
+#define REACTOS_STR_ORIGINAL_FILENAME	"bootvid.sys\0"
+#include <reactos/version.rc>
 
-#include <reactos/version.rc>
+IDB_BOOTIMAGE   BITMAP  DISCARDABLE   "bootimage.bmp"
+IDB_BAR         BITMAP  DISCARDABLE   "bar.bmp"
+
+

Propchange: branches/olpc/drivers/base/bootvid/bootvid.rc
------------------------------------------------------------------------------
--- svn:needs-lock (original)
+++ svn:needs-lock (removed)
@@ -1,1 +1,0 @@
-*

Removed: branches/olpc/drivers/base/bootvid/precomp.h
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/precomp.h?rev=27185&view=auto
==============================================================================
--- branches/olpc/drivers/base/bootvid/precomp.h (original)
+++ branches/olpc/drivers/base/bootvid/precomp.h (removed)
@@ -1,46 +1,0 @@
-#include "ntddk.h"
-#include "arc/arc.h"
-#include "halfuncs.h"
-#include "drivers/bootvid/bootvid.h"
-
-//
-// Command Stream Definitions
-//
-#define CMD_STREAM_WRITE            0x0
-#define CMD_STREAM_WRITE_ARRAY      0x2
-#define CMD_STREAM_USHORT           0x4
-#define CMD_STREAM_READ             0x8
-
-//
-// Bitmap Header
-//
-typedef struct tagBITMAPINFOHEADER
-{
-    ULONG biSize;
-    LONG biWidth;
-    LONG biHeight;
-    USHORT biPlanes;
-    USHORT biBitCount;
-    ULONG biCompression;
-    ULONG biSizeImage;
-    LONG biXPelsPerMeter;
-    LONG biYPelsPerMeter;
-    ULONG biClrUsed;
-    ULONG biClrImportant;
-} BITMAPINFOHEADER, *PBITMAPINFOHEADER;
-
-VOID
-NTAPI
-InitializePalette(
-    VOID
-);
-
-//
-// Globals
-//
-extern USHORT AT_Initialization[];
-extern ULONG curr_x;
-extern ULONG curr_y;
-extern ULONG_PTR VgaRegisterBase;
-extern ULONG_PTR VgaBase;
-extern UCHAR FontData[256 * 13];

Removed: branches/olpc/drivers/base/bootvid/vga.c
URL: http://svn.reactos.org/svn/reactos/branches/olpc/drivers/base/bootvid/vga.c?rev=27185&view=auto
==============================================================================
--- branches/olpc/drivers/base/bootvid/vga.c (original)
+++ branches/olpc/drivers/base/bootvid/vga.c (removed)
@@ -1,1274 +1,0 @@
-#include "precomp.h"
-
-/* GLOBALS *******************************************************************/
-
-ULONG ScrollRegion[4] =
-{
-    0,
-    0,
-    640 - 1,
-    480 - 1
-};
-UCHAR lMaskTable[8] =
-{
-    (1 << 8) - (1 << 0),
-    (1 << 7) - (1 << 0),
-    (1 << 6) - (1 << 0),
-    (1 << 5) - (1 << 0),
-    (1 << 4) - (1 << 0),
-    (1 << 3) - (1 << 0),
-    (1 << 2) - (1 << 0),
-    (1 << 1) - (1 << 0)
-};
-UCHAR rMaskTable[8] =
-{
-    (1 << 7),
-    (1 << 7)+ (1 << 6),
-    (1 << 7)+ (1 << 6) + (1 << 5),
-    (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4),
-    (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3),
-    (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) + (1 << 2),
-    (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) + (1 << 2) + (1 << 1),
-    (1 << 7)+ (1 << 6) + (1 << 5) + (1 << 4) + (1 << 3) + (1 << 2) + (1 << 1) +
-    (1 << 0),
-};
-UCHAR PixelMask[8] =
-{
-    (1 << 7),
-    (1 << 6),
-    (1 << 5),
-    (1 << 4),
-    (1 << 3),
-    (1 << 2),
-    (1 << 1),
-    (1 << 0),
-};
-ULONG lookup[16] =
-{
-    0x0000,
-    0x0100,
-    0x1000,
-    0x1100,
-    0x0001,
-    0x0101,
-    0x1001,
-    0x1101,
-    0x0010,
-    0x0110,
-    0x1010,
-    0x1110,
-    0x0011,
-    0x0111,
-    0x1011,
-    0x1111,
-};
-
-ULONG TextColor = 0xF;
-ULONG curr_x = 0;
-ULONG curr_y = 0;
-BOOLEAN NextLine = FALSE;
-ULONG_PTR VgaRegisterBase = 0;
-ULONG_PTR VgaBase = 0;
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-VOID
-NTAPI
-ReadWriteMode(UCHAR Mode)
-{
-    UCHAR Value;
-
-    /* Switch to graphics mode register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 5);
-
-    /* Get the current register value, minus the current mode */
-    Value = READ_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF) & 0xF4;
-
-    /* Set the new mode */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, Mode | Value);
-}
-
-VOID
-NTAPI
-__outpb(IN ULONG Port,
-        IN ULONG Value)
-{
-    /* Write to the VGA Register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + Port, (UCHAR)Value);
-}
-
-VOID
-NTAPI
-__outpw(IN ULONG Port,
-        IN ULONG Value)
-{
-    /* Write to the VGA Register */
-    WRITE_PORT_USHORT((PUSHORT)(VgaRegisterBase + Port), (USHORT)Value);
-}
-
-VOID
-NTAPI
-SetPixel(IN ULONG Left,
-         IN ULONG Top,
-         IN UCHAR Color)
-{
-    PUCHAR PixelPosition;
-
-    /* Calculate the pixel position. */
-    PixelPosition = (PUCHAR)VgaBase + (Left >> 3) + (Top * 80);
-
-    /* Switch to mode 10 */
-    ReadWriteMode(10);
-
-    /* Clear the 4 planes (we're already in unchained mode here) */
-    __outpw(0x3C4, 0xF02);
-
-    /* Select the color don't care register */
-    __outpw(0x3CE, 7);
-
-    /* Select the bitmask register and write the mask */
-    __outpw(0x3CE, (PixelMask[Left & 7] << 8) | 8);
-
-    /* Read the current pixel value and add our color */
-    WRITE_REGISTER_UCHAR(PixelPosition,
-                         READ_REGISTER_UCHAR(PixelPosition) & Color);
-}
-
-VOID
-NTAPI
-DisplayCharacter(CHAR Character,
-                 ULONG Left,
-                 ULONG Top,
-                 ULONG TextColor,
-                 ULONG BackTextColor)
-{
-    PUCHAR FontChar;
-    ULONG i, j, XOffset;
-
-    /* Get the font line for this character */
-    FontChar = &FontData[Character * 13 - Top];
-
-    /* Loop each pixel height */
-    i = 13;
-    do
-    {
-        /* Loop each pixel width */
-        j = 128;
-        XOffset = Left;
-        do
-        {
-            /* Check if we should draw this pixel */
-            if (FontChar[Top] & (UCHAR)j)
-            {
-                /* We do, use the given Text Color */
-                SetPixel(XOffset, Top, (UCHAR)TextColor);
-            }
-            else if (BackTextColor < 16)
-            {
-                /* This is a background pixel. We're drawing it unless it's */
-                /* transparent. */
-                SetPixel(XOffset, Top, (UCHAR)BackTextColor);
-            }
-
-            /* Increase X Offset */
-            XOffset++;
-        } while (j >>= 1);
-
-        /* Move to the next Y ordinate */
-        Top++;
-    } while (--i);
-}
-
-VOID
-NTAPI
-DisplayStringXY(PUCHAR String,
-                ULONG Left,
-                ULONG Top,
-                ULONG TextColor,
-                ULONG BackColor)
-{
-    /* Loop every character */
-    while (*String)
-    {
-        /* Display a character */
-        DisplayCharacter(*String, Left, Top, TextColor, BackColor);
-
-        /* Move to next character and next position */
-        String++;
-        Left += 8;
-    }
-}
-
-VOID
-NTAPI
-SetPaletteEntryRGB(IN ULONG Id,
-                   IN ULONG Rgb)
-{
-    PCHAR Colors = (PCHAR)&Rgb;
-
-    /* Set the palette index */
-    __outpb(0x3C8, (UCHAR)Id);
-
-    /* Set RGB colors */
-    __outpb(0x3C9, Colors[2] >> 2);
-    __outpb(0x3C9, Colors[1] >> 2);
-    __outpb(0x3C9, Colors[0] >> 2);
-}
-
-VOID
-NTAPI
-InitPaletteWithTable(IN PULONG Table,
-                     IN ULONG Count)
-{
-    ULONG i;
-    PULONG Entry = Table;
-
-    /* Loop every entry */
-    for (i = 0; i < Count; i++, Entry++)
-    {
-        /* Set the entry */
-        SetPaletteEntryRGB(i, *Entry);
-    }
-}
-
-VOID
-NTAPI
-SetPaletteEntry(IN ULONG Id,
-                IN ULONG PaletteEntry)
-{
-    /* Set the palette index */
-    __outpb(0x3C8, (UCHAR)Id);
-
-    /* Set RGB colors */
-    __outpb(0x3C9, PaletteEntry & 0xFF);
-    __outpb(0x3C9, (PaletteEntry >>= 8) & 0xFF);
-    __outpb(0x3C9, (PaletteEntry >> 8) & 0xFF);
-}
-
-VOID
-NTAPI
-InitializePalette(VOID)
-{
-    ULONG PaletteEntry[16] = {0,
-                              0x20,
-                              0x2000,
-                              0x2020,
-                              0x200000,
-                              0x200020,
-                              0x202000,
-                              0x202020,
-                              0x303030,
-                              0x3F,
-                              0x3F00,
-                              0x3F3F,
-                              0x3F0000,
-                              0x3F003F,
-                              0x3F3F00,
-                              0x3F3F3F};
-    ULONG i;
-
-    /* Loop all the entries and set their palettes */
-    for (i = 0; i < 16; i++) SetPaletteEntry(i, PaletteEntry[i]);
-}
-
-VOID
-NTAPI
-VgaScroll(ULONG Scroll)
-{
-    ULONG Top;
-    ULONG SourceOffset, DestOffset;
-    ULONG Offset;
-    ULONG i, j;
-
-    /* Set memory positions of the scroll */
-    SourceOffset = VgaBase + (ScrollRegion[1] * 80) + (ScrollRegion[0] >> 3);
-    DestOffset = SourceOffset + (Scroll * 80);
-
-    /* Clear the 4 planes */
-    __outpw(0x3C4, 0xF02);
-
-    /* Set the bitmask to 0xFF for all 4 planes */
-    __outpw(0x3CE, 0xFF08);
-
-    /* Set Mode 1 */
-    ReadWriteMode(1);
-
-    /* Save top and check if it's above the bottom */
-    Top = ScrollRegion[1];
-    if (Top > ScrollRegion[3]) return;
-
-    /* Start loop */
-    do
-    {
-        /* Set number of bytes to loop and start offset */
-        Offset = ScrollRegion[0] >> 3;
-        j = SourceOffset;
-
-        /* Check if this is part of the scroll region */
-        if (Offset <= (ScrollRegion[2] >> 3))
-        {
-            /* Update position */
-            i = DestOffset - SourceOffset;
-
-            /* Loop the X axis */
-            do
-            {
-                /* Write value in the new position so that we can do the scroll */
-                WRITE_REGISTER_UCHAR((PUCHAR)j,
-                                     READ_REGISTER_UCHAR((PUCHAR)j + i));
-
-                /* Move to the next memory location to write to */
-                j++;
-
-                /* Move to the next byte in the region */
-                Offset++;
-
-                /* Make sure we don't go past the scroll region */
-            } while (Offset <= (ScrollRegion[2] >> 3));
-        }
-
-        /* Move to the next line */
-        SourceOffset += 80;
-        DestOffset += 80;
-
-        /* Increase top */
-        Top++;
-
-        /* Make sure we don't go past the scroll region */
-    } while (Top <= ScrollRegion[3]);
-}
-
-VOID
-NTAPI
-PreserveRow(IN ULONG CurrentTop,
-            IN ULONG TopDelta,
-            IN BOOLEAN Direction)
-{
-    PUCHAR Position1, Position2;
-    ULONG Count;
-
-    /* Clear the 4 planes */
-    __outpw(0x3C4, 0xF02);
-
-    /* Set the bitmask to 0xFF for all 4 planes */
-    __outpw(0x3CE, 0xFF08);
-
-    /* Set Mode 1 */
-    ReadWriteMode(1);
-
-    /* Check which way we're preserving */
-    if (Direction)
-    {
-        /* Calculate the position in memory for the row */
-        Position1 = (PUCHAR)VgaBase + CurrentTop * 80;
-        Position2 = (PUCHAR)VgaBase + 0x9600;
-    }
-    else
-    {
-        /* Calculate the position in memory for the row */
-        Position1 = (PUCHAR)VgaBase + 0x9600;
-        Position2 = (PUCHAR)VgaBase + CurrentTop * 80;
-    }
-
-    /* Set the count and make sure it's above 0 */
-    Count = TopDelta * 80;
-    if (Count)
-    {
-        /* Loop every pixel */
-        do
-        {
-            /* Write the data back on the other position */
-            WRITE_REGISTER_UCHAR(Position1, READ_REGISTER_UCHAR(Position2));
-
-            /* Increase both positions */
-            Position2++;
-            Position1++;
-        } while (--Count);
-    }
-}
-
-VOID
-NTAPI
-BitBlt(IN ULONG Left,
-       IN ULONG Top,
-       IN ULONG Width,
-       IN ULONG Height,
-       IN PUCHAR Buffer,
-       IN ULONG BitsPerPixel,
-       IN ULONG Delta)
-{
-    ULONG LeftAnd, LeftShifted, LeftPlusOne, LeftPos;
-    ULONG lMask, rMask;
-    UCHAR NotlMask;
-    ULONG Distance;
-    ULONG DistanceMinusLeftBpp;
-    ULONG SomeYesNoFlag, SomeYesNoFlag2;
-    PUCHAR PixelPosition, m;
-    PUCHAR i, k;
-    ULONG j;
-    ULONG x;
-    ULONG Plane;
-    UCHAR LeftArray[84];
-    PUCHAR CurrentLeft;
-    PUCHAR l;
-    ULONG LoopCount;
-    UCHAR pMask, PlaneShift;
-    BOOLEAN Odd;
-    UCHAR Value;
-
-    /* Check if the buffer isn't 4bpp */
-    if (BitsPerPixel != 4)
-    {
-        /* FIXME: TODO */
-        DbgPrint("Unhandled BitBlt\n"
-                 "%lxx%lx @ (%lx,%lx)\n"
-                 "Bits Per Pixel %lx\n"
-                 "Buffer: %p. Delta: %lx\n",
-                 Width,
-                 Height,
-                 Left,
-                 Top,
-                 BitsPerPixel,
-                 Buffer,
-                 Delta);
-        return;
-    }
-
-    /* Get the masks and other values */
-    LeftAnd = Left & 0x7;
-    lMask = lMaskTable[LeftAnd];
-    Distance = Width + Left;
-    rMask = rMaskTable[(Distance - 1) & 0x7];
-    Left >>= 3;
-
-    /* Set some values */
-    SomeYesNoFlag = FALSE;
-    SomeYesNoFlag2 = FALSE;
-    Distance = (Distance - 1) >> 3;
-    DistanceMinusLeftBpp = Distance - Left;
-
-    /* Check if the distance is equal to the left position and add the masks */
-    if (Left == Distance) lMask += rMask;
-
-    /* Check if there's no distance offset */
-    if (DistanceMinusLeftBpp)
-    {
-        /* Set the first flag on */
-        SomeYesNoFlag = TRUE;
-
-        /* Decrease offset and check if we still have one */
-        if (--DistanceMinusLeftBpp)
-        {
-            /* Still have a distance offset */
-            SomeYesNoFlag2 = TRUE;
-        }
-    }
-
-    /* Calculate initial pixel position */
-    PixelPosition = (PUCHAR)VgaBase + (Top * 80) + Left;
-
-    /* Set loop buffer variable */
-    i = Buffer;
-
-    /* Switch to mode 0 */
-    ReadWriteMode(0);
-
-    /* Leave now if the height is 0 */
-    if (Height <= 0) return;
-
-    /* Set more weird values */
-    CurrentLeft = &LeftArray[Left];
-    NotlMask = ~(UCHAR)lMask;
-    LeftPlusOne = Left + 1;
-    LeftShifted = (lMask << 8) | 8;
-    j = Height;
-
-    /* Start the height loop */
-    do
-    {
-        /* Start the plane loop */
-        Plane = 0;
-        do
-        {
-            /* Clear the current value */
-            *CurrentLeft = 0;
-            LoopCount = 0;
-
-            /* Set the buffer loop variable for this loop */
-            k = i;
-
-            /* Calculate plane shift and pixel mask */
-            PlaneShift = 1 << Plane;
-            pMask = PixelMask[LeftAnd];
-
-            /* Check if we have a width */
-            if (Width > 0)
-            {
-                /* Loop it */
-                l = CurrentLeft;
-                x = Width;
-                do
-                {
-                    /* Check if we're odd and increase the loop count */
-                    Odd = LoopCount & 1 ? TRUE : FALSE;
-                    LoopCount++;
-                    if (Odd)
-                    {
-                        /* Check for the plane shift */
-                        if (*k & PlaneShift)
-                        {
-                            /* Write the pixel mask */
-                            *l |= pMask;
-                        }
-
-                        /* Increase buffer position */
-                        k++;
-                    }
-                    else
-                    {
-                        /* Check for plane shift */
-                        if ((*k >> 4) & PlaneShift)
-                        {
-                            /* Write the pixel mask */
-                            *l |= pMask;
-                        }
-                    }
-
-                    /* Shift the pixel mask */
-                    pMask >>= 1;
-                    if (!pMask)
-                    {
-                        /* Move to the next current left position and clear it */
-                        l++;
-                        *l = 0;
-
-                        /* Set the pixel mask to 0x80 */
-                        pMask = 0x80;
-                    }
-                } while (--x);
-            }
-
-            /* Set the plane value */
-            __outpw(0x3C4, (1 << (Plane + 8) | 2));
-
-            /* Select the bitmask register and write the mask */
-            __outpw(0x3CE, (USHORT)LeftShifted);
-
-            /* Read the current Pixel value */
-            Value = READ_REGISTER_UCHAR(PixelPosition);
-
-            /* Add our mask */
-            Value = (Value & NotlMask) | *CurrentLeft;
-
-            /* Set current left for the loop, and write new pixel value */
-            LeftPos = LeftPlusOne;
-            WRITE_REGISTER_UCHAR(PixelPosition, Value);
-
-            /* Set loop pixel position and check if we should loop */
-            m = PixelPosition + 1;
-            if (SomeYesNoFlag2)
-            {
-                /* Set the bitmask to 0xFF for all 4 planes */
-                __outpw(0x3CE, 0xFF08);
-
-                /* Check if we have any distance left */
-                if (DistanceMinusLeftBpp > 0)
-                {
-                    /* Start looping it */
-                    x = DistanceMinusLeftBpp;
-                    do
-                    {
-                        /* Write the value */
-                        WRITE_REGISTER_UCHAR(m, LeftArray[LeftPos]);
-
-                        /* Go to the next position */
-                        m++;
-                        LeftPos++;
-                    } while (--x);
-                }
-            }
-
-            /* Check if the first flag is on */
-            if (SomeYesNoFlag)
-            {
-                /* Set the mask value */
-                __outpw(0x3CE, (rMask << 8) | 8);
-
-                /* Read the current Pixel value */
-                Value = READ_REGISTER_UCHAR(m);
-
-                /* Add our mask */
-                Value = (Value & ~(UCHAR)rMask) | LeftArray[LeftPos];
-
-                /* Set current left for the loop, and write new pixel value */
-                WRITE_REGISTER_UCHAR(m, Value);
-            }
-        } while (++Plane < 4);
-
-        /* Update pixel position, buffer and height */
-        PixelPosition += 80;
-        i += Delta;
-    } while (--j);
-}
-
-VOID
-NTAPI
-RleBitBlt(IN ULONG Left,
-          IN ULONG Top,
-          IN ULONG Width,
-          IN ULONG Height,
-          IN PUCHAR Buffer)
-{
-    ULONG YDelta;
-    ULONG x;
-    ULONG RleValue, NewRleValue;
-    ULONG Color, Color2;
-    ULONG i, j;
-    ULONG Code;
-
-    /* Set Y height and current X value and start loop */
-    YDelta = Top + Height - 1;
-    x = Left;
-    for (;;)
-    {
-        /* Get the current value and advance in the buffer */
-        RleValue = *Buffer;
-        Buffer++;
-        if (RleValue)
-        {
-            /* Check if we've gone past the edge */
-            if ((x + RleValue) > (Width + Left))
-            {
-                /* Fixeup the pixel value */
-                RleValue = Left - x + Width;
-            }
-
-            /* Get the new value */
-            NewRleValue = *Buffer;
-
-            /* Get the two colors */
-            Color = NewRleValue >> 4;
-            Color2 = NewRleValue & 0xF;
-
-            /* Increase buffer positition */
-            Buffer++;
-
-            /* Check if we need to do a fill */
-            if (Color == Color2)
-            {
-                /* Do a fill and continue the loop */
-                RleValue += x;
-                VidSolidColorFill(x, YDelta, RleValue - 1, YDelta, (UCHAR)Color);
-                x = RleValue;
-                continue;
-            }
-
-            /* Check if the pixel value is 1 or below */
-            if (RleValue > 1)
-            {
-                /* Set loop variables */
-                i = (RleValue - 2) / 2 + 1;
-                do
-                {
-                    /* Set the pixels */
-                    SetPixel(x, YDelta, (UCHAR)Color);
-                    x++;
-                    SetPixel(x, YDelta, (UCHAR)Color2);
-                    x++;
-
-                    /* Decrease pixel value */
-                    RleValue -= 2;
-                } while (--i);
-            }
-
-            /* Check if there is any value at all */
-            if (RleValue)
-            {
-                /* Set the pixel and increase posititon */
-                SetPixel(x, YDelta, (UCHAR)Color);
-                x++;
-            }
-
-            /* Start over */
-            continue;
-        }
-
-        /* Get the current pixel value */
-        RleValue = *Buffer;
-        Code = RleValue;
-        switch (Code)
-        {
-            /* Case 0 */
-            case 0:
-
-                /* Set new x value, decrease distance and restart */
-                x = Left;
-                YDelta--;
-                Buffer++;
-                continue;
-
-            /* Case 1 */
-            case 1:
-
-                /* Done */
-                return;
-
-            /* Case 2 */
-            case 2:
-
-                /* Set new x value, decrease distance and restart */
-                Buffer++;
-                x += *Buffer;
-                Buffer++;
-                YDelta -= *Buffer;
-                Buffer++;
-                continue;
-
-            /* Other values */
-            default:
-
-                Buffer++;
-                break;
-        }
-
-        /* Check if we've gone past the edge */
-        if ((x + RleValue) > (Width + Left))
-        {
-            /* Set fixed up loop count */
-            i = RleValue - Left - Width + x;
-
-            /* Fixup pixel value */
-            RleValue -= i;
-        }
-        else
-        {
-            /* Clear loop count */
-            i = 0;
-        }
-
-        /* Check the value now */
-        if (RleValue > 1)
-        {
-            /* Set loop variables */
-            j = (RleValue - 2) / 2 + 1;
-            do
-            {
-                /* Get the new value */
-                NewRleValue = *Buffer;
-
-                /* Get the two colors */
-                Color = NewRleValue >> 4;
-                Color2 = NewRleValue & 0xF;
-
-                /* Increase buffer position */
-                Buffer++;
-
-                /* Set the pixels */
-                SetPixel(x, YDelta, (UCHAR)Color);
-                x++;
-                SetPixel(x, YDelta, (UCHAR)Color2);
-                x++;
-
-                /* Decrease pixel value */
-                RleValue -= 2;
-            } while (--j);
-        }
-
-        /* Check if there is any value at all */
-        if (RleValue)
-        {
-            /* Set the pixel and increase position */
-            Color = *Buffer >> 4;
-            Buffer++;
-            SetPixel(x, YDelta, (UCHAR)Color);
-            x++;
-            i--;
-        }
-
-        /* Check loop count now */
-        if ((LONG)i > 0)
-        {
-            /* Decrease it */
-            i--;
-
-            /* Set new position */
-            Buffer = Buffer + (i / 2) + 1;
-        }
-
-        /* Check if we need to increase the buffer */
-        if ((ULONG_PTR)Buffer & 1) Buffer++;
-    }
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-VidSetTextColor(ULONG Color)
-{
-    ULONG OldColor;
-
-    /* Save the old color and set the new one */
-    OldColor = TextColor;
-    TextColor = Color;
-    return OldColor;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayStringXY(PUCHAR String,
-                   ULONG Left,
-                   ULONG Top,
-                   BOOLEAN Transparent)
-{
-    ULONG BackColor;
-
-    /* If the caller wanted transparent, then send the special value (16), else */
-    /* use our default and call the helper routine. */
-    BackColor = (Transparent) ? 16 : 14;
-    DisplayStringXY(String, Left, Top, 12, BackColor);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSetScrollRegion(ULONG x1,
-                   ULONG y1,
-                   ULONG x2,
-                   ULONG y2)
-{
-    /* Assert alignment */
-    ASSERT((x1 & 0x7) == 0);
-    ASSERT((x2 & 0x7) == 7);
-
-    /* Set Scroll Region */
-    ScrollRegion[0] = x1;
-    ScrollRegion[1] = y1;
-    ScrollRegion[2] = x2;
-    ScrollRegion[3] = y2;
-
-    /* Set current X and Y */
-    curr_x = x1;
-    curr_y = y1;
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidCleanUp(VOID)
-{
-    /* Select bit mask register */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CE, 8);
-
-    /* Clear it */
-    WRITE_PORT_UCHAR((PUCHAR)VgaRegisterBase + 0x3CF, 255);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBufferToScreenBlt(IN PUCHAR Buffer,
-                     IN ULONG Left,
-                     IN ULONG Top,
-                     IN ULONG Width,
-                     IN ULONG Height,
-                     IN ULONG Delta)
-{
-    /* Make sure we have a width and height */
-    if (!(Width) || !(Height)) return;
-
-    /* Call the helper function */
-    BitBlt(Left, Top, Width, Height, Buffer, 4, Delta);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidDisplayString(PUCHAR String)
-{
-    ULONG TopDelta = 14;
-
-    /* Start looping the string */
-    while (*String)
-    {
-        /* Treat new-line separately */
-        if (*String == '\n')
-        {
-            /* Modify Y position */
-            curr_y += TopDelta;
-            if (curr_y >= ScrollRegion[3])
-            {
-                /* Scroll the view */
-                VgaScroll(TopDelta);
-                curr_y -= TopDelta;
-
-                /* Preserve row */
-                PreserveRow(curr_y, TopDelta, TRUE);
-            }
-
-            /* Update current X */
-            curr_x = ScrollRegion[0];
-
-            /* Preseve the current row */
-            PreserveRow(curr_y, TopDelta, FALSE);
-        }
-        else if (*String == '\r')
-        {
-            /* Update current X */
-            curr_x = ScrollRegion[0];
-
-            /* Check if we're being followed by a new line */
-            if (String[1] != '\n') NextLine = TRUE;
-        }
-        else
-        {
-            /* Check if we had a \n\r last time */
-            if (NextLine)
-            {
-                /* We did, preserve the current row */
-                PreserveRow(curr_y, TopDelta, TRUE);
-                NextLine = FALSE;
-            }
-
-            /* Display this character */
-            DisplayCharacter(*String, curr_x, curr_y, TextColor, 16);
-            curr_x += 8;
-
-            /* Check if we should scroll */
-            if (curr_x > ScrollRegion[2])
-            {
-                /* Update Y position and check if we should scroll it */
-                curr_y += TopDelta;
-                if (curr_y > ScrollRegion[3])
-                {
-                    /* Do the scroll */
-                    VgaScroll(TopDelta);
-                    curr_y -= TopDelta;
-
-                    /* Save the row */
-                    PreserveRow(curr_y, TopDelta, TRUE);
-                }
-
-                /* Update X */
-                curr_x = ScrollRegion[0];
-            }
-        }
-
-        /* Get the next character */
-        String++;
-    }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidBitBlt(PUCHAR Buffer,
-          ULONG Left,
-          ULONG Top)
-{
-    PBITMAPINFOHEADER BitmapInfoHeader;
-    LONG Delta;
-    PUCHAR BitmapOffset;
-
-    /* Get the Bitmap Header */
-    BitmapInfoHeader = (PBITMAPINFOHEADER)Buffer;
-
-    /* Initialize the palette */
-    InitPaletteWithTable((PULONG)(Buffer + BitmapInfoHeader->biSize),
-                         (BitmapInfoHeader->biClrUsed) ?
-                         BitmapInfoHeader->biClrUsed : 16);
-
-    /* Make sure we can support this bitmap */
-    ASSERT((BitmapInfoHeader->biBitCount * BitmapInfoHeader->biPlanes) <= 4);
-
-    /* Calculate the delta and align it on 32-bytes, then calculate the actual */
-    /* start of the bitmap data. */
-    Delta = (BitmapInfoHeader->biBitCount * BitmapInfoHeader->biWidth) + 31;
-    Delta >>= 3;
-    Delta &= ~3;
-    BitmapOffset = Buffer + sizeof(BITMAPINFOHEADER) + 16 * sizeof(ULONG);
-
-    /* Check the compression of the bitmap */
-    if (BitmapInfoHeader->biCompression == 2)
-    {
-        /* Make sure we have a width and a height */
-        if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
-        {
-            /* We can use RLE Bit Blt */
-            RleBitBlt(Left,
-                      Top,
-                      BitmapInfoHeader->biWidth,
-                      BitmapInfoHeader->biHeight,
-                      BitmapOffset);
-        }
-    }
-    else
-    {
-        /* Check if the height is negative */
-        if (BitmapInfoHeader->biHeight < 0)
-        {
-            /* Make it positive in the header */
-            BitmapInfoHeader->biHeight *= -1;
-        }
-        else
-        {
-            /* Update buffer offset */
-            BitmapOffset += ((BitmapInfoHeader->biHeight -1) * Delta);
-            Delta *= -1;
-        }
-
-        /* Make sure we have a width and a height */
-        if ((BitmapInfoHeader->biWidth) && (BitmapInfoHeader->biHeight))
-        {
-            /* Do the BitBlt */
-            BitBlt(Left,
-                   Top,
-                   BitmapInfoHeader->biWidth,
-                   BitmapInfoHeader->biHeight,
-                   BitmapOffset,
-                   BitmapInfoHeader->biBitCount,
-                   Delta);
-        }
-    }
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidScreenToBufferBlt(PUCHAR Buffer,
-                     ULONG Left,
-                     ULONG Top,
-                     ULONG Width,
-                     ULONG Height,
-                     ULONG Delta)
-{
-    ULONG Plane;
-    ULONG XDistance;
-    ULONG LeftDelta, RightDelta;
-    ULONG PixelOffset;
-    PUCHAR PixelPosition;
-    PUCHAR k, i;
-    PULONG m;
-    UCHAR Value, Value2;
-    UCHAR a;
-    ULONG b;
-    ULONG x, y;
-
-    /* Calculate total distance to copy on X */
-    XDistance = Left + Width - 1;
-
-    /* Start at plane 0 */
-    Plane = 0;
-
-    /* Calculate the 8-byte left and right deltas */
-    LeftDelta = Left & 7;
-    RightDelta = 8 - LeftDelta;
-
-    /* Clear the destination buffer */
-    RtlZeroMemory(Buffer, Delta * Height);
-
-    /* Calculate the pixel offset and convert the X distance into byte form */
-    PixelOffset = Top * 80 + (Left >> 3);
-    XDistance >>= 3;
-
-    /* Loop the 4 planes */
-    do
-    {
-        /* Set the current pixel position and reset buffer loop variable */
-        PixelPosition = (PUCHAR)VgaBase + PixelOffset;
-        i = Buffer;
-
-        /* Set Mode 0 */
-        ReadWriteMode(0);
-
-        /* Set the current plane */
-        __outpw(0x3CE, (Plane << 8) | 4);
-
-        /* Make sure we have a height */
-        if (Height > 0)
-        {
-            /* Start the outer Y loop */
-            y = Height;
-            do
-            {
-                /* Read the current value */
-                m = (PULONG)i;
-                Value = READ_REGISTER_UCHAR(PixelPosition);
-
-                /* Set Pixel Position loop variable */
-                k = PixelPosition + 1;
-
-                /* Check if we're still within bounds */
-                if (Left <= XDistance)
-                {
-                    /* Start X Inner loop */
-                    x = (XDistance - Left) + 1;
-                    do
-                    {
-                        /* Read the current value */
-                        Value2 = READ_REGISTER_UCHAR(k);
-
-                        /* Increase pixel position */
-                        k++;
-
-                        /* Do the blt */
-                        a = Value2 >> (UCHAR)RightDelta;
-                        a |= Value << (UCHAR)LeftDelta;
-                        b = lookup[a & 0xF];
-                        a >>= 4;
-                        b <<= 16;
-                        b |= lookup[a];
-
-                        /* Save new value to buffer */
-                        *m |= (b << Plane);
-
-                        /* Move to next destination location */
-                        m++;
-
-                        /* Write new value */
-                        Value = Value2;
-                    } while (--x);
-                }
-
-                /* Update pixel position */
-                PixelPosition += 80;
-                i += Delta;
-            } while (--y);
-        }
-   } while (++Plane < 4);
-}
-
-/*
- * @implemented
- */
-VOID
-NTAPI
-VidSolidColorFill(IN ULONG Left,
-                  IN ULONG Top,
-                  IN ULONG Right,
-                  IN ULONG Bottom,
-                  IN UCHAR Color)
-{
-    ULONG rMask, lMask;
-    ULONG LeftOffset, RightOffset, Distance;
-    PUCHAR Offset;
-    ULONG i, j;
-
-    /* Get the left and right masks, shifts, and delta */
-    LeftOffset = Left >> 3;
-    lMask = (lMaskTable[Left & 0x7] << 8) | 8;
-    RightOffset = Right >> 3;
-    rMask = (rMaskTable[Right & 0x7] << 8) | 8;
-    Distance = RightOffset - LeftOffset;
-
-    /* If there is no distance, then combine the right and left masks */
-    if (!Distance) lMask &= rMask;
-
-    /* Switch to mode 10 */
-    ReadWriteMode(10);
-
-    /* Clear the 4 planes (we're already in unchained mode here) */
-    __outpw(0x3C4, 0xF02);
-
-    /* Select the color don't care register */
-    __outpw(0x3CE, 7);
-
-    /* Calculate pixel position for the read */
-    Offset = VgaBase + (Top * 80) + (PUCHAR)LeftOffset;
-
-    /* Select the bitmask register and write the mask */
-    __outpw(0x3CE, (USHORT)lMask);
-
-    /* Check if the top coord is below the bottom one */
-    if (Top <= Bottom)
-    {
-        /* Start looping each line */
-        i = (Bottom - Top) + 1;
-        do
-        {
-            /* Read the previous value and add our color */
-            WRITE_REGISTER_UCHAR(Offset, READ_REGISTER_UCHAR(Offset) & Color);
-
-            /* Move to the next line */
-            Offset += 80;
-        } while (--i);
-    }
-
-    /* Check if we have a delta */
-    if (Distance)
-    {
-        /* Calculate new pixel position */
-        Offset = VgaBase + (Top * 80) + (PUCHAR)RightOffset;
-        Distance--;
-
-        /* Select the bitmask register and write the mask */
-        __outpw(0x3CE, (USHORT)rMask);
-
-        /* Check if the top coord is below the bottom one */
-        if (Top <= Bottom)
-        {
-            /* Start looping each line */
-            i = (Bottom - Top) + 1;
-            do
-            {
-                /* Read the previous value and add our color */
-                WRITE_REGISTER_UCHAR(Offset,
-                                     READ_REGISTER_UCHAR(Offset) & Color);
-
-                /* Move to the next line */
-                Offset += 80;
-            } while (--i);
-        }
-
-        /* Check if we still have a delta */
-        if (Distance)
-        {
-            /* Calculate new pixel position */
-            Offset = VgaBase + (Top * 80) + (PUCHAR)(LeftOffset + 1);
-
-            /* Set the bitmask to 0xFF for all 4 planes */
-            __outpw(0x3CE, 0xFF08);
-
-            /* Check if the top coord is below the bottom one */
-            if (Top <= Bottom)
-            {
-                /* Start looping each line */
-                i = (Bottom - Top) + 1;
-                do
-                {
-                    /* Loop the shift delta */
-                    if (Distance > 0)
-                    {
-                        for (j = Distance; j; Offset++, j--)
-                        {
-                            /* Write the color */
-                            WRITE_REGISTER_UCHAR(Offset, Color);
-                        }
-                    }
-
-                    /* Update position in memory */
-                    Offset += (80 - Distance);
-                } while (--i);
-            }
-        }
-    }
-}
-





More information about the Ros-dev mailing list