git.oblomov.eu Git - wine/blob - dlls/ddraw/helper.c

   1
   2 /*              DirectDraw Base Functions
   3  *
   4  * Copyright 1997-1999 Marcus Meissner
   5  * Copyright 1998 Lionel Ulmer (most of Direct3D stuff)
   6  */
   7
   8 #include "config.h"
   9
  10 #include <unistd.h>
  11 #include <assert.h>
  12 #include <fcntl.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16
  17 #include "winerror.h"
  18 #include "heap.h"
  19 #include "wine/exception.h"
  20 #include "ddraw.h"
  21 #include "d3d.h"
  22 #include "debugtools.h"
  23 #include "options.h"
  24
  25 DEFAULT_DEBUG_CHANNEL(ddraw);
  26
  27 /******************************************************************************
  28  *              debug output functions
  29  */
  30 void _dump_DDBLTFX(DWORD flagmask) {
  31     int i;
  32     const struct {
  33         DWORD   mask;
  34         char    *name;
  35     } flags[] = {
  36 #define FE(x) { x, #x},
  37         FE(DDBLTFX_ARITHSTRETCHY)
  38         FE(DDBLTFX_MIRRORLEFTRIGHT)
  39         FE(DDBLTFX_MIRRORUPDOWN)
  40         FE(DDBLTFX_NOTEARING)
  41         FE(DDBLTFX_ROTATE180)
  42         FE(DDBLTFX_ROTATE270)
  43         FE(DDBLTFX_ROTATE90)
  44         FE(DDBLTFX_ZBUFFERRANGE)
  45         FE(DDBLTFX_ZBUFFERBASEDEST)
  46 #undef FE
  47     };
  48     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
  49         if (flags[i].mask & flagmask)
  50             DPRINTF("%s ",flags[i].name);
  51     DPRINTF("\n");
  52 }
  53
  54 void _dump_DDOVERLAY(DWORD flagmask) {
  55     int i;
  56     const struct {
  57         DWORD   mask;
  58         char    *name;
  59     } flags[] = {
  60 #define FE(x) { x, #x},
  61         FE(DDOVER_ALPHADEST)
  62         FE(DDOVER_ALPHADESTCONSTOVERRIDE)
  63         FE(DDOVER_ALPHADESTNEG)
  64         FE(DDOVER_ALPHADESTSURFACEOVERRIDE)
  65         FE(DDOVER_ALPHAEDGEBLEND)
  66         FE(DDOVER_ALPHASRC)
  67         FE(DDOVER_ALPHASRCCONSTOVERRIDE)
  68         FE(DDOVER_ALPHASRCNEG)
  69         FE(DDOVER_ALPHASRCSURFACEOVERRIDE)
  70         FE(DDOVER_HIDE)
  71         FE(DDOVER_KEYDEST)
  72         FE(DDOVER_KEYDESTOVERRIDE)
  73         FE(DDOVER_KEYSRC)
  74         FE(DDOVER_KEYSRCOVERRIDE)
  75         FE(DDOVER_SHOW)
  76         FE(DDOVER_ADDDIRTYRECT)
  77         FE(DDOVER_REFRESHDIRTYRECTS)
  78         FE(DDOVER_REFRESHALL)
  79         FE(DDOVER_DDFX)
  80         FE(DDOVER_AUTOFLIP)
  81         FE(DDOVER_BOB)
  82         FE(DDOVER_OVERRIDEBOBWEAVE)
  83         FE(DDOVER_INTERLEAVED)
  84 #undef FE
  85     };
  86     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
  87         if (flags[i].mask & flagmask)
  88             DPRINTF("%s ",flags[i].name);
  89     DPRINTF("\n");
  90 }
  91
  92 void _dump_DDBLTFAST(DWORD flagmask) {
  93     int i;
  94     const struct {
  95         DWORD   mask;
  96         char    *name;
  97     } flags[] = {
  98 #define FE(x) { x, #x},
  99         FE(DDBLTFAST_NOCOLORKEY)
 100         FE(DDBLTFAST_SRCCOLORKEY)
 101         FE(DDBLTFAST_DESTCOLORKEY)
 102         FE(DDBLTFAST_WAIT)
 103 #undef FE
 104     };
 105     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 106         if (flags[i].mask & flagmask)
 107             DPRINTF("%s ",flags[i].name);
 108     DPRINTF("\n");
 109 }
 110
 111 void _dump_DDBLT(DWORD flagmask) {
 112     int i;
 113     const struct {
 114         DWORD   mask;
 115         char    *name;
 116     } flags[] = {
 117 #define FE(x) { x, #x},
 118         FE(DDBLT_ALPHADEST)
 119         FE(DDBLT_ALPHADESTCONSTOVERRIDE)
 120         FE(DDBLT_ALPHADESTNEG)
 121         FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
 122         FE(DDBLT_ALPHAEDGEBLEND)
 123         FE(DDBLT_ALPHASRC)
 124         FE(DDBLT_ALPHASRCCONSTOVERRIDE)
 125         FE(DDBLT_ALPHASRCNEG)
 126         FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
 127         FE(DDBLT_ASYNC)
 128         FE(DDBLT_COLORFILL)
 129         FE(DDBLT_DDFX)
 130         FE(DDBLT_DDROPS)
 131         FE(DDBLT_KEYDEST)
 132         FE(DDBLT_KEYDESTOVERRIDE)
 133         FE(DDBLT_KEYSRC)
 134         FE(DDBLT_KEYSRCOVERRIDE)
 135         FE(DDBLT_ROP)
 136         FE(DDBLT_ROTATIONANGLE)
 137         FE(DDBLT_ZBUFFER)
 138         FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
 139         FE(DDBLT_ZBUFFERDESTOVERRIDE)
 140         FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
 141         FE(DDBLT_ZBUFFERSRCOVERRIDE)
 142         FE(DDBLT_WAIT)
 143         FE(DDBLT_DEPTHFILL)
 144 #undef FE
 145     };
 146     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 147         if (flags[i].mask & flagmask)
 148             DPRINTF("%s ",flags[i].name);
 149     DPRINTF("\n");
 150 }
 151
 152 void _dump_DDSCAPS(void *in) {
 153     int i;
 154     const struct {
 155         DWORD   mask;
 156         char    *name;
 157     } flags[] = {
 158 #define FE(x) { x, #x},
 159         FE(DDSCAPS_RESERVED1)
 160         FE(DDSCAPS_ALPHA)
 161         FE(DDSCAPS_BACKBUFFER)
 162         FE(DDSCAPS_COMPLEX)
 163         FE(DDSCAPS_FLIP)
 164         FE(DDSCAPS_FRONTBUFFER)
 165         FE(DDSCAPS_OFFSCREENPLAIN)
 166         FE(DDSCAPS_OVERLAY)
 167         FE(DDSCAPS_PALETTE)
 168         FE(DDSCAPS_PRIMARYSURFACE)
 169         FE(DDSCAPS_PRIMARYSURFACELEFT)
 170         FE(DDSCAPS_SYSTEMMEMORY)
 171         FE(DDSCAPS_TEXTURE)
 172         FE(DDSCAPS_3DDEVICE)
 173         FE(DDSCAPS_VIDEOMEMORY)
 174         FE(DDSCAPS_VISIBLE)
 175         FE(DDSCAPS_WRITEONLY)
 176         FE(DDSCAPS_ZBUFFER)
 177         FE(DDSCAPS_OWNDC)
 178         FE(DDSCAPS_LIVEVIDEO)
 179         FE(DDSCAPS_HWCODEC)
 180         FE(DDSCAPS_MODEX)
 181         FE(DDSCAPS_MIPMAP)
 182         FE(DDSCAPS_RESERVED2)
 183         FE(DDSCAPS_ALLOCONLOAD)
 184         FE(DDSCAPS_VIDEOPORT)
 185         FE(DDSCAPS_LOCALVIDMEM)
 186         FE(DDSCAPS_NONLOCALVIDMEM)
 187         FE(DDSCAPS_STANDARDVGAMODE)
 188         FE(DDSCAPS_OPTIMIZED)
 189 #undef FE
 190     };
 191     DWORD flagmask = *((DWORD *) in);
 192     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 193         if (flags[i].mask & flagmask)
 194             DPRINTF("%s ",flags[i].name);
 195 }
 196
 197 void _dump_pixelformat_flag(DWORD flagmask) {
 198     int i;
 199     const struct {
 200         DWORD   mask;
 201         char    *name;
 202     } flags[] = {
 203 #define FE(x) { x, #x},
 204         FE(DDPF_ALPHAPIXELS)
 205         FE(DDPF_ALPHA)
 206         FE(DDPF_FOURCC)
 207         FE(DDPF_PALETTEINDEXED4)
 208         FE(DDPF_PALETTEINDEXEDTO8)
 209         FE(DDPF_PALETTEINDEXED8)
 210         FE(DDPF_RGB)
 211         FE(DDPF_COMPRESSED)
 212         FE(DDPF_RGBTOYUV)
 213         FE(DDPF_YUV)
 214         FE(DDPF_ZBUFFER)
 215         FE(DDPF_PALETTEINDEXED1)
 216         FE(DDPF_PALETTEINDEXED2)
 217         FE(DDPF_ZPIXELS)
 218 #undef FE
 219     };
 220     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 221         if (flags[i].mask & flagmask)
 222             DPRINTF("%s ",flags[i].name);
 223 }
 224
 225 void _dump_paletteformat(DWORD dwFlags) {
 226     int i;
 227     const struct {
 228         DWORD   mask;
 229         char    *name;
 230     } flags[] = {
 231 #define FE(x) { x, #x},
 232         FE(DDPCAPS_4BIT)
 233         FE(DDPCAPS_8BITENTRIES)
 234         FE(DDPCAPS_8BIT)
 235         FE(DDPCAPS_INITIALIZE)
 236         FE(DDPCAPS_PRIMARYSURFACE)
 237         FE(DDPCAPS_PRIMARYSURFACELEFT)
 238         FE(DDPCAPS_ALLOW256)
 239         FE(DDPCAPS_VSYNC)
 240         FE(DDPCAPS_1BIT)
 241         FE(DDPCAPS_2BIT)
 242         FE(DDPCAPS_ALPHA)
 243 #undef FE
 244     };
 245     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 246         if (flags[i].mask & dwFlags)
 247             DPRINTF("%s ",flags[i].name);
 248     DPRINTF("\n");
 249 }
 250
 251 void _dump_pixelformat(void *in) {
 252     LPDDPIXELFORMAT pf = (LPDDPIXELFORMAT) in;
 253
 254     DPRINTF("( ");
 255     _dump_pixelformat_flag(pf->dwFlags);
 256     if (pf->dwFlags & DDPF_FOURCC) {
 257         DPRINTF(", dwFourCC code '%c%c%c%c' (0x%08lx) - %ld bits per pixel",
 258                 (unsigned char)( pf->dwFourCC     &0xff),
 259                 (unsigned char)((pf->dwFourCC>> 8)&0xff),
 260                 (unsigned char)((pf->dwFourCC>>16)&0xff),
 261                 (unsigned char)((pf->dwFourCC>>24)&0xff),
 262                 pf->dwFourCC,
 263                 pf->u.dwYUVBitCount
 264         );
 265     }
 266     if (pf->dwFlags & DDPF_RGB) {
 267         char *cmd;
 268         DPRINTF(", RGB bits: %ld, ", pf->u.dwRGBBitCount);
 269         switch (pf->u.dwRGBBitCount) {
 270         case 4: cmd = "%1lx"; break;
 271         case 8: cmd = "%02lx"; break;
 272         case 16: cmd = "%04lx"; break;
 273         case 24: cmd = "%06lx"; break;
 274         case 32: cmd = "%08lx"; break;
 275         default: ERR("Unexpected bit depth !\n"); cmd = "%d"; break;
 276         }
 277         DPRINTF(" R "); DPRINTF(cmd, pf->u1.dwRBitMask);
 278         DPRINTF(" G "); DPRINTF(cmd, pf->u2.dwGBitMask);
 279         DPRINTF(" B "); DPRINTF(cmd, pf->u3.dwBBitMask);
 280         if (pf->dwFlags & DDPF_ALPHAPIXELS) {
 281             DPRINTF(" A "); DPRINTF(cmd, pf->u4.dwRGBAlphaBitMask);
 282         }
 283         if (pf->dwFlags & DDPF_ZPIXELS) {
 284             DPRINTF(" Z "); DPRINTF(cmd, pf->u4.dwRGBZBitMask);
 285         }
 286     }
 287     if (pf->dwFlags & DDPF_ZBUFFER) {
 288         DPRINTF(", Z bits : %ld", pf->u.dwZBufferBitDepth);
 289     }
 290     if (pf->dwFlags & DDPF_ALPHA) {
 291         DPRINTF(", Alpha bits : %ld", pf->u.dwAlphaBitDepth);
 292     }
 293     DPRINTF(")");
 294 }
 295
 296 void _dump_colorkeyflag(DWORD ck) {
 297     int i;
 298     const struct {
 299         DWORD   mask;
 300         char    *name;
 301     } flags[] = {
 302 #define FE(x) { x, #x},
 303         FE(DDCKEY_COLORSPACE)
 304         FE(DDCKEY_DESTBLT)
 305         FE(DDCKEY_DESTOVERLAY)
 306         FE(DDCKEY_SRCBLT)
 307         FE(DDCKEY_SRCOVERLAY)
 308 #undef FE
 309     };
 310     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 311         if (flags[i].mask & ck)
 312             DPRINTF("%s ",flags[i].name);
 313 }
 314
 315 static void _dump_DWORD(void *in) {
 316     DPRINTF("%ld", *((DWORD *) in));
 317 }
 318 static void _dump_PTR(void *in) {
 319     DPRINTF("%p", *((void **) in));
 320 }
 321 void _dump_DDCOLORKEY(void *in) {
 322     DDCOLORKEY *ddck = (DDCOLORKEY *) in;
 323
 324     DPRINTF(" Low : %ld  - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
 325 }
 326
 327 void _dump_surface_desc(DDSURFACEDESC *lpddsd) {
 328     int i;
 329     struct {
 330         DWORD   mask;
 331         char    *name;
 332         void (*func)(void *);
 333         void    *elt;
 334     } flags[16], *fe = flags;
 335 #define FE(x,f,e) do { fe->mask = x;  fe->name = #x; fe->func = f; fe->elt = (void *) &(lpddsd->e); fe++; } while(0)
 336         FE(DDSD_CAPS, _dump_DDSCAPS, ddsCaps);
 337         FE(DDSD_HEIGHT, _dump_DWORD, dwHeight);
 338         FE(DDSD_WIDTH, _dump_DWORD, dwWidth);
 339         FE(DDSD_PITCH, _dump_DWORD, lPitch);
 340         FE(DDSD_BACKBUFFERCOUNT, _dump_DWORD, dwBackBufferCount);
 341         FE(DDSD_ZBUFFERBITDEPTH, _dump_DWORD, u.dwZBufferBitDepth);
 342         FE(DDSD_ALPHABITDEPTH, _dump_DWORD, dwAlphaBitDepth);
 343         FE(DDSD_PIXELFORMAT, _dump_pixelformat, ddpfPixelFormat);
 344         FE(DDSD_CKDESTOVERLAY, _dump_DDCOLORKEY, ddckCKDestOverlay);
 345         FE(DDSD_CKDESTBLT, _dump_DDCOLORKEY, ddckCKDestBlt);
 346         FE(DDSD_CKSRCOVERLAY, _dump_DDCOLORKEY, ddckCKSrcOverlay);
 347         FE(DDSD_CKSRCBLT, _dump_DDCOLORKEY, ddckCKSrcBlt);
 348         FE(DDSD_MIPMAPCOUNT, _dump_DWORD, u.dwMipMapCount);
 349         FE(DDSD_REFRESHRATE, _dump_DWORD, u.dwRefreshRate);
 350         FE(DDSD_LINEARSIZE, _dump_DWORD, u1.dwLinearSize);
 351         FE(DDSD_LPSURFACE, _dump_PTR, u1.lpSurface);
 352 #undef FE
 353
 354     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 355         if (flags[i].mask & lpddsd->dwFlags) {
 356             DPRINTF(" - %s : ",flags[i].name);
 357             flags[i].func(flags[i].elt);
 358             DPRINTF("\n");
 359         }
 360 }
 361 void _dump_cooperativelevel(DWORD cooplevel) {
 362     int i;
 363     const struct {
 364         int     mask;
 365         char    *name;
 366     } flags[] = {
 367 #define FE(x) { x, #x},
 368             FE(DDSCL_FULLSCREEN)
 369             FE(DDSCL_ALLOWREBOOT)
 370             FE(DDSCL_NOWINDOWCHANGES)
 371             FE(DDSCL_NORMAL)
 372             FE(DDSCL_ALLOWMODEX)
 373             FE(DDSCL_EXCLUSIVE)
 374             FE(DDSCL_SETFOCUSWINDOW)
 375             FE(DDSCL_SETDEVICEWINDOW)
 376             FE(DDSCL_CREATEDEVICEWINDOW)
 377 #undef FE
 378     };
 379
 380     if (TRACE_ON(ddraw)) {
 381         DPRINTF(" - ");
 382         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 383             if (flags[i].mask & cooplevel)
 384                 DPRINTF("%s ",flags[i].name);
 385         DPRINTF("\n");
 386     }
 387 }