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_DDBLTFAST(DWORD flagmask) {
  55     int i;
  56     const struct {
  57         DWORD   mask;
  58         char    *name;
  59     } flags[] = {
  60 #define FE(x) { x, #x},
  61         FE(DDBLTFAST_NOCOLORKEY)
  62         FE(DDBLTFAST_SRCCOLORKEY)
  63         FE(DDBLTFAST_DESTCOLORKEY)
  64         FE(DDBLTFAST_WAIT)
  65 #undef FE
  66     };
  67     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
  68         if (flags[i].mask & flagmask)
  69             DPRINTF("%s ",flags[i].name);
  70     DPRINTF("\n");
  71 }
  72
  73 void _dump_DDBLT(DWORD flagmask) {
  74     int i;
  75     const struct {
  76         DWORD   mask;
  77         char    *name;
  78     } flags[] = {
  79 #define FE(x) { x, #x},
  80         FE(DDBLT_ALPHADEST)
  81         FE(DDBLT_ALPHADESTCONSTOVERRIDE)
  82         FE(DDBLT_ALPHADESTNEG)
  83         FE(DDBLT_ALPHADESTSURFACEOVERRIDE)
  84         FE(DDBLT_ALPHAEDGEBLEND)
  85         FE(DDBLT_ALPHASRC)
  86         FE(DDBLT_ALPHASRCCONSTOVERRIDE)
  87         FE(DDBLT_ALPHASRCNEG)
  88         FE(DDBLT_ALPHASRCSURFACEOVERRIDE)
  89         FE(DDBLT_ASYNC)
  90         FE(DDBLT_COLORFILL)
  91         FE(DDBLT_DDFX)
  92         FE(DDBLT_DDROPS)
  93         FE(DDBLT_KEYDEST)
  94         FE(DDBLT_KEYDESTOVERRIDE)
  95         FE(DDBLT_KEYSRC)
  96         FE(DDBLT_KEYSRCOVERRIDE)
  97         FE(DDBLT_ROP)
  98         FE(DDBLT_ROTATIONANGLE)
  99         FE(DDBLT_ZBUFFER)
 100         FE(DDBLT_ZBUFFERDESTCONSTOVERRIDE)
 101         FE(DDBLT_ZBUFFERDESTOVERRIDE)
 102         FE(DDBLT_ZBUFFERSRCCONSTOVERRIDE)
 103         FE(DDBLT_ZBUFFERSRCOVERRIDE)
 104         FE(DDBLT_WAIT)
 105         FE(DDBLT_DEPTHFILL)
 106 #undef FE
 107     };
 108     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 109         if (flags[i].mask & flagmask)
 110             DPRINTF("%s ",flags[i].name);
 111     DPRINTF("\n");
 112 }
 113
 114 void _dump_DDSCAPS(void *in) {
 115     int i;
 116     const struct {
 117         DWORD   mask;
 118         char    *name;
 119     } flags[] = {
 120 #define FE(x) { x, #x},
 121         FE(DDSCAPS_RESERVED1)
 122         FE(DDSCAPS_ALPHA)
 123         FE(DDSCAPS_BACKBUFFER)
 124         FE(DDSCAPS_COMPLEX)
 125         FE(DDSCAPS_FLIP)
 126         FE(DDSCAPS_FRONTBUFFER)
 127         FE(DDSCAPS_OFFSCREENPLAIN)
 128         FE(DDSCAPS_OVERLAY)
 129         FE(DDSCAPS_PALETTE)
 130         FE(DDSCAPS_PRIMARYSURFACE)
 131         FE(DDSCAPS_PRIMARYSURFACELEFT)
 132         FE(DDSCAPS_SYSTEMMEMORY)
 133         FE(DDSCAPS_TEXTURE)
 134         FE(DDSCAPS_3DDEVICE)
 135         FE(DDSCAPS_VIDEOMEMORY)
 136         FE(DDSCAPS_VISIBLE)
 137         FE(DDSCAPS_WRITEONLY)
 138         FE(DDSCAPS_ZBUFFER)
 139         FE(DDSCAPS_OWNDC)
 140         FE(DDSCAPS_LIVEVIDEO)
 141         FE(DDSCAPS_HWCODEC)
 142         FE(DDSCAPS_MODEX)
 143         FE(DDSCAPS_MIPMAP)
 144         FE(DDSCAPS_RESERVED2)
 145         FE(DDSCAPS_ALLOCONLOAD)
 146         FE(DDSCAPS_VIDEOPORT)
 147         FE(DDSCAPS_LOCALVIDMEM)
 148         FE(DDSCAPS_NONLOCALVIDMEM)
 149         FE(DDSCAPS_STANDARDVGAMODE)
 150         FE(DDSCAPS_OPTIMIZED)
 151 #undef FE
 152     };
 153     DWORD flagmask = *((DWORD *) in);
 154     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 155         if (flags[i].mask & flagmask)
 156             DPRINTF("%s ",flags[i].name);
 157 }
 158
 159 void _dump_pixelformat_flag(DWORD flagmask) {
 160     int i;
 161     const struct {
 162         DWORD   mask;
 163         char    *name;
 164     } flags[] = {
 165 #define FE(x) { x, #x},
 166         FE(DDPF_ALPHAPIXELS)
 167         FE(DDPF_ALPHA)
 168         FE(DDPF_FOURCC)
 169         FE(DDPF_PALETTEINDEXED4)
 170         FE(DDPF_PALETTEINDEXEDTO8)
 171         FE(DDPF_PALETTEINDEXED8)
 172         FE(DDPF_RGB)
 173         FE(DDPF_COMPRESSED)
 174         FE(DDPF_RGBTOYUV)
 175         FE(DDPF_YUV)
 176         FE(DDPF_ZBUFFER)
 177         FE(DDPF_PALETTEINDEXED1)
 178         FE(DDPF_PALETTEINDEXED2)
 179         FE(DDPF_ZPIXELS)
 180 #undef FE
 181     };
 182     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 183         if (flags[i].mask & flagmask)
 184             DPRINTF("%s ",flags[i].name);
 185 }
 186
 187 void _dump_paletteformat(DWORD dwFlags) {
 188     int i;
 189     const struct {
 190         DWORD   mask;
 191         char    *name;
 192     } flags[] = {
 193 #define FE(x) { x, #x},
 194         FE(DDPCAPS_4BIT)
 195         FE(DDPCAPS_8BITENTRIES)
 196         FE(DDPCAPS_8BIT)
 197         FE(DDPCAPS_INITIALIZE)
 198         FE(DDPCAPS_PRIMARYSURFACE)
 199         FE(DDPCAPS_PRIMARYSURFACELEFT)
 200         FE(DDPCAPS_ALLOW256)
 201         FE(DDPCAPS_VSYNC)
 202         FE(DDPCAPS_1BIT)
 203         FE(DDPCAPS_2BIT)
 204         FE(DDPCAPS_ALPHA)
 205 #undef FE
 206     };
 207     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 208         if (flags[i].mask & dwFlags)
 209             DPRINTF("%s ",flags[i].name);
 210     DPRINTF("\n");
 211 }
 212
 213 void _dump_pixelformat(void *in) {
 214     LPDDPIXELFORMAT pf = (LPDDPIXELFORMAT) in;
 215
 216     DPRINTF("( ");
 217     _dump_pixelformat_flag(pf->dwFlags);
 218     if (pf->dwFlags & DDPF_FOURCC) {
 219         DPRINTF(", dwFourCC (%08lx) : %c%c%c%c",
 220                 pf->dwFourCC,
 221                 (unsigned char)( pf->dwFourCC     &0xff),
 222                 (unsigned char)((pf->dwFourCC>> 8)&0xff),
 223                 (unsigned char)((pf->dwFourCC>>16)&0xff),
 224                 (unsigned char)((pf->dwFourCC>>24)&0xff)
 225         );
 226     }
 227     if (pf->dwFlags & DDPF_RGB) {
 228         char *cmd;
 229         DPRINTF(", RGB bits: %ld, ", pf->u.dwRGBBitCount);
 230         switch (pf->u.dwRGBBitCount) {
 231         case 4: cmd = "%1lx"; break;
 232         case 8: cmd = "%02lx"; break;
 233         case 16: cmd = "%04lx"; break;
 234         case 24: cmd = "%06lx"; break;
 235         case 32: cmd = "%08lx"; break;
 236         default: ERR("Unexpected bit depth !\n"); cmd = "%d"; break;
 237         }
 238         DPRINTF(" R "); DPRINTF(cmd, pf->u1.dwRBitMask);
 239         DPRINTF(" G "); DPRINTF(cmd, pf->u2.dwGBitMask);
 240         DPRINTF(" B "); DPRINTF(cmd, pf->u3.dwBBitMask);
 241         if (pf->dwFlags & DDPF_ALPHAPIXELS) {
 242             DPRINTF(" A "); DPRINTF(cmd, pf->u4.dwRGBAlphaBitMask);
 243         }
 244         if (pf->dwFlags & DDPF_ZPIXELS) {
 245             DPRINTF(" Z "); DPRINTF(cmd, pf->u4.dwRGBZBitMask);
 246         }
 247     }
 248     if (pf->dwFlags & DDPF_ZBUFFER) {
 249         DPRINTF(", Z bits : %ld", pf->u.dwZBufferBitDepth);
 250     }
 251     if (pf->dwFlags & DDPF_ALPHA) {
 252         DPRINTF(", Alpha bits : %ld", pf->u.dwAlphaBitDepth);
 253     }
 254     DPRINTF(")");
 255 }
 256
 257 void _dump_colorkeyflag(DWORD ck) {
 258     int i;
 259     const struct {
 260         DWORD   mask;
 261         char    *name;
 262     } flags[] = {
 263 #define FE(x) { x, #x},
 264         FE(DDCKEY_COLORSPACE)
 265         FE(DDCKEY_DESTBLT)
 266         FE(DDCKEY_DESTOVERLAY)
 267         FE(DDCKEY_SRCBLT)
 268         FE(DDCKEY_SRCOVERLAY)
 269 #undef FE
 270     };
 271     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 272         if (flags[i].mask & ck)
 273             DPRINTF("%s ",flags[i].name);
 274 }
 275
 276 static void _dump_DWORD(void *in) {
 277     DPRINTF("%ld", *((DWORD *) in));
 278 }
 279 static void _dump_PTR(void *in) {
 280     DPRINTF("%p", *((void **) in));
 281 }
 282 void _dump_DDCOLORKEY(void *in) {
 283     DDCOLORKEY *ddck = (DDCOLORKEY *) in;
 284
 285     DPRINTF(" Low : %ld  - High : %ld", ddck->dwColorSpaceLowValue, ddck->dwColorSpaceHighValue);
 286 }
 287
 288 void _dump_surface_desc(DDSURFACEDESC *lpddsd) {
 289     int i;
 290     struct {
 291         DWORD   mask;
 292         char    *name;
 293         void (*func)(void *);
 294         void    *elt;
 295     } flags[16], *fe = flags;
 296 #define FE(x,f,e) do { fe->mask = x;  fe->name = #x; fe->func = f; fe->elt = (void *) &(lpddsd->e); fe++; } while(0)
 297         FE(DDSD_CAPS, _dump_DDSCAPS, ddsCaps);
 298         FE(DDSD_HEIGHT, _dump_DWORD, dwHeight);
 299         FE(DDSD_WIDTH, _dump_DWORD, dwWidth);
 300         FE(DDSD_PITCH, _dump_DWORD, lPitch);
 301         FE(DDSD_BACKBUFFERCOUNT, _dump_DWORD, dwBackBufferCount);
 302         FE(DDSD_ZBUFFERBITDEPTH, _dump_DWORD, u.dwZBufferBitDepth);
 303         FE(DDSD_ALPHABITDEPTH, _dump_DWORD, dwAlphaBitDepth);
 304         FE(DDSD_PIXELFORMAT, _dump_pixelformat, ddpfPixelFormat);
 305         FE(DDSD_CKDESTOVERLAY, _dump_DDCOLORKEY, ddckCKDestOverlay);
 306         FE(DDSD_CKDESTBLT, _dump_DDCOLORKEY, ddckCKDestBlt);
 307         FE(DDSD_CKSRCOVERLAY, _dump_DDCOLORKEY, ddckCKSrcOverlay);
 308         FE(DDSD_CKSRCBLT, _dump_DDCOLORKEY, ddckCKSrcBlt);
 309         FE(DDSD_MIPMAPCOUNT, _dump_DWORD, u.dwMipMapCount);
 310         FE(DDSD_REFRESHRATE, _dump_DWORD, u.dwRefreshRate);
 311         FE(DDSD_LINEARSIZE, _dump_DWORD, u1.dwLinearSize);
 312         FE(DDSD_LPSURFACE, _dump_PTR, u1.lpSurface);
 313 #undef FE
 314
 315     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 316         if (flags[i].mask & lpddsd->dwFlags) {
 317             DPRINTF(" - %s : ",flags[i].name);
 318             flags[i].func(flags[i].elt);
 319             DPRINTF("\n");
 320         }
 321 }
 322 void _dump_cooperativelevel(DWORD cooplevel) {
 323     int i;
 324     const struct {
 325         int     mask;
 326         char    *name;
 327     } flags[] = {
 328 #define FE(x) { x, #x},
 329             FE(DDSCL_FULLSCREEN)
 330             FE(DDSCL_ALLOWREBOOT)
 331             FE(DDSCL_NOWINDOWCHANGES)
 332             FE(DDSCL_NORMAL)
 333             FE(DDSCL_ALLOWMODEX)
 334             FE(DDSCL_EXCLUSIVE)
 335             FE(DDSCL_SETFOCUSWINDOW)
 336             FE(DDSCL_SETDEVICEWINDOW)
 337             FE(DDSCL_CREATEDEVICEWINDOW)
 338 #undef FE
 339     };
 340
 341     if (TRACE_ON(ddraw)) {
 342         DPRINTF(" - ");
 343         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 344             if (flags[i].mask & cooplevel)
 345                 DPRINTF("%s ",flags[i].name);
 346         DPRINTF("\n");
 347     }
 348 }