alignment and endianess fixes in x11drv/dib.c

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 





ChangeLog:

     Fixes for memory alignment and endianess issues x11drv DIB functions.

Description:

     Introduced byte-swapping and safe memory access in various places
     in x11drv DIB related functions.
     Added FIXME messages in not yet big-endian safe functions.

Warren Baird : Warren_Baird@cimmetry.com

diff -ur clean/wine/graphics/x11drv/dib.c  wine/graphics/x11drv/dib.c
--- clean/wine/graphics/x11drv/dib.c     Wed Jan 29 15:31:02 2003
+++ wine/graphics/x11drv/dib.c     Fri Jan 31 10:07:55 2003
@@ -400,6 +400,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -432,6 +436,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -464,6 +472,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -498,6 +510,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -525,6 +541,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -552,6 +572,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -578,6 +602,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -610,6 +638,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     /* Note, the source pixel value is shifted left by 16 bits so that
      * we know we will always have to shift right to extract the components.
      */
@@ -669,6 +701,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -701,6 +737,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -731,6 +771,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -763,6 +807,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -790,6 +838,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -817,6 +869,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -843,6 +899,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -873,6 +933,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -898,6 +962,10 @@
     int x,y;
     int oddwidth;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     oddwidth=width & 3;
     width=width/4;
     for (y=0; y<height; y++) {
@@ -949,6 +1017,10 @@
     int x,y;
     int oddwidth;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     oddwidth=width & 3;
     width=width/4;
     for (y=0; y<height; y++) {
@@ -1000,6 +1072,10 @@
     int x,y;
     int oddwidth;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     oddwidth=width & 3;
     width=width/4;
     for (y=0; y<height; y++) {
@@ -1051,6 +1127,10 @@
     int x,y;
     int oddwidth;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     oddwidth=width & 3;
     width=width/4;
     for (y=0; y<height; y++) {
@@ -1107,6 +1187,19 @@
         srcpixel=srcbits;
         dstpixel=dstbits;
         for (x=0; x<width; x++) {
+#ifdef WORDS_BIGENDIAN
+            /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
+            DWORD srcval1,srcval2;
+            srcval1=srcpixel[0];
+            dstpixel[0]=( srcval1 & 0xffffff00) ;         /* h1, g1, l1 */
+            srcval2=srcpixel[1];
+            dstpixel[1]=( srcval1 & 0xff) << 24 |         /* l2 */
+                        ( srcval2 & 0xffff0000) >> 8  ;   /* h2, g2 */
+            srcval1=srcpixel[2];
+            dstpixel[2]=( srcval2  & 0x0000ffff) << 16 |  /* g3, l3 */
+                        ( srcval1  & 0xff000000) >> 16;   /* h3 */
+            dstpixel[3]=( srcval1  & 0x00ffffff) << 8;    /* h4, g4, l4 */
+#else
             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
             DWORD srcval1,srcval2;
             srcval1=srcpixel[0];
@@ -1118,16 +1211,31 @@
             dstpixel[2]=( srcval2 >> 16) |              /* g3, l3 */
                         ((srcval1 << 16) & 0x00ff0000); /* h3 */
             dstpixel[3]=( srcval1 >>  8);               /* h4, g4, l4 */
+#endif
             srcpixel+=3;
             dstpixel+=4;
         }
         /* And now up to 3 odd pixels */
+    /* There are alignment problems here - be careful on systems that
+       need alignment */
+
+#ifdef ALLOW_UNALIGNED_ACCESS
         for (x=0; x<oddwidth; x++) {
             DWORD srcval;
             srcval=*srcpixel;
             srcpixel=(LPDWORD)(((char*)srcpixel)+3);
             *dstpixel++=( srcval         & 0x00ffffff); /* h, g, l */
         }
+#else
+    if (oddwidth > 0) {
+        for (x=0; x<oddwidth; x++) {
+         DWORD srcval;
+         memcpy(&srcval,srcpixel,4);
+         srcpixel=(LPDWORD)(((char*)srcpixel)+3);
+         *dstpixel++ = (srcval  & 0xffffff00) ;
+        }
+    }
+#endif
         srcbits = (char*)srcbits + srclinebytes;
         dstbits = (char*)dstbits + dstlinebytes;
     }
@@ -1150,7 +1258,17 @@
         for (x=0; x<width; x++) {
             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
             DWORD srcval1,srcval2;
-
+#ifdef WORDS_BIGENDIAN
+            srcval1=srcpixel[0];
+            dstpixel[0]=((srcval1 >>  8)  & 0xffffff) ; /* h1, g1, l1 */
+            srcval2=srcpixel[1];
+            dstpixel[1]=((srcval1 <<  16) & 0xff0000) | /* h2 */
+                        ((srcval2 >>  16) & 0x00ffff); /* g2,l2 */
+            srcval1=srcpixel[2];
+            dstpixel[2]=((srcval2 << 8)  & 0xffff00) | /* h3,g3 */
+                        ((srcval1 >> 24) & 0x0000ff);  /* h3 */
+            dstpixel[3]=( srcval1        & 0xffffff);  /* h4, g4, l4 */
+#else
             srcval1=srcpixel[0];
             dstpixel[0]=((srcval1 >> 16) & 0x0000ff) | /* h1 */
                         ( srcval1        & 0x00ff00) | /* g1 */
@@ -1166,10 +1284,12 @@
             dstpixel[3]=((srcval1 >> 24) & 0x0000ff) | /* h4 */
                         ((srcval1 >>  8) & 0x00ff00) | /* g4 */
                         ((srcval1 <<  8) & 0xff0000);  /* l4 */
+#endif
             srcpixel+=3;
             dstpixel+=4;
         }
         /* And now up to 3 odd pixels */
+#ifdef ALLOW_UNALIGNED_ACCESS
         for (x=0; x<oddwidth; x++) {
             DWORD srcval;
             srcval=*srcpixel;
@@ -1178,6 +1298,17 @@
                         ( srcval         & 0x00ff00) | /* g */
                         ((srcval  << 16) & 0xff0000);  /* l */
         }
+#else
+    if (oddwidth > 0) {
+        for (x=0; x<oddwidth; x++) {
+         DWORD srcval;
+         memcpy(&srcval,srcpixel,sizeof(DWORD));
+         srcpixel=(LPDWORD)(((char*)srcpixel)+3);
+         *dstpixel++ = ((srcval >>  8)  & 0xffffff) ;
+
+        }
+    }
+#endif
         srcbits = (char*)srcbits + srclinebytes;
         dstbits = (char*)dstbits + dstlinebytes;
     }
@@ -1193,6 +1324,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
@@ -1220,6 +1355,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
@@ -1249,6 +1388,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -1276,6 +1419,10 @@
     DWORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
@@ -1305,6 +1452,10 @@
     WORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -1328,6 +1479,10 @@
     WORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -1351,6 +1506,10 @@
     WORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -1374,6 +1533,10 @@
     WORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     for (y=0; y<height; y++) {
         srcpixel=srcbits;
         dstpixel=dstbits;
@@ -1401,6 +1564,10 @@
     WORD* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     /* Here is how we proceed. Assume we have rsrc=0x0000ff00 and our pixel
      * contains 0x11223344.
      * - first we shift 0x11223344 right by rRightShift to bring the most
@@ -1448,6 +1615,9 @@
     BYTE* dstbyte;
     int x,y;
     int oddwidth;
+#ifndef ALLOW_UNALIGNED_ACCESS
+    BYTE oddbytes[9]; /* space for bytes at end of row */
+#endif

     oddwidth=width & 3;
     width=width/4;
@@ -1455,6 +1625,18 @@
         srcpixel=srcbits;
         dstpixel=dstbits;
         for (x=0; x<width; x++) {
+#ifdef WORDS_BIGENDIAN
+            /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
+            DWORD srcval;
+              DWORD tmppixel;
+
+            srcval=((*srcpixel++)       & 0xffffff00);  /* h1, g1, l1*/
+            *dstpixel++=srcval | (*srcpixel & 0xff000000) >> 24; /* h2 */
+            srcval=(*srcpixel++ & 0x00ffff00) << 8;  /* g2, l2 */
+            *dstpixel++=srcval | ((*srcpixel & 0xffff0000) >> 16); /* h3, g3 */
+            srcval=(*srcpixel++ & 0x0000ff00) << 16;  /* l3 */
+            *dstpixel++=srcval | ((*srcpixel++ & 0xffffff00) >> 8);  /* h4, g4,
l4 */
+#else
             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
             DWORD srcval;
             srcval=((*srcpixel++)       & 0x00ffffff);  /* h1, g1, l1*/
@@ -1463,8 +1645,14 @@
             *dstpixel++=srcval | ((*srcpixel)   << 16); /* h3, g3 */
             srcval=((*srcpixel++ >> 16) & 0x000000ff);  /* l3 */
             *dstpixel++=srcval | ((*srcpixel++) << 8);  /* h4, g4, l4 */
+#endif
         }
         /* And now up to 3 odd pixels */
+
+    /* There are alignment problems here - be careful on systems that
+       need alignment */
+
+#ifdef ALLOW_UNALIGNED_ACCESS
         dstbyte=(BYTE*)dstpixel;
         for (x=0; x<oddwidth; x++) {
             DWORD srcval;
@@ -1472,6 +1660,23 @@
             *((WORD*)dstbyte)++=srcval;                 /* h, g */
             *dstbyte++=srcval >> 16;                    /* l */
         }
+#else
+
+
+    /* fill in a temporary buffer with the pixels, and memcpy
+       it into the place we need it */
+
+        for (x=0; x<oddwidth; x++) {
+              srcpixel++;
+
+              oddbytes[x*3  ] = (*srcpixel & 0xff000000) >> 24;
+              oddbytes[x*3+1] = (*srcpixel & 0x00ff0000) >> 16;
+              oddbytes[x*3+2] = (*srcpixel & 0x0000ff00) >> 8;
+        }
+
+         memcpy((BYTE*)dstpixel,oddbytes,oddwidth*3);
+
+#endif
         srcbits = (char*)srcbits + srclinebytes;
         dstbits = (char*)dstbits + dstlinebytes;
     }
@@ -1486,6 +1691,9 @@
     BYTE* dstbyte;
     int x,y;
     int oddwidth;
+#ifndef ALLOW_UNALIGNED_ACCESS
+    BYTE oddbytes[9]; /* space for bytes at end of row */
+#endif

     oddwidth=width & 3;
     width=width/4;
@@ -1494,6 +1702,19 @@
         dstpixel=dstbits;
         for (x=0; x<width; x++) {
             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
+#ifdef WORDS_BIGENDIAN
+            DWORD srcval;
+            srcval= (*srcpixel++ & 0xffffff) << 8;       /* h1, g1, l1 */
+            *dstpixel++=srcval |
+                        ((*srcpixel & 0xff0000) >> 16);  /* h2 */
+            srcval = (*srcpixel++ & 0x00ffff) << 16;     /* g2, l2 */
+            *dstpixel++=srcval |
+                        ((*srcpixel & 0x00ffff00) >> 8); /* h3, g3 */
+
+            srcval=    ((*srcpixel++ & 0x000000ff) << 24); /* l3 */
+            *dstpixel++=srcval |
+                        (*srcpixel++ & 0xffffff);        /* h4, g4, l4 */
+#else
             DWORD srcval1,srcval2;
             srcval1=*srcpixel++;
             srcval2=    ((srcval1 >> 16) & 0x000000ff) | /* h1 */
@@ -1514,8 +1735,13 @@
                         ((srcval1 >>  8) & 0x0000ff00) | /* h4 */
                         ((srcval1 <<  8) & 0x00ff0000) | /* g4 */
                         ( srcval1 << 24);                /* l4 */
+#endif
         }
         /* And now up to 3 odd pixels */
+    /* There are alignment problems here - be careful on systems that
+       need alignment */
+
+#ifdef ALLOW_UNALIGNED_ACCESS
         dstbyte=(BYTE*)dstpixel;
         for (x=0; x<oddwidth; x++) {
             DWORD srcval;
@@ -1524,6 +1750,22 @@
                                 (srcval         & 0xff00);  /* g */
             *dstbyte++=srcval;                              /* l */
         }
+#else
+    /* fill in a temporary buffer with the pixels, and memcpy
+       it into the place we need it */
+
+        for (x=0; x<oddwidth; x++) {
+            DWORD srcval;
+            srcval=*srcpixel++;
+
+        oddbytes[x*3  ] = (srcval & 0xff0000) >> 16; /* h */
+        oddbytes[x*3+1] = (srcval & 0x00ff00) >> 8;  /* g */
+        oddbytes[x*3+2] = (srcval & 0x0000ff);     /* l */
+        }
+
+    memcpy((BYTE*)dstpixel,oddbytes,oddwidth*3);
+
+#endif
         srcbits = (char*)srcbits + srclinebytes;
         dstbits = (char*)dstbits + dstlinebytes;
     }
@@ -1539,6 +1781,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
@@ -1568,6 +1814,10 @@
     BYTE* dstpixel;
     int x,y;

+#ifdef WORDS_BIGENDIAN
+    FIXME("This code is not yet big-endian safe - expect corrupt images\n");
+#endif
+
     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
@@ -2812,9 +3062,15 @@
                     for (x=0; x<dstwidth; x++) {
                         *dstbyte++=X11DRV_DIB_GetNearestIndex
                             (colors, 256,
+#ifdef WORDS_BIGENDIAN
+                             srcbyte[3],
+                             srcbyte[2],
+                             srcbyte[1]);
+#else
                              srcbyte[0],
                              srcbyte[1],
                              srcbyte[2]);
+#endif
                         srcbyte+=bytes_per_pixel;
                     }
                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;




[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux