Support ply-image splash screen display for ST1q

src/third_party/ply-image/src/ply-frame-buffer.c

 /* ply-frame-buffer.c - framebuffer abstraction
  *
  * Copyright (C) 2006, 2007, 2008 Red Hat, Inc.
  *               2008 Charlie Brej <cbrej@cs.man.ac.uk>
  *
  * 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, or (at your option)
  * any later version.
  *
@@ skipping 516 matching lines @@
 
 bool 
 ply_frame_buffer_fill (ply_frame_buffer_t      *buffer,
                        ply_frame_buffer_area_t *area,
                        unsigned long            x,
                        unsigned long            y,
                        uint32_t                *data)
 {
   char *dst, *src;
   int hdiff, vdiff;
+  int lines, width;
 
   assert (buffer != NULL);
   assert (ply_frame_buffer_device_is_open (buffer));
   assert (area != NULL);
 
   hdiff = area->width - buffer->area.width;
   vdiff = area->height - buffer->area.height;
 
+  lines = vdiff > 0 ? buffer->area.height : area->height;
+  width = hdiff > 0 ? buffer->area.width : area->width;
+
   if (hdiff >= 0)
     {
       /* image is wider than buffer */
       dst = &buffer->map_address[0];
       src = (char *) (data + hdiff / 2);
     } else {
-      dst = &buffer->map_address[(-hdiff / 2) * sizeof(*data)];
+      dst = &buffer->map_address[(-hdiff / 2) * buffer->bytes_per_pixel];
       src = (char *) data;
     }
 
   if (vdiff >= 0)
     {
       /* image is taller than buffer */
       src += (vdiff / 2) * area->width * sizeof(*data);
     }
   else
     {
-      dst += (-vdiff / 2) * buffer->row_stride * sizeof(*data);
+      dst += (-vdiff / 2) * buffer->row_stride * buffer->bytes_per_pixel;
     }
 
-  if (area->width == buffer->row_stride)
+  if (buffer->bytes_per_pixel != sizeof(*data))
+    {
+      uint16_t *src_16 = 0, *src_16_end;
+      int line;
+
+      /* Handle the 16 bpp case (specifically RGB 565 case) */
+      if (buffer->bytes_per_pixel != 2)
+        return 0;
+
+      /* Allocate temporary row pixel data storage for 16 bpp displays */
+      src_16 = (uint16_t *) malloc (width * sizeof(*src_16));
+
+      if (!src_16)
+        return 0;
+
+      src_16_end = src_16 + width;
+
+      for (line = 0; line < lines; line++) {
+        uint32_t *src_32_temp;
+        uint16_t *src_16_temp;
+
+        for (src_32_temp = (uint32_t *)src, src_16_temp = src_16;
+          src_16_temp != src_16_end;
+          src_16_temp++)
+        {
+            uint32_t src_32_value = *src_32_temp++;
+            *src_16_temp = (uint16_t)(
+              ((src_32_value & 0x00F80000) >> 8) | \
+              ((src_32_value & 0x0000FC00) >> 5) | \
+              ((src_32_value & 0x000000F8) >> 3)
+            );
+        }
+        memcpy (dst, src_16, width * buffer->bytes_per_pixel);
+
+        dst += buffer->row_stride * buffer->bytes_per_pixel;
+        src += area->width * sizeof(*data);
+      }
+
+      free (src_16);
+    }
+  else if (area->width == buffer->row_stride)
     {
       memcpy (dst, src, area->width * area->height * sizeof(*data));
     }
   else
     {
       int line;
-      int lines = vdiff > 0 ? buffer->area.height : area->height;
-      int width = hdiff > 0 ? buffer->area.width : area->width;
-    
+
       for (line = 0; line < lines; line++) {
         memcpy (dst, src, width * sizeof(*data));
         dst += buffer->row_stride * sizeof(*data);
         src += area->width * sizeof(*data);
       }
     }
 
   return 1;
 }
 
 
 const char *
 ply_frame_buffer_get_bytes (ply_frame_buffer_t *buffer)
 {
   return (char *) buffer->shadow_buffer;
 }