Ticket #1999: patch_bootsplash_20080406.diff

src/tools/generate_boot_screen.cpp

@@ -5 +5 @@
  *  Authors:
  *      Artur Wyszynski <harakash@gmail.com>
  *      Stephan Aßmus <superstippi@gmx.de>
+ *      Philippe Saint-Pierre <stpere@gmail.com>
  */
 
 //! Haiku boot splash image generator/converter
@@ -13 +14 @@
 #include <png.h>
 #include <string>
 #include <stdarg.h>
+#include <stdint.h>
 
 // TODO: Generate the single optimal palette for all three images,
 // store palette versions of these images as well, so that they are
@@ -21 +23 @@
 
 
 FILE* sOutput = NULL;
+int   sOffset = 0;
 
-
 static void
 error(const char *s, ...)
 {
@@ -120 +122 @@
 
 
 static void
+newLineIfRequired()
+{
+    sOffset++;
+    if (sOffset%12 == 0)
+    {
+        fprintf(sOutput, "\n\t");
+    }
+}
+
+
+static void
 writeHeader(const char* baseName, int width, int height, png_bytep* rowPtrs)
 {
     fprintf(sOutput, "static const uint16 %sWidth = %d;\n", baseName, width);
     fprintf(sOutput, "static const uint16 %sHeight = %d;\n", baseName, height);
     fprintf(sOutput, "#ifndef __BOOTSPLASH_KERNEL__\n");
-    fprintf(sOutput, "static const RLE_element %sCompressedImage[] = {\n\t",
+    
+    int buffer[128];
+    // buffer[0] stores count, buffer[1..127] holds the actual values
+
+    fprintf(sOutput, "static uint8 %sCompressedImage[] = {\n\t",
         baseName);
 
-    int offset = 0;
-    int lastColor = -1;
-    int counter = 0;
-    for (int y = 0; y < height; y++) {
-        png_byte* row = rowPtrs[y];
-        for (int x = 0; x < width * 3; x++) {
-            if (lastColor == row[x]) {
-                // if the currentColor is already being counted...
-                counter++;
-            } else {
-                // otherwise display what we had in memory, record that color
-                // and reset the counter...
-                if (lastColor != -1) {
-                    offset++;
-                    fprintf(sOutput, "{%d, 0x%02x}, ", counter, lastColor);
-                    if (offset % 6 == 0) {
-                        fprintf(sOutput, "\n\t");
+    for (int c = 0; c < 3; c++)
+    {
+        // for each component i.e. R, G, B ...
+        // NOTE : I don't care much about performance at this step, decoding however...
+        int currentValue = rowPtrs[0][c];
+        int count = 0;
+
+        // When bufferActive == true, we store the number rather than writing 
+        // them directly; we use this to store numbers until we find a pair..
+        bool bufferActive = false;
+
+        sOffset = 0;
+
+        for (int y = 0; y < height; y++) {
+            png_byte* row = rowPtrs[y];
+            for (int x = c; x < width * 3; x += 3) {
+                if (row[x] == currentValue) {
+                    if (bufferActive) {
+                        bufferActive = false;
+                        count = 2;
+                        if (buffer[0] > 1) {
+                            fprintf (sOutput, "%d, ", 
+                                128 + buffer[0] - 1);
+                            newLineIfRequired();
+                            for (int i = 1; i < buffer[0] ; i++) {
+                                fprintf( sOutput, "0x%02x, ", 
+                                    buffer[i] );
+                                newLineIfRequired();
+                            }
+                        }
+                    } else {
+                        count++;
+                        if (count == 127) {
+                            fprintf (sOutput, "127, ");
+                            newLineIfRequired();
+                            fprintf (sOutput, "0x%02x, ", currentValue);
+                            newLineIfRequired();
+                            count = 0;
+                        }
                     }
+                } else {
+                    if (bufferActive) {
+                        if (buffer[0] == 127) {
+                            // we don't have enough room, 
+                            // flush the buffer
+                            fprintf (sOutput, "%d, ", 
+                                128 + buffer[0] - 1);
+                            newLineIfRequired();
+                            for (int i = 1; i < buffer[0] ; i++) {
+                                fprintf( sOutput, "0x%02x, ", 
+                                    buffer[i] );
+                                newLineIfRequired();
+                            }
+                            buffer[0] = 0;
+                        }
+                        buffer[0]++;
+                        buffer[ buffer[0] ] = row[x];
+                    } else if (count > 0) {
+                        buffer[0] = 1;
+                        buffer[1] = row[x];
+                        bufferActive = true;
+                        if (count > 1) {
+                            fprintf (sOutput, "%d, ", count);
+                            newLineIfRequired();
+                            fprintf (sOutput, "0x%02x, ", 
+                                currentValue);
+                            newLineIfRequired();
+                        }
+                    }
+                    currentValue = row[x];
                 }
-                lastColor = row[x];
-                counter = 1;
             }
-
-            if (x == width * 3 - 1 && y == height - 1) {
-                // we have reach the end
-                fprintf(sOutput, "{%d, 0x%02x}\n};\n\n", counter, row[x]);
-                offset++;
-                break;
+        }
+        if (bufferActive) {
+            // I could have written 127 + buffer[0], but I think this is more readable...
+            fprintf (sOutput, "%d, ", 128 + buffer[0] - 1);
+            newLineIfRequired();
+            for (int i = 1; i < buffer[0] ; i++) {
+                fprintf( sOutput, "0x%02x, ", buffer[i] );
+                newLineIfRequired();
             }
+        } else {
+            fprintf(sOutput, "%d, 0x%02x, ", count, currentValue);
+            newLineIfRequired();
+        }       
+        // we put a ending zero, just to indicate end of channel
+        fprintf(sOutput, "0");
+        if (c != 2) {
+            fprintf(sOutput, ",");
         }
+        fprintf(sOutput, "\n\t");
     }
-    fprintf(sOutput, "static const uint32 %sSize = %d;\n", baseName, offset);
+    fprintf(sOutput, "};\n");
     fprintf(sOutput, "#endif\n\n");
 }
 
@@ -232 +310 @@
     fprintf(sOutput, "static const int32 kSplashIconsPlacementY = %d;\n\n",
         iconPlacementY);
 
-    fprintf(sOutput, "struct RLE_element \n{\n\tuint16 count; \n\tuint8 "
-        "colorComponent;\n};\n\n");
-
     parseImage(argv[1], "kSplashLogo");
     parseImage(argv[4], "kSplashIcons");
 

src/system/boot/platform/bios_ia32/video.cpp

@@ -796 +796 @@
 
 
 static void
-uncompress_RLE(const RLE_element *compressed, uint8 *uncompressed, uint32 size)
+uncompress_RLE(const uint8 compressed[], uint8 *uncompressed)
 {
-    uint32 cursor = 0;
-    for (uint32 i = 0; i < size; i++) {
-        memset(uncompressed + cursor, compressed[i].colorComponent,
-            compressed[i].count);
-        cursor += compressed[i].count;
-    } 
+    uint32 cursorUncompressed = 0;
+    uint32 cursorCompressed = 0;
+    uint8 count = 0;
+    uint8 item = 0;
+    int i = 0;
+    for (uint8 c = 0; c < 3; c++) {
+        // for Red channel, then Green, then finally Blue...
+        cursorUncompressed = c;
+        while (compressed[ cursorCompressed ]) {
+            // at the end of the channel there is a stopper 0, so the loop will end... 
+            // (ref: generate_boot_screen.cpp)
+            count = compressed[ cursorCompressed++ ];
+            if (count < 128) {
+                // regular run, repeat "item" "count" times...
+                item = compressed[ cursorCompressed++ ];
+                for (i = count - 1; i >= 0; --i) {
+                    uncompressed[ cursorUncompressed ] = item;
+                    cursorUncompressed += 3;
+                }
+            } else {
+                // enumeration, just write the next "count" items as is...
+                count = count - 128;
+                for (i = count - 1; i >= 0; --i) {
+                    uncompressed[ cursorUncompressed ] = compressed[ cursorCompressed++ ];
+                    cursorUncompressed += 3;
+                }
+            }
+        }
+        // the current position of compressed[cursor] is the end of channel, we skip it...
+        cursorCompressed++;
+    }
 }
 
 //  #pragma mark -
@@ -884 +909 @@
         * kSplashLogoHeight * 3);
     if (uncompressedLogo == NULL)
         return;
-    uncompress_RLE(kSplashLogoCompressedImage, uncompressedLogo,
-        kSplashLogoSize);
+    uncompress_RLE(kSplashLogoCompressedImage, uncompressedLogo);
 
     // TODO: support indexed versions of the images!
 
@@ -911 +935 @@
         * kSplashIconsHeight * 3);
     if (gKernelArgs.boot_splash == NULL)
         return;
-    uncompress_RLE(kSplashIconsCompressedImage, gKernelArgs.boot_splash,
-        kSplashIconsSize);
+    uncompress_RLE(kSplashIconsCompressedImage, gKernelArgs.boot_splash );
 
     // render initial (grayed out) icons
     // the grayed out version is the lower half of the icons image