git.oblomov.eu Git - wine/blob - objects/bitblt.c

   1 /*
   2  * GDI bit-blit operations
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  */
   6
   7 static char Copyright[] = "Copyright  Alexandre Julliard, 1993";
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <X11/Xlib.h>
  12 #include <X11/Intrinsic.h>
  13
  14 #include "gdi.h"
  15 #include "metafile.h"
  16
  17 extern const int DC_XROPfunction[];
  18
  19 #define MIN(a,b) ((a) < (b) ? (a) : (b))
  20 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  21
  22
  23 /***********************************************************************
  24  *           PatBlt    (GDI.29)
  25  */
  26 BOOL PatBlt( HDC hdc, short left, short top,
  27              short width, short height, DWORD rop)
  28 {
  29     int x1, x2, y1, y2;
  30
  31     DC * dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
  32     if (!dc)
  33     {
  34         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
  35         if (!dc) return FALSE;
  36         MF_MetaParam6(dc, META_PATBLT, left, top, width, height,
  37                       HIWORD(rop), LOWORD(rop));
  38         return TRUE;
  39     }
  40
  41 #ifdef DEBUG_GDI
  42     printf( "PatBlt: %d %d,%d %dx%d %06x\n",
  43             hdc, left, top, width, height, rop );
  44 #endif
  45
  46     rop >>= 16;
  47     if (!DC_SetupGCForBrush( dc )) rop &= 0x0f;
  48     else rop = (rop & 0x03) | ((rop >> 4) & 0x0c);
  49     XSetFunction( XT_display, dc->u.x.gc, DC_XROPfunction[rop] );
  50
  51     x1 = dc->w.DCOrgX + XLPTODP( dc, left );
  52     x2 = dc->w.DCOrgX + XLPTODP( dc, left + width );
  53     y1 = dc->w.DCOrgY + YLPTODP( dc, top );
  54     y2 = dc->w.DCOrgY + YLPTODP( dc, top + height );
  55     XFillRectangle( XT_display, dc->u.x.drawable, dc->u.x.gc,
  56                    MIN(x1,x2), MIN(y1,y2), abs(x2-x1), abs(y2-y1) );
  57     return TRUE;
  58 }
  59
  60
  61 /***********************************************************************
  62  *           BitBlt    (GDI.34)
  63  */
  64 BOOL BitBlt( HDC hdcDest, short xDest, short yDest, short width, short height,
  65              HDC hdcSrc, short xSrc, short ySrc, DWORD rop )
  66 {
  67     int xs1, xs2, ys1, ys2;
  68     int xd1, xd2, yd1, yd2;
  69     DC *dcDest, *dcSrc;
  70
  71 #ifdef DEBUG_GDI
  72     printf( "BitBlt: %d %d,%d %dx%d %d %d,%d %08x\n",
  73            hdcDest, xDest, yDest, width, height, hdcSrc, xSrc, ySrc, rop );
  74 #endif
  75         if (width == 0 || height == 0) return FALSE;
  76     if ((rop & 0xcc0000) == ((rop & 0x330000) << 2))
  77         return PatBlt( hdcDest, xDest, yDest, width, height, rop );
  78
  79     rop >>= 16;
  80     if ((rop & 0x0f) != (rop >> 4))
  81     {
  82         printf( "BitBlt: Unimplemented ROP %02x\n", rop );
  83         return FALSE;
  84     }
  85
  86     dcDest = (DC *) GDI_GetObjPtr( hdcDest, DC_MAGIC );
  87     if (!dcDest) return FALSE;
  88     dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
  89     if (!dcSrc) return FALSE;
  90
  91     xs1 = dcSrc->w.DCOrgX + XLPTODP( dcSrc, xSrc );
  92     xs2 = dcSrc->w.DCOrgX + XLPTODP( dcSrc, xSrc + width );
  93     ys1 = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc );
  94     ys2 = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc + height );
  95     xd1 = dcDest->w.DCOrgX + XLPTODP( dcDest, xDest );
  96     xd2 = dcDest->w.DCOrgX + XLPTODP( dcDest, xDest + width );
  97     yd1 = dcDest->w.DCOrgY + YLPTODP( dcDest, yDest );
  98     yd2 = dcDest->w.DCOrgY + YLPTODP( dcDest, yDest + height );
  99
 100     if ((abs(xs2-xs1) != abs(xd2-xd1)) || (abs(ys2-ys1) != abs(yd2-yd1)))
 101         return FALSE;  /* Should call StretchBlt here */
 102
 103     DC_SetupGCForText( dcDest );
 104     XSetFunction( XT_display, dcDest->u.x.gc, DC_XROPfunction[rop & 0x0f] );
 105     if (dcSrc->w.bitsPerPixel == dcDest->w.bitsPerPixel)
 106     {
 107         XCopyArea( XT_display, dcSrc->u.x.drawable,
 108                    dcDest->u.x.drawable, dcDest->u.x.gc,
 109                    MIN(xs1,xs2), MIN(ys1,ys2), abs(xs2-xs1), abs(ys2-ys1),
 110                    MIN(xd1,xd2), MIN(yd1,yd2) );
 111     }
 112     else
 113     {
 114         if (dcSrc->w.bitsPerPixel != 1) return FALSE;
 115         XCopyPlane( XT_display, dcSrc->u.x.drawable,
 116                     dcDest->u.x.drawable, dcDest->u.x.gc,
 117                     MIN(xs1,xs2), MIN(ys1,ys2), abs(xs2-xs1), abs(ys2-ys1),
 118                     MIN(xd1,xd2), MIN(yd1,yd2), 1 );
 119     }
 120     return TRUE;
 121 }
 122
 123
 124
 125 /***********************************************************************
 126  *           black on white stretch -- favors color pixels over white
 127  *
 128  */
 129 static void bonw_stretch(XImage *sxi, XImage *dxi,
 130         short widthSrc, short heightSrc, short widthDest, short heightDest)
 131 {
 132     float deltax, deltay, sourcex, sourcey, oldsourcex, oldsourcey;
 133     register int x, y;
 134     Pixel whitep;
 135     int totalx, totaly, xavgwhite, yavgwhite;
 136     register int i;
 137     int endx, endy;
 138
 139     deltax = (float)widthSrc/widthDest;
 140     deltay = (float)heightSrc/heightDest;
 141     whitep  = WhitePixel(display, DefaultScreen(display));
 142
 143     oldsourcex = 0;
 144     for (x=0, sourcex=0.0; x<widthDest;
 145                         x++, oldsourcex=sourcex, sourcex+=deltax) {
 146         xavgwhite = 0;
 147         if (deltax > 1.0) {
 148             totalx = 0;
 149             endx = (int)sourcex;
 150             for (i=(int)oldsourcex; i<=endx; i++)
 151                 if (XGetPixel(sxi, i, (int)sourcey) == whitep)
 152                     totalx++;
 153             xavgwhite = (totalx > (int)(deltax / 2.0));
 154         } else {
 155             xavgwhite = 0;
 156         }
 157
 158         oldsourcey = 0;
 159         for (y=0, sourcey=0.0; y<heightDest;
 160                                 y++, oldsourcey=sourcey, sourcey+=deltay) {
 161             yavgwhite = 0;
 162             if (deltay > 1.0) {
 163                 totaly = 0;
 164                 endy = (int)sourcey;
 165                 for (i=(int)oldsourcey; i<=endy; i++)
 166                     if (XGetPixel(sxi, (int)sourcex, i) == whitep)
 167                         totaly++;
 168                 yavgwhite = (totaly > ((int)deltay / 2));
 169             } else {
 170                 yavgwhite = 0;
 171             }
 172             if (xavgwhite && yavgwhite)
 173                 XPutPixel(dxi, x, y, whitep);
 174             else
 175                 XPutPixel(dxi, x, y, XGetPixel(sxi, (int)sourcex, (int)sourcey));
 176
 177         } /* for all y in dest */
 178     } /* for all x in dest */
 179
 180 }
 181
 182 /***********************************************************************
 183  *           white on black stretch -- favors color pixels over black
 184  *
 185  */
 186 static void wonb_stretch(XImage *sxi, XImage *dxi,
 187         short widthSrc, short heightSrc, short widthDest, short heightDest)
 188 {
 189     float deltax, deltay, sourcex, sourcey, oldsourcex, oldsourcey;
 190     register int x, y;
 191     Pixel blackp;
 192     int totalx, totaly, xavgblack, yavgblack;
 193     register int i;
 194     int endx, endy;
 195
 196     deltax = (float)widthSrc/widthDest;
 197     deltay = (float)heightSrc/heightDest;
 198     blackp  = WhitePixel(display, DefaultScreen(display));
 199
 200     oldsourcex = 0;
 201     for (x=0, sourcex=0.0; x<widthDest;
 202                         x++, oldsourcex=sourcex, sourcex+=deltax) {
 203         xavgblack = 0;
 204         if (deltax > 1.0) {
 205             totalx = 0;
 206             endx = (int)sourcex;
 207             for (i=(int)oldsourcex; i<=endx; i++)
 208                 if (XGetPixel(sxi, i, (int)sourcey) == blackp)
 209                     totalx++;
 210             xavgblack = (totalx > (int)(deltax / 2.0));
 211         } else {
 212             xavgblack = 0;
 213         }
 214
 215         oldsourcey = 0;
 216         for (y=0, sourcey=0.0; y<heightDest;
 217                                 y++, oldsourcey=sourcey, sourcey+=deltay) {
 218             yavgblack = 0;
 219             if (deltay > 1.0) {
 220                 totaly = 0;
 221                 endy = (int)sourcey;
 222                 for (i=(int)oldsourcey; i<=endy; i++)
 223                     if (XGetPixel(sxi, (int)sourcex, i) == blackp)
 224                         totaly++;
 225                 yavgblack = (totaly > ((int)deltay / 2));
 226             } else {
 227                 yavgblack = 0;
 228             }
 229             if (xavgblack && yavgblack)
 230                 XPutPixel(dxi, x, y, blackp);
 231             else
 232                 XPutPixel(dxi, x, y, XGetPixel(sxi, (int)sourcex, (int)sourcey));
 233
 234         } /* for all y in dest */
 235     } /* for all x in dest */
 236 }
 237
 238 /* We use the 32-bit to 64-bit multiply and 64-bit to 32-bit divide of the */
 239 /* 386 (which gcc doesn't know well enough) to efficiently perform integer */
 240 /* scaling without having to worry about overflows. */
 241
 242 /* ##### muldiv64() borrowed from svgalib 1.03 ##### */
 243 static inline int muldiv64( int m1, int m2, int d )
 244 {
 245         /* int32 * int32 -> int64 / int32 -> int32 */
 246 #ifdef i386
 247         int result;
 248         __asm__(
 249                 "imull %%edx\n\t"
 250                 "idivl %3\n\t"
 251                 : "=a" (result)                 /* out */
 252                 : "a" (m1), "d" (m2), "g" (d)   /* in */
 253                 : "ax", "dx"                    /* mod */
 254         );
 255         return result;
 256 #else
 257         return m1 * m2 / d;
 258 #endif
 259 }
 260
 261 /***********************************************************************
 262  *          color stretch -- deletes unused pixels
 263  *
 264  */
 265 static void color_stretch(XImage *sxi, XImage *dxi,
 266         short widthSrc, short heightSrc, short widthDest, short heightDest)
 267 {
 268         register int x, y, sx, sy, xfactor, yfactor;
 269
 270         xfactor = muldiv64(widthSrc, 65536, widthDest);
 271         yfactor = muldiv64(heightSrc, 65536, heightDest);
 272
 273         sy = 0;
 274
 275         for (y = 0; y < heightDest;)
 276         {
 277                 int sourcey = sy >> 16;
 278                 sx = 0;
 279                 for (x = 0; x < widthDest; x++) {
 280                         XPutPixel(dxi, x, y, XGetPixel(sxi, sx >> 16, sourcey));
 281                         sx += xfactor;
 282                 }
 283                 y++;
 284                 while (y < heightDest) {
 285                         int py;
 286
 287                         sourcey = sy >> 16;
 288                         sy += yfactor;
 289
 290                         if ((sy >> 16) != sourcey)
 291                                 break;
 292
 293                         /* vertical stretch => copy previous line */
 294
 295                         py = y - 1;
 296
 297                         for (x = 0; x < widthDest; x++)
 298                                 XPutPixel(dxi, x, y, XGetPixel(dxi, x, py));
 299                         y++;
 300                 }
 301         }
 302 }
 303
 304 /***********************************************************************
 305  *           StretchBlt    (GDI.35)
 306  *
 307  *      o StretchBlt is CPU intensive so we only call it if we have
 308  *        to.  Checks are made to see if we can call BitBlt instead.
 309  *
 310  *      o the stretching is slowish, some integer interpolation would
 311  *        speed it up.
 312  *
 313  *      o only black on white and color copy have been tested
 314  */
 315 BOOL StretchBlt( HDC hdcDest, short xDest, short yDest, short widthDest, short heightDest,
 316                HDC hdcSrc, short xSrc, short ySrc, short widthSrc, short heightSrc, DWORD rop )
 317 {
 318     int xs1, xs2, ys1, ys2;
 319     int xd1, xd2, yd1, yd2;
 320     DC *dcDest, *dcSrc;
 321     XImage *sxi, *dxi;
 322     WORD stretchmode;
 323         BOOL    flg;
 324
 325 #ifdef DEBUG_GDI
 326     fprintf(stderr, "StretchBlt: %d %d,%d %dx%d %d %d,%d %dx%d %08x\n",
 327            hdcDest, xDest, yDest, widthDest, heightDest, hdcSrc, xSrc,
 328            ySrc, widthSrc, heightSrc, rop );
 329     printf("StretchMode is %x\n",
 330            ((DC *)GDI_GetObjPtr(hdcDest, DC_MAGIC))->w.stretchBltMode);
 331 #endif
 332
 333         if (widthDest == 0 || heightDest == 0) return FALSE;
 334         if (widthSrc == 0 || heightSrc == 0) return FALSE;
 335     if ((rop & 0xcc0000) == ((rop & 0x330000) << 2))
 336         return PatBlt( hdcDest, xDest, yDest, widthDest, heightDest, rop );
 337
 338     /* don't stretch the bitmap unless we have to; if we don't,
 339      * call BitBlt for a performance boost
 340      */
 341
 342     if (widthSrc == widthDest && heightSrc == heightDest) {
 343         return BitBlt(hdcDest, xDest, yDest, widthSrc, heightSrc,
 344                hdcSrc, xSrc, ySrc, rop);
 345     }
 346
 347     rop >>= 16;
 348     if ((rop & 0x0f) != (rop >> 4))
 349     {
 350         printf( "StretchBlt: Unimplemented ROP %02x\n", rop );
 351         return FALSE;
 352     }
 353
 354     dcDest = (DC *) GDI_GetObjPtr( hdcDest, DC_MAGIC );
 355     if (!dcDest) return FALSE;
 356     dcSrc = (DC *) GDI_GetObjPtr( hdcSrc, DC_MAGIC );
 357     if (!dcSrc) return FALSE;
 358
 359     xs1 = dcSrc->w.DCOrgX + XLPTODP( dcSrc, xSrc );
 360     xs2 = dcSrc->w.DCOrgX + XLPTODP( dcSrc, xSrc + widthSrc );
 361     ys1 = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc );
 362     ys2 = dcSrc->w.DCOrgY + YLPTODP( dcSrc, ySrc + heightSrc );
 363     xd1 = dcDest->w.DCOrgX + XLPTODP( dcDest, xDest );
 364     xd2 = dcDest->w.DCOrgX + XLPTODP( dcDest, xDest + widthDest );
 365     yd1 = dcDest->w.DCOrgY + YLPTODP( dcDest, yDest );
 366     yd2 = dcDest->w.DCOrgY + YLPTODP( dcDest, yDest + heightDest );
 367
 368
 369     /* get a source and destination image so we can manipulate
 370      * the pixels
 371      */
 372
 373     sxi = XGetImage(display, dcSrc->u.x.drawable, xs1, ys1,
 374              widthSrc, heightSrc, AllPlanes, ZPixmap);
 375     dxi = XCreateImage(display, DefaultVisualOfScreen(screen),
 376                             screenDepth, ZPixmap,
 377                             0, NULL, widthDest, heightDest,
 378                             32, 0);
 379     dxi->data = malloc(dxi->bytes_per_line * heightDest);
 380
 381     stretchmode = ((DC *)GDI_GetObjPtr(hdcDest, DC_MAGIC))->w.stretchBltMode;
 382
 383      /* the actual stretching is done here, we'll try to use
 384       * some interolation to get some speed out of it in
 385       * the future
 386       */
 387
 388     switch (stretchmode) {
 389         case BLACKONWHITE:
 390                 color_stretch(sxi, dxi, widthSrc, heightSrc,
 391                                 widthDest, heightDest);
 392 /*              bonw_stretch(sxi, dxi, widthSrc, heightSrc,
 393                                 widthDest, heightDest);
 394 */              break;
 395         case WHITEONBLACK:
 396                 color_stretch(sxi, dxi, widthSrc, heightSrc,
 397                                 widthDest, heightDest);
 398 /*              wonb_stretch(sxi, dxi, widthSrc, heightSrc,
 399                                 widthDest, heightDest);
 400 */              break;
 401         case COLORONCOLOR:
 402                 color_stretch(sxi, dxi, widthSrc, heightSrc,
 403                                 widthDest, heightDest);
 404                 break;
 405         default:
 406                 fprintf(stderr, "StretchBlt: unknown stretchmode '%d'\n",
 407                         stretchmode);
 408                 break;
 409     }
 410
 411     DC_SetupGCForText(dcDest);
 412     XSetFunction(display, dcDest->u.x.gc, DC_XROPfunction[rop & 0x0f]);
 413     XPutImage(display, dcDest->u.x.drawable, dcDest->u.x.gc,
 414                 dxi, 0, 0, MIN(xd1,xd2), MIN(yd1,yd2),
 415                 widthDest, heightDest);
 416
 417     /* now free the images we created */
 418
 419     XDestroyImage(sxi);
 420     XDestroyImage(dxi);
 421
 422     return TRUE;
 423 }
 424