assemble a splash preview if none was found (#277)

source/conversion.c

@@ -0,0 +1,129 @@
+#include "conversion.h"
+#include "draw.h"
+
+#include <png.h>
+
+static void rotate_agbr_counterclockwise(char ** bufp, size_t size, size_t width)
+{
+    uint32_t * buf = (uint32_t*)*bufp;
+    uint32_t * out = malloc(size);
+
+    size_t pixel_count = (size/4);
+    size_t height = pixel_count/width;
+
+    for (uint32_t h = 0; h < height; ++h)
+    {
+        for (uint32_t w = 0; w < width; ++w)
+        {
+            size_t buf_index = (w + (h * width));
+            size_t out_index = (height * (width-1)) - (height * w) + h;
+
+            out[out_index] = buf[buf_index];
+        }
+    }
+
+    free(*bufp);
+    *bufp = (char*)out;
+}
+
+size_t bin_to_abgr(char ** bufp, size_t size)
+{
+    size_t out_size = (size / 3) * 4;
+    char* buf = malloc(out_size);
+
+    for (size_t i = 0, j = 0; i < size; i+=3, j+=4)
+    {
+        (buf+j)[0] = 0xFF;         // A
+        (buf+j)[1] = (*bufp+i)[0]; // B
+        (buf+j)[2] = (*bufp+i)[1]; // G
+        (buf+j)[3] = (*bufp+i)[2]; // R
+    }
+    free(*bufp);
+    *bufp = buf;
+
+    // splash screens contain the raw framebuffer to put on the screen
+    // because the screens are mounted at a 90 degree angle we also need to rotate
+    // the output
+    rotate_agbr_counterclockwise(bufp, out_size, 240);
+
+    return out_size;
+}
+
+size_t png_to_abgr(char ** bufp, size_t size)
+{
+    size_t out_size = 0;
+    if(size < 8 || png_sig_cmp((png_bytep)*bufp, 0, 8))
+    {
+        throw_error("Invalid preview.png", ERROR_LEVEL_WARNING);
+        return out_size;
+    }
+
+    uint32_t * buf = (uint32_t*)*bufp;
+
+    FILE * fp = fmemopen(buf, size, "rb");;
+    png_bytep * row_pointers = NULL;
+
+    png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    png_infop info = png_create_info_struct(png);
+
+    png_init_io(png, fp);
+    png_read_info(png, info);
+
+    u32 width = png_get_image_width(png, info);
+    u32 height = png_get_image_height(png, info);
+
+    png_byte color_type = png_get_color_type(png, info);
+    png_byte bit_depth  = png_get_bit_depth(png, info);
+
+    // Read any color_type into 8bit depth, ABGR format.
+    // See http://www.libpng.org/pub/png/libpng-manual.txt
+
+    if(bit_depth == 16)
+        png_set_strip_16(png);
+
+    if(color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_palette_to_rgb(png);
+
+    // PNG_COLOR_TYPE_GRAY_ALPHA is always 8 or 16bit depth.
+    if(color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
+        png_set_expand_gray_1_2_4_to_8(png);
+
+    if(png_get_valid(png, info, PNG_INFO_tRNS))
+        png_set_tRNS_to_alpha(png);
+
+    // These color_type don't have an alpha channel then fill it with 0xff.
+    if(color_type == PNG_COLOR_TYPE_RGB ||
+       color_type == PNG_COLOR_TYPE_GRAY ||
+       color_type == PNG_COLOR_TYPE_PALETTE)
+        png_set_add_alpha(png, 0xFF, PNG_FILLER_BEFORE);
+
+    if(color_type == PNG_COLOR_TYPE_GRAY ||
+       color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
+        png_set_gray_to_rgb(png);
+
+    //output ABGR
+    png_set_bgr(png);
+    png_set_swap_alpha(png);
+
+    png_read_update_info(png, info);
+
+    row_pointers = malloc(sizeof(png_bytep) * height);
+    out_size = sizeof(u32) * (width * height);
+    u32 * out = malloc(out_size);
+    for(u32 y = 0; y < height; y++)
+    {
+        row_pointers[y] = (png_bytep)(out + (width * y));
+    }
+
+    png_read_image(png, row_pointers);
+
+    png_destroy_read_struct(&png, &info, NULL);
+
+    if (fp) fclose(fp);
+    if (row_pointers) free(row_pointers);
+
+    free(*bufp);
+    *bufp = (char*)out;
+
+    return out_size;
+}