git.oblomov.eu Git - wine/blob - dlls/winex11.drv/dib_src_swap.c

   1 /*
   2  * DIB conversion routines for cases where the source
   3  * has non-native byte order.
   4  *
   5  * Copyright (C) 2003 Huw Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdlib.h>
  25
  26 #include "windef.h"
  27 #include "x11drv.h"
  28
  29
  30 #define FLIP_WORD(x) \
  31  ( *(x)  = ( (*(x) & 0xff) << 8) | \
  32    ( (*(x) & 0xff00) >> 8) )
  33
  34 #define FLIP_TWO_WORDS(x) \
  35  ( *(x)  = ( (*(x) & 0x00ff00ff) << 8) | \
  36    ( (*(x) & 0xff00ff00) >> 8) )
  37
  38 #define FLIP_DWORD(x) \
  39  ( *(x)  = ( (*(x) & 0xff) << 24) | \
  40    ( (*(x) & 0xff00) << 8) | \
  41    ( (*(x) & 0xff0000) >> 8) | \
  42    ( (*(x) & 0xff000000) >> 24) )
  43
  44
  45
  46 /*
  47  * 15 bit conversions
  48  */
  49
  50 static void convert_5x5_asis_src_byteswap(int width, int height,
  51                                           const void* srcbits, int srclinebytes,
  52                                           void* dstbits, int dstlinebytes)
  53 {
  54     int x, y;
  55     const DWORD *srcpixel;
  56     DWORD *dstpixel;
  57
  58     for (y=0; y<height; y++) {
  59         srcpixel=srcbits;
  60         dstpixel=dstbits;
  61         for(x = 0; x < width/2; x++) {
  62             /* Do 2 pixels at a time */
  63             DWORD srcval = *srcpixel++;
  64             *dstpixel++=((srcval << 8) & 0xff00ff00) |
  65                         ((srcval >> 8) & 0x00ff00ff);
  66         }
  67         if(width&1) {
  68             /* And the odd pixel */
  69             WORD srcval = *(const WORD*)srcpixel;
  70             *(WORD*)dstpixel = ((srcval << 8) & 0xff00) |
  71                                ((srcval >> 8) & 0x00ff);
  72         }
  73         srcbits = (const char*)srcbits + srclinebytes;
  74         dstbits = (char*)dstbits + dstlinebytes;
  75     }
  76 }
  77
  78 static void convert_555_reverse_src_byteswap(int width, int height,
  79                                              const void* srcbits, int srclinebytes,
  80                                              void* dstbits, int dstlinebytes)
  81 {
  82     const DWORD* srcpixel;
  83     DWORD* dstpixel;
  84     int x,y;
  85
  86     for (y=0; y<height; y++) {
  87         srcpixel=srcbits;
  88         dstpixel=dstbits;
  89         for (x=0; x<width/2; x++) {
  90             /* Do 2 pixels at a time */
  91             DWORD srcval;
  92             srcval=*srcpixel++;
  93             *dstpixel++=((srcval >>  2) & 0x001f001f) | /* h */
  94                         ((srcval <<  8) & 0x03000300) | /* g - 2 bits */
  95                         ((srcval >>  8) & 0x00e000e0) | /* g - 3 bits */
  96                         ((srcval <<  2) & 0x7c007c00);  /* l */
  97         }
  98         if (width&1) {
  99             /* And then the odd pixel */
 100             WORD srcval;
 101             srcval=*((const WORD*)srcpixel);
 102             *((WORD*)dstpixel)=((srcval >>  2) & 0x001f) | /* h */
 103                                ((srcval <<  8) & 0x0300) | /* g - 2 bits */
 104                                ((srcval >>  8) & 0x00e0) | /* g - 3 bits */
 105                                ((srcval <<  2) & 0x7c00);  /* l */
 106         }
 107         srcbits = (const char*)srcbits + srclinebytes;
 108         dstbits = (char*)dstbits + dstlinebytes;
 109     }
 110 }
 111
 112 static void convert_555_to_565_asis_src_byteswap(int width, int height,
 113                                                  const void* srcbits, int srclinebytes,
 114                                                  void* dstbits, int dstlinebytes)
 115 {
 116     const DWORD* srcpixel;
 117     DWORD* dstpixel;
 118     int x,y;
 119
 120     for (y=0; y<height; y++) {
 121         srcpixel=srcbits;
 122         dstpixel=dstbits;
 123         for (x=0; x<width/2; x++) {
 124             /* Do 2 pixels at a time */
 125             DWORD srcval;
 126             srcval=*srcpixel++;
 127             *dstpixel++=((srcval << 9) & 0xfe00fe00) | /* h, g - 2 bits*/
 128                         ((srcval >> 7) & 0x01c001c0) | /* g - 3 bits */
 129                         ((srcval << 4) & 0x00200020) | /* g - 1 bit */
 130                         ((srcval >> 8) & 0x001f001f);  /* l */
 131         }
 132         if (width&1) {
 133             /* And then the odd pixel */
 134             WORD srcval;
 135             srcval=*((const WORD*)srcpixel);
 136             *((WORD*)dstpixel)=((srcval << 9) & 0xfe00) | /* h, g - 2bits*/
 137                                ((srcval >> 7) & 0x01c0) | /* g - 3 bits */
 138                                ((srcval << 4) & 0x0020) | /* g - 1 bit */
 139                                ((srcval >> 8) & 0x001f);  /* l */
 140         }
 141         srcbits = (const char*)srcbits + srclinebytes;
 142         dstbits = (char*)dstbits + dstlinebytes;
 143     }
 144 }
 145
 146 static void convert_555_to_565_reverse_src_byteswap(int width, int height,
 147                                                     const void* srcbits, int srclinebytes,
 148                                                     void* dstbits, int dstlinebytes)
 149 {
 150     const DWORD* srcpixel;
 151     DWORD* dstpixel;
 152     int x,y;
 153
 154     for (y=0; y<height; y++) {
 155         srcpixel=srcbits;
 156         dstpixel=dstbits;
 157         for (x=0; x<width/2; x++) {
 158             /* Do 2 pixels at a time */
 159             DWORD srcval;
 160             srcval=*srcpixel++;
 161              *dstpixel++=((srcval >>  2) & 0x001f001f) | /* h */
 162                          ((srcval <<  9) & 0x06000600) | /* g - 2 bits*/
 163                          ((srcval >>  7) & 0x01c001c0) | /* g - 3 bits */
 164                          ((srcval <<  4) & 0x00200020) | /* g - 1 bits */
 165                          ((srcval <<  3) & 0xf800f800);  /* l */
 166         }
 167         if (width&1) {
 168             /* And then the odd pixel */
 169             WORD srcval;
 170             srcval=*((const WORD*)srcpixel);
 171             *((WORD*)dstpixel)=((srcval >>  2) & 0x001f) | /* h */
 172                                ((srcval <<  9) & 0x0600) | /* g - 2 bits  */
 173                                ((srcval >>  7) & 0x01c0) | /* g - 3 bits */
 174                                ((srcval <<  4) & 0x0020) | /* g - 1 bit */
 175                                ((srcval <<  3) & 0xf800);  /* l */
 176         }
 177         srcbits = (const char*)srcbits + srclinebytes;
 178         dstbits = (char*)dstbits + dstlinebytes;
 179     }
 180 }
 181
 182 static void convert_555_to_888_asis_src_byteswap(int width, int height,
 183                                                  const void* srcbits, int srclinebytes,
 184                                                  void* dstbits, int dstlinebytes)
 185 {
 186     const WORD* srcpixel;
 187     BYTE* dstpixel;
 188     int x,y;
 189
 190     for (y=0; y<height; y++) {
 191         srcpixel=srcbits;
 192         dstpixel=dstbits;
 193         for (x=0; x<width; x++) {
 194             WORD srcval;
 195             srcval=*srcpixel++;
 196             dstpixel[0]=((srcval >>  5) & 0xf8) | /* l */
 197                         ((srcval >> 10) & 0x07);  /* l - 3 bits */
 198             dstpixel[1]=((srcval <<  6) & 0xc0) | /* g - 2 bits */
 199                         ((srcval >> 10) & 0x38) | /* g - 3 bits */
 200                         ((srcval <<  1) & 0x06) | /* g - 2 bits */
 201                         ((srcval >> 15) & 0x01);  /* g - 1 bit */
 202             dstpixel[2]=((srcval <<  1) & 0xf8) | /* h */
 203                         ((srcval >>  4) & 0x07);  /* h - 3 bits */
 204             dstpixel+=3;
 205         }
 206         srcbits = (const char*)srcbits + srclinebytes;
 207         dstbits = (char*)dstbits + dstlinebytes;
 208     }
 209 }
 210
 211 static void convert_555_to_888_reverse_src_byteswap(int width, int height,
 212                                                     const void* srcbits, int srclinebytes,
 213                                                     void* dstbits, int dstlinebytes)
 214 {
 215     const WORD* srcpixel;
 216     BYTE* dstpixel;
 217     int x,y;
 218
 219     for (y=0; y<height; y++) {
 220         srcpixel=srcbits;
 221         dstpixel=dstbits;
 222         for (x=0; x<width; x++) {
 223             WORD srcval;
 224             srcval=*srcpixel++;
 225             dstpixel[0]=((srcval <<  1) & 0xf8) | /* h */
 226                         ((srcval >>  4) & 0x07);  /* h - 3 bits */
 227             dstpixel[1]=((srcval <<  6) & 0xc0) | /* g - 2 bits */
 228                         ((srcval >> 10) & 0x38) | /* g - 3 bits */
 229                         ((srcval <<  1) & 0x06) | /* g - 2 bits */
 230                         ((srcval >> 15) & 0x01);  /* g - 1 bits */
 231             dstpixel[2]=((srcval >>  5) & 0xf8) | /* l */
 232                         ((srcval >> 10) & 0x07);  /* l - 3 bits */
 233             dstpixel+=3;
 234         }
 235         srcbits = (const char*)srcbits + srclinebytes;
 236         dstbits = (char*)dstbits + dstlinebytes;
 237     }
 238 }
 239
 240 static void convert_555_to_0888_asis_src_byteswap(int width, int height,
 241                                                   const void* srcbits, int srclinebytes,
 242                                                   void* dstbits, int dstlinebytes)
 243 {
 244     const WORD* srcpixel;
 245     DWORD* dstpixel;
 246     int x,y;
 247
 248     for (y=0; y<height; y++) {
 249         srcpixel=srcbits;
 250         dstpixel=dstbits;
 251         for (x=0; x<width; x++) {
 252             WORD srcval;
 253             srcval=*srcpixel++;
 254             *dstpixel++=((srcval << 17) & 0xf80000) | /* h */
 255                         ((srcval << 12) & 0x070000) | /* h - 3 bits */
 256                         ((srcval << 14) & 0x00c000) | /* g - 2 bits */
 257                         ((srcval >>  2) & 0x003800) | /* g - 3 bits */
 258                         ((srcval <<  9) & 0x000600) | /* g - 2 bits */
 259                         ((srcval >>  7) & 0x000100) | /* g - 1 bit */
 260                         ((srcval >>  5) & 0x0000f8) | /* l */
 261                         ((srcval >> 10) & 0x000007);  /* l - 3 bits */
 262         }
 263         srcbits = (const char*)srcbits + srclinebytes;
 264         dstbits = (char*)dstbits + dstlinebytes;
 265     }
 266 }
 267
 268 static void convert_555_to_0888_reverse_src_byteswap(int width, int height,
 269                                                      const void* srcbits, int srclinebytes,
 270                                                      void* dstbits, int dstlinebytes)
 271 {
 272     const WORD* srcpixel;
 273     DWORD* dstpixel;
 274     int x,y;
 275
 276     for (y=0; y<height; y++) {
 277         srcpixel=srcbits;
 278         dstpixel=dstbits;
 279         for (x=0; x<width; x++) {
 280             WORD srcval;
 281             srcval=*srcpixel++;
 282             *dstpixel++=((srcval <<  1) & 0x0000f8) | /* h */
 283                         ((srcval >>  4) & 0x000007) | /* h - 3 bits */
 284                         ((srcval << 14) & 0x00c000) | /* g - 2 bits */
 285                         ((srcval >>  2) & 0x003800) | /* g - 3 bits */
 286                         ((srcval <<  9) & 0x000600) | /* g - 2 bits */
 287                         ((srcval >>  7) & 0x000100) | /* g - 1 bit */
 288                         ((srcval << 11) & 0xf80000) | /* l */
 289                         ((srcval <<  6) & 0x070000);  /* l - 3 bits */
 290         }
 291         srcbits = (const char*)srcbits + srclinebytes;
 292         dstbits = (char*)dstbits + dstlinebytes;
 293     }
 294 }
 295
 296 static void convert_5x5_to_any0888_src_byteswap(int width, int height,
 297                                                 const void* srcbits, int srclinebytes,
 298                                                 WORD rsrc, WORD gsrc, WORD bsrc,
 299                                                 void* dstbits, int dstlinebytes,
 300                                                 DWORD rdst, DWORD gdst, DWORD bdst)
 301 {
 302     int rRightShift1,gRightShift1,bRightShift1;
 303     int rRightShift2,gRightShift2,bRightShift2;
 304     BYTE gMask1,gMask2;
 305     int rLeftShift,gLeftShift,bLeftShift;
 306     const WORD* srcpixel;
 307     DWORD* dstpixel;
 308     int x,y;
 309
 310     /* Note, the source pixel value is shifted left by 16 bits so that
 311      * we know we will always have to shift right to extract the components.
 312      */
 313     rRightShift1=16+X11DRV_DIB_MaskToShift(rsrc)-3;
 314     gRightShift1=16+X11DRV_DIB_MaskToShift(gsrc)-3;
 315     bRightShift1=16+X11DRV_DIB_MaskToShift(bsrc)-3;
 316     rRightShift2=rRightShift1+5;
 317     gRightShift2=gRightShift1+5;
 318     bRightShift2=bRightShift1+5;
 319     if (gsrc==0x03e0) {
 320         /* Green has 5 bits, like the others */
 321         gMask1=0xf8;
 322         gMask2=0x07;
 323     } else {
 324         /* Green has 6 bits, not 5. Compensate. */
 325         gRightShift1++;
 326         gRightShift2+=2;
 327         gMask1=0xfc;
 328         gMask2=0x03;
 329     }
 330
 331     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
 332     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
 333     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
 334
 335     for (y=0; y<height; y++) {
 336         srcpixel=srcbits;
 337         dstpixel=dstbits;
 338         for (x=0; x<width; x++) {
 339             DWORD srcval;
 340             BYTE red,green,blue;
 341             srcval=*srcpixel++ << 16;
 342             FLIP_TWO_WORDS(&srcval);
 343
 344             red=  ((srcval >> rRightShift1) & 0xf8) |
 345                   ((srcval >> rRightShift2) & 0x07);
 346             green=((srcval >> gRightShift1) & gMask1) |
 347                   ((srcval >> gRightShift2) & gMask2);
 348             blue= ((srcval >> bRightShift1) & 0xf8) |
 349                   ((srcval >> bRightShift2) & 0x07);
 350             *dstpixel++=(red   << rLeftShift) |
 351                         (green << gLeftShift) |
 352                         (blue  << bLeftShift);
 353         }
 354         srcbits = (const char*)srcbits + srclinebytes;
 355         dstbits = (char*)dstbits + dstlinebytes;
 356     }
 357 }
 358
 359 /*
 360  * 16 bits conversions
 361  */
 362
 363 static void convert_565_reverse_src_byteswap(int width, int height,
 364                                              const void* srcbits, int srclinebytes,
 365                                              void* dstbits, int dstlinebytes)
 366 {
 367     const DWORD* srcpixel;
 368     DWORD* dstpixel;
 369     int x,y;
 370
 371     for (y=0; y<height; y++) {
 372         srcpixel=srcbits;
 373         dstpixel=dstbits;
 374         for (x=0; x<width/2; x++) {
 375             /* Do 2 pixels at a time */
 376             DWORD srcval;
 377             srcval=*srcpixel++;
 378             *dstpixel++=((srcval <<  3) & 0xf800f800) | /* l */
 379                         ((srcval <<  8) & 0x07000700) | /* g - 3 bits */
 380                         ((srcval >>  8) & 0x00e000e0) | /* g - 3 bits */
 381                         ((srcval >>  3) & 0x001f001f);  /* h */
 382         }
 383         if (width&1) {
 384             /* And then the odd pixel */
 385             WORD srcval;
 386             srcval=*((const WORD*)srcpixel);
 387             *((WORD*)dstpixel)=((srcval <<  3) & 0xf800) | /* l */
 388                                ((srcval <<  8) & 0x0700) | /* g - 3 bits */
 389                                ((srcval >>  8) & 0x00e0) | /* g - 3 bits */
 390                                ((srcval >>  3) & 0x001f);  /* h */
 391         }
 392         srcbits = (const char*)srcbits + srclinebytes;
 393         dstbits = (char*)dstbits + dstlinebytes;
 394     }
 395 }
 396
 397 static void convert_565_to_555_asis_src_byteswap(int width, int height,
 398                                                  const void* srcbits, int srclinebytes,
 399                                                  void* dstbits, int dstlinebytes)
 400 {
 401     const DWORD* srcpixel;
 402     DWORD* dstpixel;
 403     int x,y;
 404
 405     for (y=0; y<height; y++) {
 406         srcpixel=srcbits;
 407         dstpixel=dstbits;
 408         for (x=0; x<width/2; x++) {
 409             /* Do 2 pixels at a time */
 410             DWORD srcval;
 411             srcval=*srcpixel++;
 412             *dstpixel++=((srcval << 7) & 0x7f807f80) | /* h, g - 3 bits */
 413                         ((srcval >> 9) & 0x00600060) | /* g - 2 bits */
 414                         ((srcval >> 8) & 0x001f001f);  /* l */
 415         }
 416         if (width&1) {
 417             /* And then the odd pixel */
 418             WORD srcval;
 419             srcval=*((const WORD*)srcpixel);
 420             *((WORD*)dstpixel)=((srcval << 7) & 0x7f80) | /* h, g - 3 bits */
 421                                ((srcval >> 9) & 0x0060) | /* g - 2 bits */
 422                                ((srcval >> 8) & 0x001f);  /* l */
 423         }
 424         srcbits = (const char*)srcbits + srclinebytes;
 425         dstbits = (char*)dstbits + dstlinebytes;
 426     }
 427 }
 428
 429 static void convert_565_to_555_reverse_src_byteswap(int width, int height,
 430                                                     const void* srcbits, int srclinebytes,
 431                                                     void* dstbits, int dstlinebytes)
 432 {
 433     const DWORD* srcpixel;
 434     DWORD* dstpixel;
 435     int x,y;
 436
 437     for (y=0; y<height; y++) {
 438         srcpixel=srcbits;
 439         dstpixel=dstbits;
 440         for (x=0; x<width/2; x++) {
 441             /* Do 2 pixels at a time */
 442             DWORD srcval;
 443             srcval=*srcpixel++;
 444             *dstpixel++=((srcval >>  3) & 0x001f001f) | /* h */
 445                         ((srcval >>  9) & 0x00600060) | /* g - 2 bits */
 446                         ((srcval <<  7) & 0x03800380) | /* g - 3 bits */
 447                         ((srcval <<  2) & 0x7c007c00);  /* l */
 448         }
 449         if (width&1) {
 450             /* And then the odd pixel */
 451             WORD srcval;
 452             srcval=*((const WORD*)srcpixel);
 453             *((WORD*)dstpixel)=((srcval >>  3) & 0x001f) | /* h */
 454                                ((srcval >>  9) & 0x0060) | /* g - 2 bits */
 455                                ((srcval <<  7) & 0x0380) | /* g - 3 bits */
 456                                ((srcval <<  2) & 0x7c00);  /* l */
 457         }
 458         srcbits = (const char*)srcbits + srclinebytes;
 459         dstbits = (char*)dstbits + dstlinebytes;
 460     }
 461 }
 462
 463 static void convert_565_to_888_asis_src_byteswap(int width, int height,
 464                                                  const void* srcbits, int srclinebytes,
 465                                                  void* dstbits, int dstlinebytes)
 466 {
 467     const WORD* srcpixel;
 468     BYTE* dstpixel;
 469     int x,y;
 470
 471     for (y=0; y<height; y++) {
 472         srcpixel=srcbits;
 473         dstpixel=dstbits;
 474         for (x=0; x<width; x++) {
 475             WORD srcval;
 476             srcval=*srcpixel++;
 477             dstpixel[0]=((srcval >>  5) & 0xf8) | /* l */
 478                         ((srcval >> 10) & 0x07);  /* l - 3 bits */
 479             dstpixel[1]=((srcval <<  5) & 0xe0) | /* g - 3 bits */
 480                         ((srcval >> 11) & 0x1c) | /* g - 3 bits */
 481                         ((srcval >>  1) & 0x03);  /* g - 2 bits */
 482             dstpixel[2]=((srcval >>  0) & 0xf8) | /* h */
 483                         ((srcval >>  5) & 0x07);  /* h - 3 bits */
 484             dstpixel+=3;
 485         }
 486         srcbits = (const char*)srcbits + srclinebytes;
 487         dstbits = (char*)dstbits + dstlinebytes;
 488     }
 489 }
 490
 491 static void convert_565_to_888_reverse_src_byteswap(int width, int height,
 492                                                     const void* srcbits, int srclinebytes,
 493                                                     void* dstbits, int dstlinebytes)
 494 {
 495     const WORD* srcpixel;
 496     BYTE* dstpixel;
 497     int x,y;
 498
 499     for (y=0; y<height; y++) {
 500         srcpixel=srcbits;
 501         dstpixel=dstbits;
 502         for (x=0; x<width; x++) {
 503             WORD srcval;
 504             srcval=*srcpixel++;
 505             dstpixel[0]=((srcval >>  0) & 0xf8) | /* h */
 506                         ((srcval >>  5) & 0x07);  /* h - 3 bits */
 507             dstpixel[1]=((srcval <<  5) & 0xe0) | /* g - 3 bits */
 508                         ((srcval >> 11) & 0x1c) | /* g - 3 bits */
 509                         ((srcval >>  1) & 0x03);  /* g - 2 bits */
 510             dstpixel[2]=((srcval >>  5) & 0xf8) | /* l */
 511                         ((srcval >> 10) & 0x07);  /* l - 3 bits */
 512             dstpixel+=3;
 513         }
 514         srcbits = (const char*)srcbits + srclinebytes;
 515         dstbits = (char*)dstbits + dstlinebytes;
 516     }
 517 }
 518
 519 static void convert_565_to_0888_asis_src_byteswap(int width, int height,
 520                                                   const void* srcbits, int srclinebytes,
 521                                                   void* dstbits, int dstlinebytes)
 522 {
 523     const WORD* srcpixel;
 524     DWORD* dstpixel;
 525     int x,y;
 526
 527     for (y=0; y<height; y++) {
 528         srcpixel=srcbits;
 529         dstpixel=dstbits;
 530         for (x=0; x<width; x++) {
 531             WORD srcval;
 532             srcval=*srcpixel++;
 533             *dstpixel++=((srcval << 16) & 0xf80000) | /* h */
 534                         ((srcval << 11) & 0x070000) | /* h - 3 bits */
 535                         ((srcval << 13) & 0x00e000) | /* g - 3 bits */
 536                         ((srcval >>  3) & 0x001c00) | /* g - 3 bits */
 537                         ((srcval <<  7) & 0x000300) | /* g - 2 bits */
 538                         ((srcval >>  5) & 0x0000f8) | /* l */
 539                         ((srcval >> 10) & 0x000007);  /* l - 3 bits */
 540         }
 541         srcbits = (const char*)srcbits + srclinebytes;
 542         dstbits = (char*)dstbits + dstlinebytes;
 543     }
 544 }
 545
 546 static void convert_565_to_0888_reverse_src_byteswap(int width, int height,
 547                                                      const void* srcbits, int srclinebytes,
 548                                                      void* dstbits, int dstlinebytes)
 549 {
 550     const WORD* srcpixel;
 551     DWORD* dstpixel;
 552     int x,y;
 553
 554     for (y=0; y<height; y++) {
 555         srcpixel=srcbits;
 556         dstpixel=dstbits;
 557         for (x=0; x<width; x++) {
 558             WORD srcval;
 559             srcval=*srcpixel++;
 560             *dstpixel++=((srcval >>  0) & 0x0000f8) | /* h */
 561                         ((srcval >>  5) & 0x000007) | /* h - 3 bits */
 562                         ((srcval << 13) & 0x00e000) | /* g - 3 bits */
 563                         ((srcval >>  3) & 0x001c00) | /* g - 3 bits */
 564                         ((srcval <<  7) & 0x000300) | /* g - 2 bits */
 565                         ((srcval << 11) & 0xf80000) | /* l */
 566                         ((srcval <<  6) & 0x070000);  /* l - 3 bits */
 567         }
 568         srcbits = (const char*)srcbits + srclinebytes;
 569         dstbits = (char*)dstbits + dstlinebytes;
 570     }
 571 }
 572
 573 /*
 574  * 24 bit conversions
 575  */
 576
 577 static void convert_888_asis_src_byteswap(int width, int height,
 578                                           const void* srcbits, int srclinebytes,
 579                                           void* dstbits, int dstlinebytes)
 580 {
 581     int x, y;
 582
 583     for (y=0; y<height; y++) {
 584         for(x = 0; x < ((width+1)*3/4); x++) {
 585             DWORD srcval = *((const DWORD*)srcbits + x);
 586             *((DWORD*)dstbits + x) = ((srcval << 24) & 0xff000000) |
 587                                      ((srcval <<  8) & 0x00ff0000) |
 588                                      ((srcval >>  8) & 0x0000ff00) |
 589                                      ((srcval >> 24) & 0x000000ff);
 590         }
 591         srcbits = (const char*)srcbits + srclinebytes;
 592         dstbits = (char*)dstbits + dstlinebytes;
 593     }
 594 }
 595
 596 static void convert_888_reverse_src_byteswap(int width, int height,
 597                                              const void* srcbits, int srclinebytes,
 598                                              void* dstbits, int dstlinebytes)
 599 {
 600     const DWORD* srcpixel;
 601     DWORD* dstpixel;
 602     DWORD srcarray[3];
 603     int x,y;
 604     int oddwidth = width & 3;
 605
 606     width = width/4;
 607
 608     for (y=0; y<height; y++) {
 609         srcpixel=srcbits;
 610         dstpixel=dstbits;
 611         for (x=0; x<width; x++) {
 612             /* Do 4 pixels at a time: 3 dwords in and 3 dwords out */
 613             *dstpixel++= ((srcpixel[0] >>  8) & 0x00ffffff) | /* l1, g1, h1 */
 614                          ((srcpixel[1] <<  8) & 0xff000000);  /* h2 */
 615             *dstpixel++= ((srcpixel[1] >> 24) & 0x000000ff) | /* g2 */
 616                          ((srcpixel[0] <<  8) & 0x0000ff00) | /* l2 */
 617                          ((srcpixel[2] >>  8) & 0x00ff0000) | /* h3 */
 618                          ((srcpixel[1] << 24) & 0xff000000);  /* g3 */
 619             *dstpixel++= ((srcpixel[1] >>  8) & 0x000000ff) | /* l3 */
 620                          ((srcpixel[2] <<  8) & 0xffffff00);  /* l4, g4, h4 */
 621             srcpixel+=3;
 622         }
 623         /* And now up to 3 odd pixels */
 624         if(oddwidth) {
 625             BYTE *dstbyte, *srcbyte;
 626             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 627             dstbyte = (LPBYTE)dstpixel;
 628             srcbyte = (LPBYTE)srcarray;
 629             for (x=0; x<oddwidth; x++) {
 630                 FLIP_DWORD(srcarray+x);
 631                 dstbyte[0] = srcbyte[2];
 632                 dstbyte[1] = srcbyte[1];
 633                 dstbyte[2] = srcbyte[0];
 634                 srcbyte+=3;
 635                 dstbyte+=3;
 636             }
 637         }
 638
 639         srcbits = (const char*)srcbits + srclinebytes;
 640         dstbits = (char*)dstbits + dstlinebytes;
 641     }
 642 }
 643
 644 static void convert_888_to_555_asis_src_byteswap(int width, int height,
 645                                                  const void* srcbits, int srclinebytes,
 646                                                  void* dstbits, int dstlinebytes)
 647 {
 648     const DWORD* srcpixel;
 649     const BYTE* srcbyte;
 650     WORD* dstpixel;
 651     DWORD srcarray[3];
 652     int x,y;
 653     int oddwidth;
 654
 655     oddwidth=width & 3;
 656     width=width/4;
 657     for (y=0; y<height; y++) {
 658         srcpixel=srcbits;
 659         dstpixel=dstbits;
 660         for (x=0; x<width; x++) {
 661             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 662             DWORD srcval1,srcval2;
 663             srcval1=srcpixel[0];
 664             FLIP_DWORD(&srcval1);
 665             dstpixel[0]=((srcval1 >>  3) & 0x001f) | /* l1 */
 666                         ((srcval1 >>  6) & 0x03e0) | /* g1 */
 667                         ((srcval1 >>  9) & 0x7c00);  /* h1 */
 668             srcval2=srcpixel[1];
 669             FLIP_DWORD(&srcval2);
 670             dstpixel[1]=((srcval1 >> 27) & 0x001f) | /* l2 */
 671                         ((srcval2 <<  2) & 0x03e0) | /* g2 */
 672                         ((srcval2 >>  1) & 0x7c00);  /* h2 */
 673             srcval1=srcpixel[2];
 674             FLIP_DWORD(&srcval1);
 675             dstpixel[2]=((srcval2 >> 19) & 0x001f) | /* l3 */
 676                         ((srcval2 >> 22) & 0x03e0) | /* g3 */
 677                         ((srcval1 <<  7) & 0x7c00);  /* h3 */
 678             dstpixel[3]=((srcval1 >> 11) & 0x001f) | /* l4 */
 679                         ((srcval1 >> 14) & 0x03e0) | /* g4 */
 680                         ((srcval1 >> 17) & 0x7c00);  /* h4 */
 681             srcpixel+=3;
 682             dstpixel+=4;
 683         }
 684         /* And now up to 3 odd pixels */
 685         if(oddwidth) {
 686             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 687             srcbyte = (LPBYTE)srcarray;
 688             for (x=0; x<oddwidth; x++) {
 689                 WORD dstval;
 690                 FLIP_DWORD(srcarray+x);
 691
 692                 dstval =((srcbyte[0] >> 3) & 0x001f);    /* l */
 693                 dstval|=((srcbyte[1] << 2) & 0x03e0);    /* g */
 694                 dstval|=((srcbyte[2] << 7) & 0x7c00);    /* h */
 695                 *dstpixel++=dstval;
 696                 srcbyte+=3;
 697             }
 698         }
 699         srcbits = (const char*)srcbits + srclinebytes;
 700         dstbits = (char*)dstbits + dstlinebytes;
 701     }
 702 }
 703
 704 static void convert_888_to_555_reverse_src_byteswap(int width, int height,
 705                                                     const void* srcbits, int srclinebytes,
 706                                                     void* dstbits, int dstlinebytes)
 707 {
 708     const DWORD* srcpixel;
 709     const BYTE* srcbyte;
 710     WORD* dstpixel;
 711     DWORD srcarray[3];
 712     int x,y;
 713     int oddwidth;
 714
 715     oddwidth=width & 3;
 716     width=width/4;
 717     for (y=0; y<height; y++) {
 718         srcpixel=srcbits;
 719         dstpixel=dstbits;
 720         for (x=0; x<width; x++) {
 721             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 722             DWORD srcval1,srcval2;
 723             srcval1=srcpixel[0];
 724             FLIP_DWORD(&srcval1);
 725             dstpixel[0]=((srcval1 <<  7) & 0x7c00) | /* l1 */
 726                         ((srcval1 >>  6) & 0x03e0) | /* g1 */
 727                         ((srcval1 >> 19) & 0x001f);  /* h1 */
 728             srcval2=srcpixel[1];
 729             FLIP_DWORD(&srcval2);
 730             dstpixel[1]=((srcval1 >> 17) & 0x7c00) | /* l2 */
 731                         ((srcval2 <<  2) & 0x03e0) | /* g2 */
 732                         ((srcval2 >> 11) & 0x001f);  /* h2 */
 733             srcval1=srcpixel[2];
 734             FLIP_DWORD(&srcval1);
 735             dstpixel[2]=((srcval2 >>  9) & 0x7c00) | /* l3 */
 736                         ((srcval2 >> 22) & 0x03e0) | /* g3 */
 737                         ((srcval1 >>  3) & 0x001f);  /* h3 */
 738             dstpixel[3]=((srcval1 >>  1) & 0x7c00) | /* l4 */
 739                         ((srcval1 >> 14) & 0x03e0) | /* g4 */
 740                         ((srcval1 >> 27) & 0x001f);  /* h4 */
 741             srcpixel+=3;
 742             dstpixel+=4;
 743         }
 744         /* And now up to 3 odd pixels */
 745         if(oddwidth) {
 746             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 747             srcbyte = (LPBYTE)srcarray;
 748             for (x=0; x<oddwidth; x++) {
 749                 WORD dstval;
 750                 FLIP_DWORD(srcarray+x);
 751                 dstval =((srcbyte[0] << 7) & 0x7c00);    /* l */
 752                 dstval|=((srcbyte[1] << 2) & 0x03e0);    /* g */
 753                 dstval|=((srcbyte[2] >> 3) & 0x001f);    /* h */
 754                 *dstpixel++=dstval;
 755                 srcbyte+=3;
 756             }
 757         }
 758         srcbits = (const char*)srcbits + srclinebytes;
 759         dstbits = (char*)dstbits + dstlinebytes;
 760     }
 761 }
 762
 763 static void convert_888_to_565_asis_src_byteswap(int width, int height,
 764                                                  const void* srcbits, int srclinebytes,
 765                                                  void* dstbits, int dstlinebytes)
 766 {
 767     const DWORD* srcpixel;
 768     const BYTE* srcbyte;
 769     WORD* dstpixel;
 770     DWORD srcarray[3];
 771     int x,y;
 772     int oddwidth;
 773
 774     oddwidth=width & 3;
 775     width=width/4;
 776     for (y=0; y<height; y++) {
 777         srcpixel=srcbits;
 778         dstpixel=dstbits;
 779         for (x=0; x<width; x++) {
 780             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 781             DWORD srcval1,srcval2;
 782             srcval1=srcpixel[0];
 783             FLIP_DWORD(&srcval1);
 784             dstpixel[0]=((srcval1 >>  3) & 0x001f) | /* l1 */
 785                         ((srcval1 >>  5) & 0x07e0) | /* g1 */
 786                         ((srcval1 >>  8) & 0xf800);  /* h1 */
 787             srcval2=srcpixel[1];
 788             FLIP_DWORD(&srcval2);
 789             dstpixel[1]=((srcval1 >> 27) & 0x001f) | /* l2 */
 790                         ((srcval2 <<  3) & 0x07e0) | /* g2 */
 791                         ( srcval2        & 0xf800);  /* h2 */
 792             srcval1=srcpixel[2];
 793             FLIP_DWORD(&srcval1);
 794             dstpixel[2]=((srcval2 >> 19) & 0x001f) | /* l3 */
 795                         ((srcval2 >> 21) & 0x07e0) | /* g3 */
 796                         ((srcval1 <<  8) & 0xf800);  /* h3 */
 797             dstpixel[3]=((srcval1 >> 11) & 0x001f) | /* l4 */
 798                         ((srcval1 >> 13) & 0x07e0) | /* g4 */
 799                         ((srcval1 >> 16) & 0xf800);  /* h4 */
 800             srcpixel+=3;
 801             dstpixel+=4;
 802         }
 803         /* And now up to 3 odd pixels */
 804         if(oddwidth) {
 805             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 806             srcbyte = (LPBYTE)srcarray;
 807             for (x=0; x<oddwidth; x++) {
 808                 WORD dstval;
 809                 FLIP_DWORD(srcarray+x);
 810                 dstval =((srcbyte[0] >> 3) & 0x001f);    /* l */
 811                 dstval|=((srcbyte[1] << 3) & 0x07e0);    /* g */
 812                 dstval|=((srcbyte[2] << 8) & 0xf800);    /* h */
 813                 *dstpixel++=dstval;
 814                 srcbyte+=3;
 815             }
 816         }
 817         srcbits = (const char*)srcbits + srclinebytes;
 818         dstbits = (char*)dstbits + dstlinebytes;
 819     }
 820 }
 821
 822 static void convert_888_to_565_reverse_src_byteswap(int width, int height,
 823                                                     const void* srcbits, int srclinebytes,
 824                                                     void* dstbits, int dstlinebytes)
 825 {
 826     const DWORD* srcpixel;
 827     const BYTE* srcbyte;
 828     WORD* dstpixel;
 829     DWORD srcarray[3];
 830     int x,y;
 831     int oddwidth;
 832
 833     oddwidth=width & 3;
 834     width=width/4;
 835     for (y=0; y<height; y++) {
 836         srcpixel=srcbits;
 837         dstpixel=dstbits;
 838         for (x=0; x<width; x++) {
 839             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 840             DWORD srcval1,srcval2;
 841             srcval1=srcpixel[0];
 842             FLIP_DWORD(&srcval1);
 843             dstpixel[0]=((srcval1 <<  8) & 0xf800) | /* l1 */
 844                         ((srcval1 >>  5) & 0x07e0) | /* g1 */
 845                         ((srcval1 >> 19) & 0x001f);  /* h1 */
 846             srcval2=srcpixel[1];
 847             FLIP_DWORD(&srcval2);
 848             dstpixel[1]=((srcval1 >> 16) & 0xf800) | /* l2 */
 849                         ((srcval2 <<  3) & 0x07e0) | /* g2 */
 850                         ((srcval2 >> 11) & 0x001f);  /* h2 */
 851             srcval1=srcpixel[2];
 852             FLIP_DWORD(&srcval1);
 853             dstpixel[2]=((srcval2 >>  8) & 0xf800) | /* l3 */
 854                         ((srcval2 >> 21) & 0x07e0) | /* g3 */
 855                         ((srcval1 >>  3) & 0x001f);  /* h3 */
 856             dstpixel[3]=(srcval1         & 0xf800) | /* l4 */
 857                         ((srcval1 >> 13) & 0x07e0) | /* g4 */
 858                         ((srcval1 >> 27) & 0x001f);  /* h4 */
 859             srcpixel+=3;
 860             dstpixel+=4;
 861         }
 862         /* And now up to 3 odd pixels */
 863         if(oddwidth) {
 864             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 865             srcbyte = (LPBYTE)srcarray;
 866             for (x=0; x<oddwidth; x++) {
 867                 WORD dstval;
 868                 FLIP_DWORD(srcarray+x);
 869                 dstval =((srcbyte[0] << 8) & 0xf800);    /* l */
 870                 dstval|=((srcbyte[1] << 3) & 0x07e0);    /* g */
 871                 dstval|=((srcbyte[2] >> 3) & 0x001f);    /* h */
 872                 *dstpixel++=dstval;
 873                 srcbyte+=3;
 874             }
 875         }
 876         srcbits = (const char*)srcbits + srclinebytes;
 877         dstbits = (char*)dstbits + dstlinebytes;
 878     }
 879 }
 880
 881 static void convert_888_to_0888_asis_src_byteswap(int width, int height,
 882                                                   const void* srcbits, int srclinebytes,
 883                                                   void* dstbits, int dstlinebytes)
 884 {
 885     const DWORD* srcpixel;
 886     DWORD* dstpixel;
 887     DWORD srcarray[3];
 888     int x,y;
 889     int oddwidth;
 890
 891     oddwidth=width & 3;
 892     width=width/4;
 893     for (y=0; y<height; y++) {
 894         srcpixel=srcbits;
 895         dstpixel=dstbits;
 896         for (x=0; x<width; x++) {
 897             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
 898             DWORD srcval1,srcval2;
 899             srcval1=srcpixel[0];
 900             FLIP_DWORD(&srcval1);
 901             dstpixel[0]=( srcval1        & 0x00ffffff);  /* h1, g1, l1 */
 902             srcval2=srcpixel[1];
 903             FLIP_DWORD(&srcval2);
 904             dstpixel[1]=( srcval1 >> 24) |              /* l2 */
 905                         ((srcval2 <<  8) & 0x00ffff00); /* h2, g2 */
 906             srcval1=srcpixel[2];
 907             FLIP_DWORD(&srcval1);
 908             dstpixel[2]=( srcval2 >> 16) |              /* g3, l3 */
 909                         ((srcval1 << 16) & 0x00ff0000); /* h3 */
 910             dstpixel[3]=( srcval1 >>  8);               /* h4, g4, l4 */
 911             srcpixel+=3;
 912             dstpixel+=4;
 913         }
 914         /* And now up to 3 odd pixels */
 915         if(oddwidth) {
 916             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 917             srcpixel = srcarray;
 918             for (x=0; x<oddwidth; x++) {
 919                 DWORD srcval;
 920                 FLIP_DWORD(srcarray+x);
 921                 srcval=*srcpixel;
 922                 srcpixel=(const DWORD*)(((const char*)srcpixel)+3);
 923                 *dstpixel++=( srcval         & 0x00ffffff); /* h, g, l */
 924             }
 925         }
 926         srcbits = (const char*)srcbits + srclinebytes;
 927         dstbits = (char*)dstbits + dstlinebytes;
 928     }
 929 }
 930
 931 static void convert_888_to_0888_reverse_src_byteswap(int width, int height,
 932                                                      const void* srcbits, int srclinebytes,
 933                                                      void* dstbits, int dstlinebytes)
 934 {
 935     const DWORD* srcpixel;
 936     DWORD* dstpixel;
 937     DWORD srcarray[3];
 938     int x,y;
 939     int oddwidth;
 940
 941     oddwidth=width & 3;
 942     width=width/4;
 943     for (y=0; y<height; y++) {
 944         srcpixel=srcbits;
 945         dstpixel=dstbits;
 946         for (x=0; x<width; x++) {
 947             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
 948             DWORD srcval1,srcval2;
 949
 950             srcval1=srcpixel[0];
 951             FLIP_DWORD(&srcval1);
 952             dstpixel[0]=((srcval1 >> 16) & 0x0000ff) | /* h1 */
 953                         ( srcval1        & 0x00ff00) | /* g1 */
 954                         ((srcval1 << 16) & 0xff0000);  /* l1 */
 955             srcval2=srcpixel[1];
 956             FLIP_DWORD(&srcval2);
 957             dstpixel[1]=((srcval1 >>  8) & 0xff0000) | /* l2 */
 958                         ((srcval2 <<  8) & 0x00ff00) | /* g2 */
 959                         ((srcval2 >>  8) & 0x0000ff);  /* h2 */
 960             srcval1=srcpixel[2];
 961             FLIP_DWORD(&srcval1);
 962             dstpixel[2]=( srcval2        & 0xff0000) | /* l3 */
 963                         ((srcval2 >> 16) & 0x00ff00) | /* g3 */
 964                         ( srcval1        & 0x0000ff);  /* h3 */
 965             dstpixel[3]=((srcval1 >> 24) & 0x0000ff) | /* h4 */
 966                         ((srcval1 >>  8) & 0x00ff00) | /* g4 */
 967                         ((srcval1 <<  8) & 0xff0000);  /* l4 */
 968             srcpixel+=3;
 969             dstpixel+=4;
 970         }
 971         /* And now up to 3 odd pixels */
 972         if(oddwidth) {
 973             memcpy(srcarray,srcpixel,oddwidth*sizeof(DWORD));
 974             srcpixel = srcarray;
 975             for (x=0; x<oddwidth; x++) {
 976                 DWORD srcval;
 977                 FLIP_DWORD(srcarray+x);
 978                 srcval=*srcpixel;
 979                 srcpixel=(const DWORD*)(((const char*)srcpixel)+3);
 980                 *dstpixel++=((srcval  >> 16) & 0x0000ff) | /* h */
 981                             ( srcval         & 0x00ff00) | /* g */
 982                             ((srcval  << 16) & 0xff0000);  /* l */
 983             }
 984         }
 985         srcbits = (const char*)srcbits + srclinebytes;
 986         dstbits = (char*)dstbits + dstlinebytes;
 987     }
 988 }
 989
 990 static void convert_rgb888_to_any0888_src_byteswap(int width, int height,
 991                                                    const void* srcbits, int srclinebytes,
 992                                                    void* dstbits, int dstlinebytes,
 993                                                    DWORD rdst, DWORD gdst, DWORD bdst)
 994 {
 995     int rLeftShift,gLeftShift,bLeftShift;
 996     const DWORD* srcpixel;
 997     DWORD* dstpixel;
 998     int x,y;
 999     DWORD srcarray[3];
1000
1001     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1002     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1003     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1004     for (y=0; y<height; y++) {
1005         srcpixel=srcbits;
1006         dstpixel=dstbits;
1007         for (x=0; x<width/4; x++) {
1008             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
1009             DWORD srcval1, srcval2;
1010             srcval1=*srcpixel++;
1011             *dstpixel++=(((srcval1 >> 24) & 0xff) << bLeftShift) | /* b1 */
1012                         (((srcval1 >> 16) & 0xff) << gLeftShift) | /* g1 */
1013                         (((srcval1 >>  8) & 0xff) << rLeftShift);  /* r1 */
1014             srcval2=*srcpixel++;
1015             *dstpixel++=(((srcval1 >>  0) & 0xff) << bLeftShift) | /* b2 */
1016                         (((srcval2 >> 24) & 0xff) << gLeftShift) | /* g2 */
1017                         (((srcval2 >> 16) & 0xff) << rLeftShift);  /* r2 */
1018             srcval1=*srcpixel++;
1019             *dstpixel++=(((srcval2 >>  8) & 0xff) << bLeftShift) | /* b3 */
1020                         (((srcval2 >>  0) & 0xff) << gLeftShift) | /* g3 */
1021                         (((srcval1 >> 24) & 0xff) << rLeftShift);  /* r3 */
1022             *dstpixel++=(((srcval1 >> 16) & 0xff) << bLeftShift) | /* b4 */
1023                         (((srcval1 >>  8) & 0xff) << gLeftShift) | /* g4 */
1024                         (((srcval1 >>  0) & 0xff) << rLeftShift);  /* r4 */
1025         }
1026         /* And now up to 3 odd pixels */
1027         if(width&3) {
1028             memcpy(srcarray,srcpixel,width&3*sizeof(DWORD));
1029             srcpixel = srcarray;
1030             for (x=0; x < (width&3); x++) {
1031                 DWORD srcval;
1032                 FLIP_DWORD(srcarray+x);
1033                 srcval=*srcpixel;
1034                 srcpixel=(const DWORD*)(((const char*)srcpixel)+3);
1035                 *dstpixel++=(((srcval >>  0) & 0xff) << bLeftShift) | /* b */
1036                             (((srcval >>  8) & 0xff) << gLeftShift) | /* g */
1037                             (((srcval >> 16) & 0xff) << rLeftShift);  /* r */
1038             }
1039         }
1040         srcbits = (const char*)srcbits + srclinebytes;
1041         dstbits = (char*)dstbits + dstlinebytes;
1042     }
1043 }
1044
1045 static void convert_bgr888_to_any0888_src_byteswap(int width, int height,
1046                                                    const void* srcbits, int srclinebytes,
1047                                                    void* dstbits, int dstlinebytes,
1048                                                    DWORD rdst, DWORD gdst, DWORD bdst)
1049 {
1050     int rLeftShift,gLeftShift,bLeftShift;
1051     const DWORD* srcpixel;
1052     DWORD* dstpixel;
1053     int x,y;
1054     DWORD srcarray[3];
1055
1056     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1057     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1058     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1059     for (y=0; y<height; y++) {
1060         srcpixel=srcbits;
1061         dstpixel=dstbits;
1062         for (x=0; x<width/4; x++) {
1063             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
1064             DWORD srcval1, srcval2;
1065             srcval1=*srcpixel++;
1066             *dstpixel++=(((srcval1 >> 24) & 0xff) << rLeftShift) | /* r1 */
1067                         (((srcval1 >> 16) & 0xff) << gLeftShift) | /* g1 */
1068                         (((srcval1 >>  8) & 0xff) << bLeftShift);  /* b1 */
1069             srcval2=*srcpixel++;
1070             *dstpixel++=(((srcval1 >>  0) & 0xff) << rLeftShift) | /* r2 */
1071                         (((srcval2 >> 24) & 0xff) << gLeftShift) | /* g2 */
1072                         (((srcval2 >> 16) & 0xff) << bLeftShift);  /* b2 */
1073             srcval1=*srcpixel++;
1074             *dstpixel++=(((srcval2 >>  8) & 0xff) << rLeftShift) | /* r3 */
1075                         (((srcval2 >>  0) & 0xff) << gLeftShift) | /* g3 */
1076                         (((srcval1 >> 24) & 0xff) << bLeftShift);  /* b3 */
1077             *dstpixel++=(((srcval1 >> 16) & 0xff) << rLeftShift) | /* r4 */
1078                         (((srcval1 >>  8) & 0xff) << gLeftShift) | /* g4 */
1079                         (((srcval1 >>  0) & 0xff) << bLeftShift);  /* b4 */
1080         }
1081         /* And now up to 3 odd pixels */
1082         if(width&3) {
1083             memcpy(srcarray,srcpixel,width&3*sizeof(DWORD));
1084             srcpixel = srcarray;
1085             for (x=0; x < (width&3); x++) {
1086                 DWORD srcval;
1087                 FLIP_DWORD(srcarray+x);
1088                 srcval=*srcpixel;
1089                 srcpixel=(const DWORD*)(((const char*)srcpixel)+3);
1090                 *dstpixel++=(((srcval >>  0) & 0xff) << rLeftShift) | /* r */
1091                             (((srcval >>  8) & 0xff) << gLeftShift) | /* g */
1092                             (((srcval >> 16) & 0xff) << bLeftShift);  /* b */
1093             }
1094         }
1095         srcbits = (const char*)srcbits + srclinebytes;
1096         dstbits = (char*)dstbits + dstlinebytes;
1097     }
1098 }
1099
1100
1101 /*
1102  * 32 bit conversions
1103  */
1104
1105 static void convert_0888_asis_src_byteswap(int width, int height,
1106                                            const void* srcbits, int srclinebytes,
1107                                            void* dstbits, int dstlinebytes)
1108 {
1109     int x, y;
1110
1111     for (y=0; y<height; y++) {
1112         for(x = 0; x < width; x++) {
1113             DWORD srcval = *((const DWORD*)srcbits + x);
1114             *((DWORD*)dstbits + x) = ((srcval << 24) & 0xff000000) |
1115                                      ((srcval <<  8) & 0x00ff0000) |
1116                                      ((srcval >>  8) & 0x0000ff00) |
1117                                      ((srcval >> 24) & 0x000000ff);
1118         }
1119         srcbits = (const char*)srcbits + srclinebytes;
1120         dstbits = (char*)dstbits + dstlinebytes;
1121     }
1122 }
1123
1124 static void convert_0888_reverse_src_byteswap(int width, int height,
1125                                               const void* srcbits, int srclinebytes,
1126                                               void* dstbits, int dstlinebytes)
1127 {
1128     const DWORD* srcpixel;
1129     DWORD* dstpixel;
1130     int x,y;
1131
1132     for (y=0; y<height; y++) {
1133         srcpixel=srcbits;
1134         dstpixel=dstbits;
1135         for (x=0; x<width; x++) {
1136             DWORD srcval;
1137             srcval=*srcpixel++;
1138             *dstpixel++=((srcval >> 8) & 0x00ffffff);
1139         }
1140         srcbits = (const char*)srcbits + srclinebytes;
1141         dstbits = (char*)dstbits + dstlinebytes;
1142     }
1143 }
1144
1145 static void convert_0888_any_src_byteswap(int width, int height,
1146                                           const void* srcbits, int srclinebytes,
1147                                           DWORD rsrc, DWORD gsrc, DWORD bsrc,
1148                                           void* dstbits, int dstlinebytes,
1149                                           DWORD rdst, DWORD gdst, DWORD bdst)
1150 {
1151     int rRightShift,gRightShift,bRightShift;
1152     int rLeftShift,gLeftShift,bLeftShift;
1153     const DWORD* srcpixel;
1154     DWORD* dstpixel;
1155     int x,y;
1156
1157     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1158     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1159     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1160     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1161     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1162     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1163     for (y=0; y<height; y++) {
1164         srcpixel=srcbits;
1165         dstpixel=dstbits;
1166         for (x=0; x<width; x++) {
1167             DWORD srcval;
1168             srcval=*srcpixel++;
1169             FLIP_DWORD(&srcval);
1170             *dstpixel++=(((srcval >> rRightShift) & 0xff) << rLeftShift) |
1171                         (((srcval >> gRightShift) & 0xff) << gLeftShift) |
1172                         (((srcval >> bRightShift) & 0xff) << bLeftShift);
1173         }
1174         srcbits = (const char*)srcbits + srclinebytes;
1175         dstbits = (char*)dstbits + dstlinebytes;
1176     }
1177 }
1178
1179 static void convert_0888_to_555_asis_src_byteswap(int width, int height,
1180                                                   const void* srcbits, int srclinebytes,
1181                                                   void* dstbits, int dstlinebytes)
1182 {
1183     const DWORD* srcpixel;
1184     WORD* dstpixel;
1185     int x,y;
1186
1187     for (y=0; y<height; y++) {
1188         srcpixel=srcbits;
1189         dstpixel=dstbits;
1190         for (x=0; x<width; x++) {
1191             DWORD srcval;
1192             srcval=*srcpixel++;
1193             *dstpixel++=((srcval >>  1) & 0x7c00) | /* h */
1194                         ((srcval >> 14) & 0x03e0) | /* g */
1195                         ((srcval >> 27) & 0x001f);  /* l */
1196         }
1197         srcbits = (const char*)srcbits + srclinebytes;
1198         dstbits = (char*)dstbits + dstlinebytes;
1199     }
1200 }
1201
1202 static void convert_0888_to_555_reverse_src_byteswap(int width, int height,
1203                                                      const void* srcbits, int srclinebytes,
1204                                                      void* dstbits, int dstlinebytes)
1205 {
1206     const DWORD* srcpixel;
1207     WORD* dstpixel;
1208     int x,y;
1209
1210     for (y=0; y<height; y++) {
1211         srcpixel=srcbits;
1212         dstpixel=dstbits;
1213         for (x=0; x<width; x++) {
1214             DWORD srcval;
1215             srcval=*srcpixel++;
1216             *dstpixel++=((srcval >> 11) & 0x001f) | /* h */
1217                         ((srcval >> 14) & 0x03e0) | /* g */
1218                         ((srcval >> 17) & 0x7c00);  /* l */
1219         }
1220         srcbits = (const char*)srcbits + srclinebytes;
1221         dstbits = (char*)dstbits + dstlinebytes;
1222     }
1223 }
1224
1225 static void convert_0888_to_565_asis_src_byteswap(int width, int height,
1226                                                   const void* srcbits, int srclinebytes,
1227                                                   void* dstbits, int dstlinebytes)
1228 {
1229     const DWORD* srcpixel;
1230     WORD* dstpixel;
1231     int x,y;
1232
1233     for (y=0; y<height; y++) {
1234         srcpixel=srcbits;
1235         dstpixel=dstbits;
1236         for (x=0; x<width; x++) {
1237             DWORD srcval;
1238             srcval=*srcpixel++;
1239             *dstpixel++=((srcval >>  0) & 0xf800) | /* h */
1240                         ((srcval >> 13) & 0x07e0) | /* g */
1241                         ((srcval >> 27) & 0x001f);  /* l */
1242         }
1243         srcbits = (const char*)srcbits + srclinebytes;
1244         dstbits = (char*)dstbits + dstlinebytes;
1245     }
1246 }
1247
1248 static void convert_0888_to_565_reverse_src_byteswap(int width, int height,
1249                                                      const void* srcbits, int srclinebytes,
1250                                                      void* dstbits, int dstlinebytes)
1251 {
1252     const DWORD* srcpixel;
1253     WORD* dstpixel;
1254     int x,y;
1255
1256     for (y=0; y<height; y++) {
1257         srcpixel=srcbits;
1258         dstpixel=dstbits;
1259         for (x=0; x<width; x++) {
1260             DWORD srcval;
1261             srcval=*srcpixel++;
1262             *dstpixel++=((srcval >> 11) & 0x001f) | /* h */
1263                         ((srcval >> 13) & 0x07e0) | /* g */
1264                         ((srcval >> 16) & 0xf800);  /* l */
1265         }
1266         srcbits = (const char*)srcbits + srclinebytes;
1267         dstbits = (char*)dstbits + dstlinebytes;
1268     }
1269 }
1270
1271 static void convert_any0888_to_5x5_src_byteswap(int width, int height,
1272                                                 const void* srcbits, int srclinebytes,
1273                                                 DWORD rsrc, DWORD gsrc, DWORD bsrc,
1274                                                 void* dstbits, int dstlinebytes,
1275                                                 WORD rdst, WORD gdst, WORD bdst)
1276 {
1277     int rRightShift,gRightShift,bRightShift;
1278     int rLeftShift,gLeftShift,bLeftShift;
1279     const DWORD* srcpixel;
1280     WORD* dstpixel;
1281     int x,y;
1282
1283     /* Here is how we proceed. Assume we have rsrc=0x0000ff00 and our pixel
1284      * contains 0x11223344.
1285      * - first we shift 0x11223344 right by rRightShift to bring the most
1286      *   significant bits of the red components in the bottom 5 (or 6) bits
1287      *   -> 0x4488c
1288      * - then we remove non red bits by anding with the modified rdst (0x1f)
1289      *   -> 0x0c
1290      * - finally shift these bits left by rLeftShift so that they end up in
1291      *   the right place
1292      *   -> 0x3000
1293      */
1294     rRightShift=X11DRV_DIB_MaskToShift(rsrc)+3;
1295     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1296     gRightShift+=(gdst==0x07e0?2:3);
1297     bRightShift=X11DRV_DIB_MaskToShift(bsrc)+3;
1298
1299     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1300     rdst=rdst >> rLeftShift;
1301     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1302     gdst=gdst >> gLeftShift;
1303     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1304     bdst=bdst >> bLeftShift;
1305
1306     for (y=0; y<height; y++) {
1307         srcpixel=srcbits;
1308         dstpixel=dstbits;
1309         for (x=0; x<width; x++) {
1310             DWORD srcval;
1311             srcval=*srcpixel++;
1312             FLIP_DWORD(&srcval);
1313             *dstpixel++=(((srcval >> rRightShift) & rdst) << rLeftShift) |
1314                         (((srcval >> gRightShift) & gdst) << gLeftShift) |
1315                         (((srcval >> bRightShift) & bdst) << bLeftShift);
1316         }
1317         srcbits = (const char*)srcbits + srclinebytes;
1318         dstbits = (char*)dstbits + dstlinebytes;
1319     }
1320 }
1321
1322 static void convert_0888_to_888_asis_src_byteswap(int width, int height,
1323                                                   const void* srcbits, int srclinebytes,
1324                                                   void* dstbits, int dstlinebytes)
1325 {
1326     const DWORD* srcpixel;
1327     DWORD* dstpixel;
1328     BYTE* dstbyte;
1329     int x,y;
1330     int oddwidth;
1331
1332     oddwidth=width & 3;
1333     width=width/4;
1334     for (y=0; y<height; y++) {
1335         srcpixel=srcbits;
1336         dstpixel=dstbits;
1337         for (x=0; x<width; x++) {
1338             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
1339             DWORD srcval1, srcval2;
1340             srcval1 = *srcpixel++;
1341             srcval2 = *srcpixel++;
1342             *dstpixel++= ((srcval1 >> 24) & 0x000000ff) | /* l1 */
1343                          ((srcval1 >>  8) & 0x0000ff00) | /* g1 */
1344                          ((srcval1 <<  8) & 0x00ff0000) | /* h1 */
1345                          ( srcval2        & 0xff000000);  /* l2 */
1346             srcval1 = *srcpixel++;
1347             *dstpixel++= ((srcval2 >> 16) & 0x000000ff) | /* g2 */
1348                          ( srcval2        & 0x0000ff00) | /* h2 */
1349                          ((srcval1 >>  8) & 0x00ff0000) | /* l3 */
1350                          ((srcval1 <<  8) & 0xff000000);  /* g3 */
1351             srcval2 = *srcpixel++;
1352             *dstpixel++= ((srcval1 >>  8) & 0x000000ff) | /* h3 */
1353                          ((srcval2 >> 16) & 0x0000ff00) | /* l4 */
1354                          ( srcval2        & 0x00ff0000) | /* g4 */
1355                          ((srcval2 << 16) & 0xff000000);  /* h4 */
1356         }
1357         /* And now up to 3 odd pixels */
1358         dstbyte=(BYTE*)dstpixel;
1359         for (x=0; x<oddwidth; x++) {
1360             DWORD srcval;
1361             srcval=*srcpixel++;
1362             FLIP_DWORD(&srcval);
1363             *((WORD*)dstbyte)=srcval;                   /* h, g */
1364             dstbyte+=sizeof(WORD);
1365             *dstbyte++=srcval >> 16;                    /* l */
1366         }
1367         srcbits = (const char*)srcbits + srclinebytes;
1368         dstbits = (char*)dstbits + dstlinebytes;
1369     }
1370 }
1371
1372 static void convert_0888_to_888_reverse_src_byteswap(int width, int height,
1373                                                      const void* srcbits, int srclinebytes,
1374                                                      void* dstbits, int dstlinebytes)
1375 {
1376     const DWORD* srcpixel;
1377     DWORD* dstpixel;
1378     BYTE* dstbyte;
1379     int x,y;
1380     int oddwidth;
1381
1382     oddwidth=width & 3;
1383     width=width/4;
1384     for (y=0; y<height; y++) {
1385         srcpixel=srcbits;
1386         dstpixel=dstbits;
1387         for (x=0; x<width; x++) {
1388             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
1389             DWORD srcval1,srcval2;
1390             srcval1=*srcpixel++;
1391             srcval2=    ((srcval1 >> 8 ) & 0x00ffffff); /* l1, g1, h1 */
1392             srcval1=*srcpixel++;
1393             *dstpixel++=srcval2 |
1394                         ((srcval1 << 16) & 0xff000000);  /* h2 */
1395             srcval2=    ((srcval1 >> 16) & 0x0000ffff);  /* l2, g2 */
1396             srcval1=*srcpixel++;
1397             *dstpixel++=srcval2 |
1398                         ((srcval1 <<  8) & 0xffff0000);  /* g3, h3 */
1399             srcval2=    ((srcval1 >> 24) & 0x000000ff);  /* l3 */
1400             srcval1=*srcpixel++;
1401             *dstpixel++=srcval2 |
1402                         srcval1;                         /* l4, g4, h4 */
1403         }
1404         /* And now up to 3 odd pixels */
1405         dstbyte=(BYTE*)dstpixel;
1406         for (x=0; x<oddwidth; x++) {
1407             DWORD srcval;
1408             srcval=*srcpixel++;
1409             *((WORD*)dstbyte)=((srcval >> 8) & 0xffff); /* g, h */
1410             dstbyte+=sizeof(WORD);
1411             *dstbyte++= srcval >> 24;                     /* l */
1412         }
1413         srcbits = (const char*)srcbits + srclinebytes;
1414         dstbits = (char*)dstbits + dstlinebytes;
1415     }
1416 }
1417
1418 static void convert_any0888_to_rgb888_src_byteswap(int width, int height,
1419                                                    const void* srcbits, int srclinebytes,
1420                                                    DWORD rsrc, DWORD gsrc, DWORD bsrc,
1421                                                    void* dstbits, int dstlinebytes)
1422 {
1423     int rRightShift,gRightShift,bRightShift;
1424     const DWORD* srcpixel;
1425     BYTE* dstpixel;
1426     int x,y;
1427
1428     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1429     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1430     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1431     for (y=0; y<height; y++) {
1432         srcpixel=srcbits;
1433         dstpixel=dstbits;
1434         for (x=0; x<width; x++) {
1435             DWORD srcval;
1436             srcval=*srcpixel++;
1437             FLIP_DWORD(&srcval);
1438             dstpixel[0]=(srcval >> bRightShift); /* b */
1439             dstpixel[1]=(srcval >> gRightShift); /* g */
1440             dstpixel[2]=(srcval >> rRightShift); /* r */
1441             dstpixel+=3;
1442         }
1443         srcbits = (const char*)srcbits + srclinebytes;
1444         dstbits = (char*)dstbits + dstlinebytes;
1445     }
1446 }
1447
1448 static void convert_any0888_to_bgr888_src_byteswap(int width, int height,
1449                                                    const void* srcbits, int srclinebytes,
1450                                                    DWORD rsrc, DWORD gsrc, DWORD bsrc,
1451                                                    void* dstbits, int dstlinebytes)
1452 {
1453     int rRightShift,gRightShift,bRightShift;
1454     const DWORD* srcpixel;
1455     BYTE* dstpixel;
1456     int x,y;
1457
1458     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1459     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1460     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1461     for (y=0; y<height; y++) {
1462         srcpixel=srcbits;
1463         dstpixel=dstbits;
1464         for (x=0; x<width; x++) {
1465             DWORD srcval;
1466             srcval=*srcpixel++;
1467             FLIP_DWORD(&srcval);
1468             dstpixel[0]=(srcval >> rRightShift); /* r */
1469             dstpixel[1]=(srcval >> gRightShift); /* g */
1470             dstpixel[2]=(srcval >> bRightShift); /* b */
1471             dstpixel+=3;
1472         }
1473         srcbits = (const char*)srcbits + srclinebytes;
1474         dstbits = (char*)dstbits + dstlinebytes;
1475     }
1476 }
1477
1478
1479 const dib_conversions dib_src_byteswap = {
1480     convert_5x5_asis_src_byteswap,
1481     convert_555_reverse_src_byteswap,
1482     convert_555_to_565_asis_src_byteswap,
1483     convert_555_to_565_reverse_src_byteswap,
1484     convert_555_to_888_asis_src_byteswap,
1485     convert_555_to_888_reverse_src_byteswap,
1486     convert_555_to_0888_asis_src_byteswap,
1487     convert_555_to_0888_reverse_src_byteswap,
1488     convert_5x5_to_any0888_src_byteswap,
1489     convert_565_reverse_src_byteswap,
1490     convert_565_to_555_asis_src_byteswap,
1491     convert_565_to_555_reverse_src_byteswap,
1492     convert_565_to_888_asis_src_byteswap,
1493     convert_565_to_888_reverse_src_byteswap,
1494     convert_565_to_0888_asis_src_byteswap,
1495     convert_565_to_0888_reverse_src_byteswap,
1496     convert_888_asis_src_byteswap,
1497     convert_888_reverse_src_byteswap,
1498     convert_888_to_555_asis_src_byteswap,
1499     convert_888_to_555_reverse_src_byteswap,
1500     convert_888_to_565_asis_src_byteswap,
1501     convert_888_to_565_reverse_src_byteswap,
1502     convert_888_to_0888_asis_src_byteswap,
1503     convert_888_to_0888_reverse_src_byteswap,
1504     convert_rgb888_to_any0888_src_byteswap,
1505     convert_bgr888_to_any0888_src_byteswap,
1506     convert_0888_asis_src_byteswap,
1507     convert_0888_reverse_src_byteswap,
1508     convert_0888_any_src_byteswap,
1509     convert_0888_to_555_asis_src_byteswap,
1510     convert_0888_to_555_reverse_src_byteswap,
1511     convert_0888_to_565_asis_src_byteswap,
1512     convert_0888_to_565_reverse_src_byteswap,
1513     convert_any0888_to_5x5_src_byteswap,
1514     convert_0888_to_888_asis_src_byteswap,
1515     convert_0888_to_888_reverse_src_byteswap,
1516     convert_any0888_to_rgb888_src_byteswap,
1517     convert_any0888_to_bgr888_src_byteswap
1518 };