added updated 16bpp patch that handles 555 BRG and does bit of inlining

git-svn-id: https://svn.o-hand.com/repos/poky/trunk@1595 311d38ba-8fff-0310-9ca6-ca027cbcb966

1 files changed, 258 insertions, 0 deletions

diff --git a/meta/packages/libmatchbox/files/16bppfixes-2.patch b/meta/packages/libmatchbox/files/16bppfixes-2.patch
new file mode 100644
index 0000000000..ab9cdc74a5
--- /dev/null
+++ b/meta/packages/libmatchbox/files/16bppfixes-2.patch
@@ -0,0 +1,258 @@
+--- libmatchbox/libmb/mbpixbuf.c.orig   2007-05-04 14:41:55.000000000 +0100
++++ libmatchbox/libmb/mbpixbuf.c        2007-05-04 14:41:55.000000000 +0100
+@@ -710,46 +710,19 @@
+   return colnum;
+ }
+ 
+-
+-static unsigned long
+-mb_pixbuf_get_pixel(MBPixbuf *pb, int r, int g, int b, int a)
++/*
++ * Split the mb_pixbuf_get_pixel() function into several specialized
++ * functions which we will inline; this allows us to optimize
++ * mb_pixbuf_img_render_to_drawable_with_gc () by taking some of the
++ * decision taking outside of the double loop
++ */
++
++/*
++ * Get pixel value for rgb values and pixel depth <= 8
++ */
++static inline unsigned long
++mb_pixbuf_get_pixel_le8_rgb (MBPixbuf *pb, int r, int g, int b)
+ {
+-  if (pb->depth > 8)
+-    {
+-      switch (pb->depth)
+-       {
+-       case 15:
+-         return ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
+-       case 16:
+-         return ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
+-       case 24:
+-       case 32:
+-         switch (pb->byte_order)
+-           {
+-           case BYTE_ORD_24_RGB:
+-             return ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
+-           case BYTE_ORD_24_RBG:
+-             return ((r & 0xff) << 16) | ((b & 0xff) << 8) | (g & 0xff);
+-           case BYTE_ORD_24_BRG:
+-             return ((b & 0xff) << 16) | ((r & 0xff) << 8) | (g & 0xff);
+-           case BYTE_ORD_24_BGR:
+-             return ((b & 0xff) << 16) | ((g & 0xff) << 8) | (r & 0xff);
+-           case BYTE_ORD_24_GRB:
+-             return ((g & 0xff) << 16) | ((r & 0xff) << 8) | (b & 0xff);
+-           case BYTE_ORD_24_GBR:
+-             return ((g & 0xff) << 16) | ((b & 0xff) << 8) | (r & 0xff);
+-           case BYTE_ORD_32_ARGB:
+-             return  (a << 24) | (r << 16) | (g << 8) | b;
+-           default:
+-             return 0;
+-           }
+-       default:
+-         return 0;
+-       }
+-      return 0;
+-    }
+-
+-  /* pb->depth <= 8 */
+   switch(pb->vis->class)
+     {
+     case PseudoColor:
+@@ -794,6 +767,111 @@
+   return 0;
+ }
+ 
++/*
++ * Get pixel value from a pointer to 16bbp value for pixel depth <= 8
++ * and advance the pointer
++ */
++static inline unsigned long
++mb_pixbuf_get_pixel_le8_16bpp_advance (MBPixbuf *pb, unsigned char ** p)
++{
++  unsigned short s = SHORT_FROM_2BYTES(*p);
++  int r, b, g;
++
++  r = (s & 0xf800) >> 8;
++  g = (s & 0x07e0) >> 3;
++  b = (s & 0x001f) << 3;
++
++  *p += 2;
++  
++  return mb_pixbuf_get_pixel_le8_rgb (pb, r, g, b);
++}
++
++/*
++ * Get pixel value for rgba values and pixel depth > 8
++ *
++ */
++static inline unsigned long
++mb_pixbuf_get_pixel_gt8_rgba (MBPixbuf *pb, int r, int g, int b, int a)
++{
++  switch (pb->depth)
++    {
++    case 15:
++      switch (pb->byte_order)
++       {
++       case BYTE_ORD_24_RGB:
++         return ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
++       case BYTE_ORD_24_BGR:
++         return ((b & 0xf8) << 7) | ((g & 0xf8) << 2) | ((r & 0xf8) >> 3);
++       }
++    case 16:
++      switch (pb->byte_order)
++       {
++       case BYTE_ORD_24_RGB:
++         return ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
++       case BYTE_ORD_24_BGR:
++         return ((b & 0xf8) << 8) | ((g & 0xfc) << 3) | ((r & 0xf8) >> 3);
++       }
++    case 24:
++    case 32:
++      switch (pb->byte_order)
++       {
++       case BYTE_ORD_24_RGB:
++         return ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
++       case BYTE_ORD_24_RBG:
++         return ((r & 0xff) << 16) | ((b & 0xff) << 8) | (g & 0xff);
++       case BYTE_ORD_24_BRG:
++         return ((b & 0xff) << 16) | ((r & 0xff) << 8) | (g & 0xff);
++       case BYTE_ORD_24_BGR:
++         return ((b & 0xff) << 16) | ((g & 0xff) << 8) | (r & 0xff);
++       case BYTE_ORD_24_GRB:
++         return ((g & 0xff) << 16) | ((r & 0xff) << 8) | (b & 0xff);
++       case BYTE_ORD_24_GBR:
++         return ((g & 0xff) << 16) | ((b & 0xff) << 8) | (r & 0xff);
++       case BYTE_ORD_32_ARGB:
++         return  (a << 24) | (r << 16) | (g << 8) | b;
++       default:
++         return 0;
++       }
++    default:
++      return 0;
++    }
++}
++
++/*
++ * Get pixel value from pointer to 16bpp data for pixel depth > 8
++ * and advance the pointer
++ *
++ * TODO ? We could take the 32bit case out of here, which would allow
++ * to ignore the alpha value for <15, 24>, but we might not gain that
++ * much by this on arm due to the conditional execution.
++ */
++static inline unsigned long
++mb_pixbuf_get_pixel_gt8_16bpp_advance (MBPixbuf *pb, unsigned char ** p,
++                                      int has_alpha)
++{
++  unsigned short s = SHORT_FROM_2BYTES(*p);
++  int r, b, g, a;
++
++  r = (s & 0xf800) >> 8;
++  g = (s & 0x07e0) >> 3;
++  b = (s & 0x001f) << 3;
++
++  *p += 2;
++  
++  a = has_alpha ?  *(*p)++ : 0xff;
++
++  return mb_pixbuf_get_pixel_gt8_rgba (pb, r, g, b, a);
++}
++
++static inline unsigned long
++mb_pixbuf_get_pixel(MBPixbuf *pb, int r, int g, int b, int a)
++{
++  if (pb->depth > 8)
++    return mb_pixbuf_get_pixel_gt8_rgba (pb, r, g, b, a);
++
++  return mb_pixbuf_get_pixel_le8_rgb (pb, r, g, b);
++}
++
+ unsigned long
+ mb_pixbuf_lookup_x_pixel(MBPixbuf *pb, int r, int g, int b, int a)
+ {
+@@ -1825,7 +1903,6 @@
+   mb_pixbuf_img_render_to_drawable_with_gc(pb, img, drw, drw_x, drw_y, pb->gc);
+ }
+ 
+-
+ void
+ mb_pixbuf_img_render_to_drawable_with_gc(MBPixbuf    *pb,
+                                         MBPixbufImage *img,
+@@ -1883,31 +1960,57 @@
+ 
+       if (pb->internal_bytespp == 2)
+        {
+-         for(y=0; y<img->height; y++)
+-           for(x=0; x<img->width; x++)
+-             {
+-               /* Below is potentially dangerous.  
+-                */
+-               pixel =  ( *p | (*(p+1) << 8)); 
+-
+-               p +=  ((img->has_alpha) ?  3 : 2);
+-               
+-               XPutPixel(img->ximg, x, y, pixel);
+-             }
++         if (pb->depth > 8)
++           {
++             for(y=0; y<img->height; y++)
++               for(x=0; x<img->width; x++)
++                 {
++                   pixel = mb_pixbuf_get_pixel_gt8_16bpp_advance(pb, &p,
++                                                                 img->has_alpha);
++                   XPutPixel(img->ximg, x, y, pixel);
++                 }
++           }
++         else
++           {
++             for(y=0; y<img->height; y++)
++               for(x=0; x<img->width; x++)
++                 {
++                   pixel = mb_pixbuf_get_pixel_le8_16bpp_advance(pb, &p);
++                   XPutPixel(img->ximg, x, y, pixel);
++                 }
++           }
+        }
+       else
+        {
+-         for(y=0; y<img->height; y++)
++         if (pb->depth > 8)
+            {
+-             for(x=0; x<img->width; x++)
++             for(y=0; y<img->height; y++)
+                {
+-                 r = ( *p++ );
+-                 g = ( *p++ );
+-                 b = ( *p++ );
+-                 a = ((img->has_alpha) ?  *p++ : 0xff);
++                 for(x=0; x<img->width; x++)
++                   {
++                     r = ( *p++ );
++                     g = ( *p++ );
++                     b = ( *p++ );
++                     a = ((img->has_alpha) ?  *p++ : 0xff);
+                  
+-                 pixel = mb_pixbuf_get_pixel(pb, r, g, b, a);
+-                 XPutPixel(img->ximg, x, y, pixel);
++                     pixel = mb_pixbuf_get_pixel_gt8_rgba(pb, r, g, b, a);
++                     XPutPixel(img->ximg, x, y, pixel);
++                   }
++               }
++           }
++         else
++           {
++             for(y=0; y<img->height; y++)
++               {
++                 for(x=0; x<img->width; x++)
++                   {
++                     r = ( *p++ );
++                     g = ( *p++ );
++                     b = ( *p++ );
++                 
++                     pixel = mb_pixbuf_get_pixel_le8_rgb(pb, r, g, b);
++                     XPutPixel(img->ximg, x, y, pixel);
++                   }
+                }
+            }
+        }