Changeset 1568 for trunk/src


Ignore:
Timestamp:
Nov 2, 1999, 11:41:23 PM (26 years ago)
Author:
hugh
Message:

Changed dprintf to add DDRAW: at start of a entry
Also copied framebuffer for solid blits to the prinmary surface
Red Alert Map editor does work now ;)

Location:
trunk/src/ddraw
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ddraw/OS2CLIPPER.CPP

    r1502 r1568  
    4141{
    4242  #ifdef DEBUG
    43     dprintf(("ClipQueryInterface\n"));
     43    dprintf(("DDRAW: ClipQueryInterface\n"));
    4444  #endif
    4545
    … …  
    6363
    6464  #ifdef DEBUG
    65     dprintf(("OS2IDirectDrawClipper::AddRef %d\n", me->Referenced+1));
     65    dprintf(("DDRAW: OS2IDirectDrawClipper::AddRef %d\n", me->Referenced+1));
    6666  #endif
    6767
    … …  
    7575
    7676  #ifdef DEBUG
    77     dprintf(("OS2IDirectDrawClipper::Release %d\n", me->Referenced-1));
     77    dprintf(("DDRAW: OS2IDirectDrawClipper::Release %d\n", me->Referenced-1));
    7878  #endif
    7979
    … …  
    9797{
    9898  #ifdef DEBUG
    99     dprintf(("ClipGetClipList\n"));
     99    dprintf(("DDRAW: ClipGetClipList\n"));
    100100  #endif
    101101
    … …  
    109109
    110110  #ifdef DEBUG
    111     dprintf(("ClipGetHWnd\n"));
     111    dprintf(("DDRAW: ClipGetHWnd\n"));
    112112  #endif
    113113
    … …  
    120120{
    121121  #ifdef DEBUG
    122     dprintf(("ClipInitialize\n"));
     122    dprintf(("DDRAW: ClipInitialize\n"));
    123123  #endif
    124124
    … …  
    130130{
    131131  #ifdef DEBUG
    132     dprintf(("ClipIsClipListChanged\n"));
     132    dprintf(("DDRAW: ClipIsClipListChanged\n"));
    133133  #endif
    134134
    … …  
    140140{
    141141  #ifdef DEBUG
    142     dprintf(("ClipSetClipList\n"));
     142    dprintf(("DDRAW: ClipSetClipList\n"));
    143143  #endif
    144144
    … …  
    153153
    154154  #ifdef DEBUG
    155     dprintf(("ClipSetHWnd\n"));
     155    dprintf(("DDRAW: ClipSetHWnd\n"));
    156156  #endif
    157157

  • trunk/src/ddraw/OS2D3D.CPP

    r1502 r1568  
    1818HRESULT __stdcall D3DQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
    1919{
    20   dprintf(("D3DQueryInterface\n"));
     20  dprintf(("DDRAW: D3DQueryInterface\n"));
    2121  *ppvObj = NULL;
    2222
    … …  
    3535 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    3636
    37   dprintf(("OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
     37  dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    3838  return ++me->Referenced;
    3939}
    … …  
    4444 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    4545
    46   dprintf(("OS2IDirectDraw::Release %d\n", me->Referenced-1));
    47   dprintf(("OS2IDirectDraw::%X \n", me));
     46  dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
     47  dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    4848  if(me->Referenced)
    4949  {
    … …  
    6464HRESULT __stdcall D3DInitialize(THIS This, REFIID)
    6565{
    66   dprintf(("D3DInitialize\n"));
     66  dprintf(("DDRAW: D3DInitialize\n"));
    6767  return(D3D_OK);
    6868}
    … …  
    7171HRESULT __stdcall D3DEnumDevices(THIS This, LPD3DENUMDEVICESCALLBACK, LPVOID)
    7272{
    73   dprintf(("D3DEnumDevices\n"));
     73  dprintf(("DDRAW: D3DEnumDevices\n"));
    7474  return(D3D_OK);
    7575}
    … …  
    7878HRESULT __stdcall D3DCreateLight(THIS This, LPDIRECT3DLIGHT*, IUnknown*)
    7979{
    80   dprintf(("D3DCreateLight\n"));
     80  dprintf(("DDRAW: D3DCreateLight\n"));
    8181  return(D3D_OK);
    8282}
    … …  
    8585HRESULT __stdcall D3DCreateMaterial(THIS This, LPDIRECT3DMATERIAL*, IUnknown*)
    8686{
    87   dprintf(("D3DCreateMaterial\n"));
     87  dprintf(("DDRAW: D3DCreateMaterial\n"));
    8888  return(D3D_OK);
    8989}
    … …  
    9292HRESULT __stdcall D3DCreateViewport(THIS This, LPDIRECT3DVIEWPORT*, IUnknown*)
    9393{
    94   dprintf(("D3DCreateViewport\n"));
     94  dprintf(("DDRAW: D3DCreateViewport\n"));
    9595  return(D3D_OK);
    9696}
    … …  
    9999HRESULT __stdcall D3DFindDevice(THIS This, LPD3DFINDDEVICESEARCH, LPD3DFINDDEVICERESULT)
    100100{
    101   dprintf(("D3DCreateFindDevice\n"));
     101  dprintf(("DDRAW: D3DCreateFindDevice\n"));
    102102  return(D3D_OK);
    103103}

  • trunk/src/ddraw/OS2DDRAW.CPP

    r1502 r1568  
    113113  if(lpGUID && *lpGUID == IID_IDirect3D)
    114114  {
    115     dprintf(("D3D Interface\n"));
     115    dprintf(("DDRAW: D3D Interface\n"));
    116116
    117117    lpVtbl = (IDirectDraw4Vtbl *)&Vtbl3D;
    … …  
    121121    if(lpGUID && *lpGUID == IID_IDirectDraw4)
    122122    {
    123       dprintf(("V4 Interface\n"));
     123      dprintf(("DDRAW: V4 Interface\n"));
    124124      lpVtbl = &Vtbl4;
    125125    }
    126126    else
    127127    {
    128       dprintf(("<V4 Interface\n"));
     128      dprintf(("DDRAW: <V4 Interface\n"));
    129129      lpVtbl = (IDirectDraw4Vtbl *) &Vtbl;
    130130    }
    … …  
    142142  if(rc)
    143143  {
    144     dprintf(("ERROR: DiveOpen returned %d\n", rc));
     144    dprintf(("DDRAW: ERROR: DiveOpen returned %d\n", rc));
    145145    lastError = DDERR_GENERIC;
    146146    hDive     = NULL;
    … …  
    148148  else
    149149  {
    150     dprintf(("DiveOpen OK Framebuufer at 0x%08X\n",pFrameBuffer));
     150    dprintf(("DDRAW: DiveOpen OK Framebuufer at 0x%08X\n",pFrameBuffer));
    151151  }
    152152  memset( &dCaps,
    … …  
    160160                      DIVE_BUFFER_SCREEN);
    161161
    162   dprintf(("DiveQueryCaps rc=0x%08X\n",rc));
     162  dprintf(("DDRAW: DiveQueryCaps rc=0x%08X\n",rc));
    163163
    164164  pdwUnknownData[235] = dCaps.ulHorizontalResolution;
    … …  
    181181OS2IDirectDraw::~OS2IDirectDraw()
    182182{
    183   dprintf(("OS2IDirectDraw::~OS2IDirectDraw()\n"));
     183  dprintf(("DDRAW: OS2IDirectDraw::~OS2IDirectDraw()\n"));
    184184  if(hDive)
    185185    DiveClose(hDive);
    … …  
    201201 OS2IDirectDraw *me = (OS2IDirectDraw *)This;
    202202  #ifdef DEBUG
    203     dprintf(("OS2IDirectDraw::QueryInterface\n"));
     203    dprintf(("DDRAW: OS2IDirectDraw::QueryInterface\n"));
    204204  #endif
    205205
    … …  
    217217  if(IsEqualGUID(riid, IID_IDirectDraw4))
    218218  {
    219     dprintf(("IID_IDirectDraw4 Interface\n"));
     219    dprintf(("DDRAW: IID_IDirectDraw4 Interface\n"));
    220220    me->lpVtbl = &me->Vtbl4;
    221221  }
    222222  else
    223223  {
    224     dprintf(("No IID_IDirectDraw4 Interface\n"));
     224    dprintf(("DDRAW: No IID_IDirectDraw4 Interface\n"));
    225225    me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
    226226  }
    … …  
    237237
    238238  #ifdef DEBUG
    239     dprintf(("OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
     239    dprintf(("DDRAW: OS2IDirectDraw::AddRef %d\n", me->Referenced+1));
    240240  #endif
    241241
    … …  
    250250
    251251  #ifdef DEBUG
    252     dprintf(("OS2IDirectDraw::Release %d\n", me->Referenced-1));
    253     dprintf(("OS2IDirectDraw::%X \n", me));
     252    dprintf(("DDRAW: OS2IDirectDraw::Release %d\n", me->Referenced-1));
     253    dprintf(("DDRAW: OS2IDirectDraw::%X \n", me));
    254254  #endif
    255255
    … …  
    276276{
    277277  #ifdef DEBUG
    278     dprintf(("Compact\n"));
     278    dprintf(("DDRAW: Compact\n"));
    279279  #endif
    280280
    … …  
    292292
    293293  #ifdef DEBUG
    294     dprintf(("CreateClipper\n"));
     294    dprintf(("DDRAW: CreateClipper\n"));
    295295  #endif
    296296
    … …  
    348348  {
    349349    #ifdef DEBUG
    350       dprintf(("CreatePalette with %d colors\n", palsize));
     350      dprintf(("DDRAW: CreatePalette with %d colors\n", palsize));
    351351    #endif
    352352
    … …  
    385385
    386386  #ifdef DEBUG
    387     dprintf(("CreateSurface\n"));
    388     dprintf(("dwSize %d\n", lpDDSurfaceDesc->dwSize));
    389     dprintf(("dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
    390     dprintf(("dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
    391     dprintf(("dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
    392     dprintf(("lPitch %d\n", lpDDSurfaceDesc->lPitch));
    393     dprintf(("dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
    394     dprintf(("dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
    395     dprintf(("dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
    396     dprintf(("ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
     387    dprintf(("DDRAW: CreateSurface\n"));
     388    dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
     389    dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
     390    dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
     391    dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
     392    dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
     393    dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
     394    dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
     395    dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
     396    dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
    397397  #endif
    398398
    … …  
    408408    if(rc != DD_OK)
    409409    {
    410       dprintf(("Error createing Surface\n\n"));
     410      dprintf(("DDRAW: Error createing Surface\n\n"));
    411411      *lplpDD = NULL;
    412412      delete newsurf;
    … …  
    415415      *lplpDD = (IDirectDrawSurface *)newsurf;
    416416
    417     dprintf(("New Surface created at %08X\n\n", newsurf));
     417    dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
    418418  }
    419419
    … …  
    431431
    432432  #ifdef DEBUG
    433     dprintf(("CreateSurface4\n"));
    434     dprintf(("dwSize %d\n", lpDDSurfaceDesc2->dwSize));
    435     dprintf(("dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
    436     dprintf(("dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
    437     dprintf(("lPitch %d\n", lpDDSurfaceDesc2->lPitch));
    438     dprintf(("dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
    439     dprintf(("dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
    440     dprintf(("dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
    441     dprintf(("ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
     433    dprintf(("DDRAW: CreateSurface4\n"));
     434    dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
     435    dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
     436    dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
     437    dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
     438    dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
     439    dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
     440    dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
     441    dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
    442442  #endif
    443443
    … …  
    454454    if(rc != DD_OK)
    455455    {
    456       dprintf(("Error createing Surface\n\n"));
     456      dprintf(("DDRAW: Error createing Surface\n\n"));
    457457      *lplpDD = NULL;
    458458
    … …  
    462462      *lplpDD = (IDirectDrawSurface4 *)newsurf;
    463463
    464     dprintf(("New Surface created at %08X\n\n", newsurf));
     464    dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
    465465  }
    466466
    … …  
    472472{
    473473  #ifdef DEBUG
    474     dprintf(("DuplicateSurface NIY\n"));
     474    dprintf(("DDRAW: DuplicateSurface NIY\n"));
    475475  #endif
    476476  return(DD_OK);
    … …  
    481481{
    482482  #ifdef DEBUG
    483     dprintf(("DuplicateSurface4 NIY\n"));
     483    dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
    484484  #endif
    485485
    … …  
    500500
    501501  #ifdef DEBUG
    502     dprintf(("EnumDisplayModes\n"));
     502    dprintf(("DDRAW: EnumDisplayModes\n"));
    503503  #endif
    504504
    … …  
    507507  {
    508508    #ifdef DEBUG
    509       dprintf(("EnumDisplayModes : Error NO EnumFunction passed in\n"));
     509      dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
    510510    #endif
    511511
    … …  
    530530
    531531    #ifdef DEBUG
    532       dprintf(("EnumDisplayModes : DIVE modes\n"));
     532      dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
    533533    #endif
    534534
    … …  
    539539
    540540      #ifdef DEBUG
    541         dprintf(("EnumDisplayModes : ALL modes\n"));
     541        dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
    542542      #endif
    543543
    … …  
    545545      {
    546546        #ifdef DEBUG
    547           dprintf(("EnumDisplayModes : STANDARDVGAMODES\n"));
     547          dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
    548548        #endif
    549549        DDSurfAct.dwHeight = ModesDive[0].iYRes;
    … …  
    554554        {
    555555          #ifdef DEBUG
    556             dprintf(("EnumDisplayModes : Enum done\n"));
     556            dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
    557557          #endif
    558558          return (DD_OK);
    … …  
    791791
    792792  #ifdef DEBUG
    793     dprintf(("EnumDisplayModes4 NIY\n"));
     793    dprintf(("DDRAW: EnumDisplayModes4 NIY\n"));
    794794  #endif
    795795  return(DD_OK);
    … …  
    800800{
    801801  #ifdef DEBUG
    802     dprintf(("EnumSurfaces NIY\n"));
     802    dprintf(("DDRAW: EnumSurfaces NIY\n"));
    803803  #endif
    804804
    … …  
    810810{
    811811  #ifdef DEBUG
    812     dprintf(("EnumSurfaces4 NIY\n"));
     812    dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
    813813  #endif
    814814
    … …  
    820820{
    821821  #ifdef DEBUG
    822     dprintf(("FlipToGDISurface NIY\n"));
     822    dprintf(("DDRAW: FlipToGDISurface NIY\n"));
    823823  #endif
    824824
    … …  
    832832
    833833  #ifdef DEBUG
    834     dprintf(("DDGetCaps of "));
     834    dprintf(("DDRAW: DDGetCaps of "));
    835835  #endif
    836836
    … …  
    842842    // Caller want Driver Caps
    843843
    844     dprintf(("Driver\n"));
     844    dprintf(("DDRAW: Driver\n"));
    845845
    846846    if( (sizeof(DDCAPS)!=lpDDDriverCaps->dwSize)     &&
    … …  
    988988  {
    989989    // Caller wants HEL Caps
    990     dprintf((" HEL\n"));
     990    dprintf(("DDRAW: HEL\n"));
    991991
    992992    if(sizeof(DDCAPS)!=lpDDHELCaps->dwSize)
    993993    {
    994       dprintf(("Size Not Set\n"));
     994      dprintf(("DDRAW: Size Not Set\n"));
    995995      return(DDERR_INVALIDPARAMS);
    996996    }
    … …  
    10761076  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    10771077  #ifdef DEBUG
    1078     dprintf(("GetDisplayMode\n"));
     1078    dprintf(("DDRAW: GetDisplayMode\n"));
    10791079  #endif
    10801080
    … …  
    11791179    default:
    11801180      #ifdef DEBUG
    1181         dprintf(("Unsupported mode\n"));
     1181        dprintf(("DDRAW: Unsupported mode\n"));
    11821182      #endif
    11831183      return(DDERR_UNSUPPORTEDMODE);
    … …  
    11921192  OS2IDirectDraw        *me = (OS2IDirectDraw *)This;
    11931193  #ifdef DEBUG
    1194     dprintf(("GetDisplayMode\n"));
     1194    dprintf(("DDRAW: GetDisplayMode\n"));
    11951195  #endif
    11961196
    … …  
    12951295    default:
    12961296      #ifdef DEBUG
    1297         dprintf(("Unsupported mode\n"));
     1297        dprintf(("DDRAW: Unsupported mode\n"));
    12981298      #endif
    12991299      return(DDERR_UNSUPPORTEDMODE);
    … …  
    13081308  DWORD dwFCC[3] = {FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3};
    13091309  #ifdef DEBUG
    1310     dprintf(("GetFourCCCodes\n"));
     1310    dprintf(("DDRAW: GetFourCCCodes\n"));
    13111311  #endif
    13121312
    … …  
    13351335{
    13361336  #ifdef DEBUG
    1337     dprintf(("GetGDISurface NYI\n"));
     1337    dprintf(("DDRAW: GetGDISurface NYI\n"));
    13381338  #endif
    13391339
    … …  
    13451345{
    13461346  #ifdef DEBUG
    1347     dprintf(("GetGDISurface NYI\n"));
     1347    dprintf(("DDRAW: GetGDISurface NYI\n"));
    13481348  #endif
    13491349
    … …  
    13571357  DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
    13581358  #ifdef DEBUG
    1359     dprintf(("GetMonitorFrequency\n"));
     1359    dprintf(("DDRAW: GetMonitorFrequency\n"));
    13601360  #endif
    13611361  if(NULL==lpdwFreq)
    … …  
    13951395  BOOL bVertBlank;
    13961396  #ifdef DEBUG
    1397     dprintf(("GetScanLine\n"));
     1397    dprintf(("DDRAW: GetScanLine\n"));
    13981398  #endif
    13991399  // ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
    … …  
    14191419  int rc;
    14201420  #ifdef DEBUG
    1421     dprintf(("GetVerticalBlankStatus\n"));
     1421    dprintf(("DDRAW: GetVerticalBlankStatus\n"));
    14221422  #endif
    14231423  if(NULL==lpbIsInVB)
    … …  
    14441444{
    14451445  #ifdef DEBUG
    1446     dprintf(("Initialize\n"));
     1446    dprintf(("DDRAW: Initialize\n"));
    14471447  #endif
    14481448
    … …  
    14541454{
    14551455  #ifdef DEBUG
    1456     dprintf(("RestoreDisplayMod\n"));
     1456    dprintf(("DDRAW: RestoreDisplayMod\n"));
    14571457  #endif
    14581458
    … …  
    14661466
    14671467  #ifdef DEBUG
    1468     dprintf(("SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
     1468    dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
    14691469  #endif
    14701470
    … …  
    14871487
    14881488  #ifdef DEBUG
    1489     dprintf(("SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
     1489    dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    14901490  #endif
    14911491
    … …  
    15251525
    15261526#ifdef DEBUG
    1527   dprintf(("SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
     1527  dprintf(("DDRAW: SetDisplayMode to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
    15281528#endif
    15291529  me->screenwidth  = dwWidth;
    … …  
    15591559  int rci;
    15601560
    1561   #ifdef DEBUG
    1562     dprintf(("WaitForVerticalBlank\n"));
    1563   #endif
     1561  dprintf(("DDRAW: WaitForVerticalBlank\n"));
    15641562
    15651563  if(DDWAITVB_BLOCKBEGINEVENT == dwFlags) // This parameter isn't support in DX
    … …  
    15671565
    15681566
    1569     rci = io_init1();
     1567  rci = io_init1();
    15701568
    15711569
    15721570  if(rci)  // try to get IOPL for the thread
     1571  {
     1572    dprintf(("DDRAW: No IOPL\n"));
    15731573    return (DDERR_UNSUPPORTED);  // we failed so return error that we don't support this
    1574 
     1574  }
    15751575  // AT this point we should have IOPL so lets use it!
    15761576
    … …  
    16001600
    16011601
    1602     io_exit1();
     1602  //  io_exit1();
    16031603
    16041604
    … …  
    16131613{
    16141614  #ifdef DEBUG
    1615     dprintf(("GetAvailableVidMem\n"));
     1615    dprintf(("DDRAW: GetAvailableVidMem\n"));
    16161616  #endif
    16171617
    … …  
    16381638{
    16391639  #ifdef DEBUG
    1640     dprintf(("GetAvailableVidMem\n"));
     1640    dprintf(("DDRAW: GetAvailableVidMem\n"));
    16411641  #endif
    16421642
    … …  
    16621662{
    16631663  #ifdef DEBUG
    1664     dprintf(("GetSurfaceFromDC NYI\n"));
     1664    dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
    16651665  #endif
    16661666
    … …  
    16721672{
    16731673  #ifdef DEBUG
    1674     dprintf(("RestoreAllSurfaces\n"));
     1674    dprintf(("DDRAW: RestoreAllSurfaces\n"));
    16751675  #endif
    16761676
    … …  
    16821682{
    16831683  #ifdef DEBUG
    1684     dprintf(("TestCooperativeLevel\n"));
     1684    dprintf(("DDRAW: TestCooperativeLevel\n"));
    16851685  #endif
    16861686
    … …  
    16931693{
    16941694  #ifdef DEBUG
    1695     dprintf(("GetDeviceIdentifier Flags = %d\n",dwFlags));
     1695    dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
    16961696  #endif
    16971697  if(NULL==lpdddi)

  • trunk/src/ddraw/OS2PALETTE.CPP

    r1502 r1568  
    5050  memcpy((char *)os2pal, (char *)lpColorTable, palsize*sizeof(PALETTEENTRY));
    5151
    52   dprintf(("Init CC PalTable"));
     52  dprintf(("DDRAW: Init CC PalTable"));
    5353  for(DWORD i=0;i<dwSize;i++)
    5454  {
    … …  
    8080{
    8181  #ifdef DEBUG
    82     dprintf(("OS2IDirectDrawPalette::PalQueryInterface\n"));
     82    dprintf(("DDRAW: OS2IDirectDrawPalette::PalQueryInterface\n"));
    8383  #endif
    8484
    … …  
    101101
    102102  #ifdef DEBUG
    103     dprintf(("OS2IDirectDrawPalette::PalAddRef %d\n", me->Referenced+1));
     103    dprintf(("DDRAW: OS2IDirectDrawPalette::PalAddRef %d\n", me->Referenced+1));
    104104  #endif
    105105
    … …  
    113113
    114114  #ifdef DEBUG
    115     dprintf(("OS2IDirectDrawPalette::PalRelease %d\n", me->Referenced-1));
     115    dprintf(("DDRAW: OS2IDirectDrawPalette::PalRelease %d\n", me->Referenced-1));
    116116  #endif
    117117
    … …  
    137137
    138138  #ifdef DEBUG
    139     dprintf(("OS2IDirectDrawPalette::GetCaps\n"));
     139    dprintf(("DDRAW: OS2IDirectDrawPalette::GetCaps\n"));
    140140  #endif
    141141
    … …  
    160160
    161161  #ifdef DEBUG
    162     dprintf(("OS2IDirectDrawPalette::PalGetEntries\n"));
     162    dprintf(("DDRAW: OS2IDirectDrawPalette::PalGetEntries\n"));
    163163  #endif
    164164
    … …  
    177177{
    178178  #ifdef DEBUG
    179     dprintf(("OS2IDirectDrawPalette::PalInitialize\n"));
     179    dprintf(("DDRAW: OS2IDirectDrawPalette::PalInitialize\n"));
    180180  #endif
    181181  return(DDERR_ALREADYINITIALIZED);
    … …  
    191191
    192192  #ifdef DEBUG
    193     dprintf(("OS2IDirectDrawPalette::PalSetEntries\n"));
     193    dprintf(("DDRAW: OS2IDirectDrawPalette::PalSetEntries\n"));
    194194  #endif
    195195  if( (NULL== lpNewEntries) ||(0!=dwFlags) ||(dwBase<0) ||((dwBase + dwNumEntries)>me->dwSize) )
    … …  
    200200         dwNumEntries*sizeof(PALETTEENTRY));
    201201
    202   dprintf(("Setting up CC Palentries:\n"));
     202  dprintf(("DDRAW: Setting up CC Palentries:\n"));
    203203  for(DWORD i=0;i<dwNumEntries;i++)
    204204  {

  • trunk/src/ddraw/OS2SURFACE.CPP

    r1562 r1568  
    311311  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    312312     if (flags[i].mask & flagmask) {
    313         dprintf(("%s ",flags[i].name));
     313        dprintf(("DDRAW: %s ",flags[i].name));
    314314     };
    315   dprintf(("\n"));
     315  dprintf(("DDRAW: \n"));
    316316
    317317}
    … …  
    331331  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    332332    if (flags[i].mask & flagmask)
    333       dprintf(("%s ",flags[i].name));
    334   dprintf(("\n"));
     333      dprintf(("DDRAW: %s ",flags[i].name));
     334  dprintf(("DDRAW: \n"));
    335335}
    336336
    … …  
    371371  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    372372    if (flags[i].mask & flagmask)
    373       dprintf(("%s ",flags[i].name));
    374   dprintf(("\n"));
     373      dprintf(("DDRAW: %s ",flags[i].name));
     374  dprintf(("DDRAW: \n"));
    375375}
    376376
    … …  
    415415  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    416416    if (flags[i].mask & flagmask)
    417       dprintf(("%s ",flags[i].name));
    418   dprintf(("\n"));
     417      dprintf(("DDRAW: %s ",flags[i].name));
     418  dprintf(("DDRAW: \n"));
    419419}
    420420
    … …  
    435435  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    436436    if (flags[i].mask & flagmask)
    437       dprintf(("%s ",flags[i].name));
    438   dprintf(("\n"));
     437      dprintf(("DDRAW: %s ",flags[i].name));
     438  dprintf(("DDRAW: \n"));
    439439}
    440440
    … …  
    466466  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    467467    if (flags[i].mask & flagmask)
    468       dprintf(("%s ",flags[i].name));
    469   dprintf(("\n"));
     468      dprintf(("DDRAW: %s ",flags[i].name));
     469  dprintf(("DDRAW: \n"));
    470470}
    471471
    … …  
    494494  for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
    495495    if (flags[i].mask & flagmask)
    496       dprintf(("%s ",flags[i].name));
    497   dprintf(("\n"));
     496      dprintf(("DDRAW: %s ",flags[i].name));
     497  dprintf(("DDRAW: \n"));
    498498}
    499499
    500500static void _dump_pixelformat(LPDDPIXELFORMAT pf) {
    501501  _dump_DDCOLORKEY(pf->dwFlags);
    502   dprintf(("dwFourCC : %ld\n", pf->dwFourCC));
    503   dprintf(("RBG bit cbout : %ld\n", pf->dwRGBBitCount));
    504   dprintf(("Masks : R %08lx  G %08lx  B %08lx  A %08lx\n",
     502  dprintf(("DDRAW: dwFourCC : %ld\n", pf->dwFourCC));
     503  dprintf(("DDRAW: RBG bit cbout : %ld\n", pf->dwRGBBitCount));
     504  dprintf(("DDRAW: Masks : R %08lx  G %08lx  B %08lx  A %08lx\n",
    505505       pf->dwRBitMask, pf->dwGBitMask, pf->dwBBitMask, pf->dwRGBAlphaBitMask));
    506506}
    … …  
    686686  {
    687687    #ifdef DEBUG
    688       dprintf(("Internal : Error creating DPA for MipMaps\n"));
     688      dprintf(("DDRAW: Internal : Error creating DPA for MipMaps\n"));
    689689    #endif
    690690    lastError = DDERR_OUTOFMEMORY ;
    … …  
    696696  {
    697697    #ifdef DEBUG
    698       dprintf(("Internal : Error creating DPA for attached surfaces\n"));
     698      dprintf(("DDRAW: Internal : Error creating DPA for attached surfaces\n"));
    699699    #endif
    700700    lastError = DDERR_OUTOFMEMORY ;
    … …  
    706706  {
    707707    #ifdef DEBUG
    708       dprintf(("Internal : Error creating DPA for Locked Rectangles\n"));
     708      dprintf(("DDRAW: Internal : Error creating DPA for Locked Rectangles\n"));
    709709    #endif
    710710    lastError = DDERR_OUTOFMEMORY ;
    … …  
    716716  {
    717717    #ifdef DEBUG
    718       dprintf(("Internal : Error creating DPA for priva surface Data\n"));
     718      dprintf(("DDRAW: Internal : Error creating DPA for priva surface Data\n"));
    719719    #endif
    720720    lastError = DDERR_OUTOFMEMORY ;
    … …  
    730730    {
    731731      #ifdef DEBUG
    732         dprintf(("Primary surface!\n"));
     732        dprintf(("DDRAW: Primary surface!\n"));
    733733      #endif
    734734
    … …  
    736736      {
    737737        #ifdef DEBUG
    738           dprintf(("Primary surface already exits!\n"));
     738          dprintf(("DDRAW: Primary surface already exits!\n"));
    739739        #endif
    740740        lastError = DDERR_PRIMARYSURFACEALREADYEXISTS;
    … …  
    748748      {
    749749        // Dx doc says passing width,height etc. for primary surface in not permitted!!
    750         dprintf(("Invalid parameters\n\n"));
     750        dprintf(("DDRAW: Invalid parameters\n\n"));
    751751        lastError = DDERR_INVALIDPARAMS;
    752752        return;
    … …  
    758758      if( lpDraw->dCaps.ulDepth == lpDraw->GetScreenBpp() )
    759759      {
    760         dprintf(("DirectScreenAccess possible\n"));
     760        dprintf(("DDRAW: DirectScreenAccess possible\n"));
    761761
    762762        // Yes so direct access to framebuffer is possible
    … …  
    795795
    796796      #ifdef DEBUG
    797         dprintf(("Setting up Surface\n"));
     797        dprintf(("DDRAW: Setting up Surface\n"));
    798798      #endif
    799799      DDSurfaceDesc.dwFlags     |= DDSD_WIDTH | DDSD_HEIGHT |
    … …  
    855855          DDSurfaceDesc.dwFlags    &= ~DDSD_PIXELFORMAT;
    856856          #ifdef DEBUG
    857             dprintf(("Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
     857            dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    858858          #endif
    859859          break;
    … …  
    861861
    862862      #ifdef DEBUG
    863         dprintf(("Surface set up, checking other Caps\n"));
     863        dprintf(("DDRAW: Surface set up, checking other Caps\n"));
    864864      #endif
    865865
    … …  
    867867      {
    868868        #ifdef DEBUG
    869           dprintf(("Complex Surface\n"));
     869          dprintf(("DDRAW: Complex Surface\n"));
    870870        #endif
    871871
    … …  
    873873        {
    874874          #ifdef DEBUG
    875             dprintf(("Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
     875            dprintf(("DDRAW: Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
    876876          #endif
    877877          memset( &ComplexSurfaceDesc,
    … …  
    905905          if (BackBuffer->GetLastError()==DD_OK)
    906906          {
    907             dprintf(("created backbuffer"));
     907            dprintf(("DDRAW: created backbuffer"));
    908908            // Our Primary Buffer is also the frontbuffer of a flipchain
    909909            DDSurfaceDesc.ddsCaps.dwCaps    |= DDSCAPS_FRONTBUFFER | DDSCAPS_FLIP;
    … …  
    913913          else
    914914          {
    915             dprintf(("Error creating backbuffer"));
     915            dprintf(("DDRAW: Error creating backbuffer"));
    916916          }
    917917        }
    … …  
    919919        {
    920920          #ifdef DEBUG
    921             dprintf(("Unsupported Complex Surface\n"));
     921            dprintf(("DDRAW: Unsupported Complex Surface\n"));
    922922            _dump_DDSCAPS(lpDDSurfaceDesc->dwFlags);
    923923          #endif
    … …  
    953953      if(DDSurfaceDesc.dwFlags & DDSD_PIXELFORMAT)         // Pixelformat passed in ?
    954954      {
    955         dprintf((" Pixelformat requested :"));
     955        dprintf(("DDRAW: Pixelformat requested :"));
    956956        // YES use it
    957957        if(DDSurfaceDesc.ddpfPixelFormat.dwFlags & DDPF_RGB)
    … …  
    969969      else
    970970      {
    971         dprintf((" Use Screen Format :"));
     971        dprintf(("DDRAW: Use Screen Format :"));
    972972        dwBpp = lpDraw->GetScreenBpp(); // No use Screenformat
    973973        lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
    … …  
    10131013            DDSurfaceDesc.dwFlags    &= ~DDSD_PIXELFORMAT;
    10141014            #ifdef DEBUG
    1015               dprintf(("Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
     1015              dprintf(("DDRAW: Unexpected BitDepth : %d\n",lpDraw->GetScreenBpp()));
    10161016            #endif
    10171017            break;
    … …  
    10201020      }
    10211021
    1022       dprintf(("%d Bits\n",dwBpp));
     1022      dprintf(("DDRAW: %d Bits\n",dwBpp));
    10231023
    10241024      // three possible situaltions
    … …  
    10341034        // 1.
    10351035
    1036         dprintf((" Usersupplied Surface\n"));
     1036        dprintf(("DDRAW: Usersupplied Surface\n"));
    10371037
    10381038        if(NULL==DDSurfaceDesc.lpSurface)
    … …  
    10861086          // 2.
    10871087
    1088           dprintf((" Alloc on Load Texture?!\n"));
     1088          dprintf(("DDRAW: Alloc on Load Texture?!\n"));
    10891089
    10901090          dwCaps &= ~DDSCAPS_ALLOCONLOAD; // remove flag
    … …  
    11031103          // This surface isn't allocated yet, but when the texture is loaded
    11041104          #ifdef DEBUG
    1105             dprintf(("Warning : Delayed memory allocation on request\n"));
     1105            dprintf(("DDRAW: Warning : Delayed memory allocation on request\n"));
    11061106          #endif
    11071107          DDSurfaceDesc.lpSurface = NULL;
    … …  
    11121112          // 3.
    11131113
    1114           dprintf((" Alloc now!\n"));
     1114          dprintf(("DDRAW: Alloc now!\n"));
    11151115
    11161116          lpDDSurfaceDesc->dwFlags  |= DDSD_PITCH|DDSD_LPSURFACE;
    … …  
    11251125            if(dwBpp<8)
    11261126            {
    1127               dprintf(("1 or 4 Bit Surface encountered may not work !"));
     1127              dprintf(("DDRAW: 1 or 4 Bit Surface encountered may not work !"));
    11281128            }
    11291129          #endif
    … …  
    11421142          pFrameBuffer = (char*)(((int)pFBreal + 7) & ~7); // align to QWORD
    11431143
    1144           dprintf((" Framebuffer @ %08X QWAligned @ %08X with a Pitch of %d\n",
     1144          dprintf(("DDRAW: Framebuffer @ %08X QWAligned @ %08X with a Pitch of %d\n",
    11451145                    pFBreal, pFrameBuffer, dwPitchFB));
    11461146
    … …  
    11511151          if( (lpDraw->dCaps.ulDepth ) == dwBpp )
    11521152          {
    1153             dprintf((" No CC_Buffer needed\n"));
     1153            dprintf(("DDRAW: No CC_Buffer needed\n"));
    11541154            // Yes => No Colorconversion is needed so point to the same buffer
    11551155            pDiveBuffer  = pFrameBuffer;
    … …  
    11571157          else
    11581158          {
    1159             dprintf((" Alloc CCBuf "));
     1159            dprintf(("DDRAW: Alloc CCBuf "));
    11601160            dwPitchDB = (lpDDSurfaceDesc->dwWidth * (lpDraw->dCaps.ulDepth/8) +7) & ~7;
    11611161            if(Mainchain)
    11621162            {
    1163               dprintf(("with DIVE\n"));
     1163              dprintf(("DDRAW: with DIVE\n"));
    11641164              // This surface is part of flipchain with the primary surface use dive to assoc memory
    11651165              pDiveBuffer = (char*)malloc( lpDDSurfaceDesc->dwHeight *
    … …  
    11731173                                         dwPitchDB,
    11741174                                         (PBYTE)pDiveBuffer);
    1175                dprintf(("rc = 0x%08X\n",rc));
     1175               dprintf(("DDRAW: rc = 0x%08X\n",rc));
    11761176            }
    11771177            else
    … …  
    12001200        dwCaps &= ~DDSCAPS_COMPLEX;
    12011201        #ifdef DEBUG
    1202           dprintf(("Complex Surface\n"));
     1202          dprintf(("DDRAW: Complex Surface\n"));
    12031203        #endif
    12041204
    … …  
    12071207          lpDDSurfaceDesc->dwFlags &= ~DDSD_BACKBUFFERCOUNT;
    12081208          #ifdef DEBUG
    1209             dprintf(("Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
     1209            dprintf(("DDRAW: Backbuffer # = %d\n",lpDDSurfaceDesc->dwBackBufferCount));
    12101210          #endif
    12111211          memcpy(&ComplexSurfaceDesc,lpDDSurfaceDesc,sizeof(DDSURFACEDESC2));
    … …  
    12431243          lpDDSurfaceDesc->dwFlags &= ~DDSD_MIPMAPCOUNT;
    12441244          #ifdef DEBUG
    1245             dprintf(("Mipmpa # = %d\n",lpDDSurfaceDesc->dwMipMapCount));
     1245            dprintf(("DDRAW: Mipmpa # = %d\n",lpDDSurfaceDesc->dwMipMapCount));
    12461246          #endif
    12471247          memcpy(&ComplexSurfaceDesc,lpDDSurfaceDesc,sizeof(DDSURFACEDESC2));
    … …  
    12511251          {
    12521252            #ifdef DEBUG
    1253               dprintf(("Creating MipMap %d\n",i));
     1253              dprintf(("DDRAW: Creating MipMap %d\n",i));
    12541254            #endif
    12551255            // Mpmaps shirnk by 2
    … …  
    12681268              lastError = MipMapSurface->GetLastError();
    12691269              #ifdef DEBUG
    1270                 dprintf(("Attached surface creation returned error %d\n",lastError));
     1270                dprintf(("DDRAW: Attached surface creation returned error %d\n",lastError));
    12711271              #endif
    12721272              return;
    … …  
    12771277        #ifdef DEBUG
    12781278          if(lpDDSurfaceDesc->dwFlags)
    1279             dprintf(("Unsupported Complex Surface\n"));
     1279            dprintf(("DDRAW: Unsupported Complex Surface\n"));
    12801280        #endif
    12811281      } // Endif DDSCAPS_COMPLEX
    … …  
    12881288  else
    12891289  {
    1290     dprintf(("CAPS not valid\n"));
     1290    dprintf(("DDRAW: CAPS not valid\n"));
    12911291    lastError = DDERR_INVALIDPARAMS;
    12921292  }
    12931293  #ifdef DEBUG
    1294     dprintf(("Buf %X Screen Caps (%d,%d), bitcount %d\n\n", this, lpDraw->GetScreenHeight(), lpDraw->GetScreenWidth(),
     1294    dprintf(("DDRAW: Buf %X Screen Caps (%d,%d), bitcount %d\n\n", this, lpDraw->GetScreenHeight(), lpDraw->GetScreenWidth(),
    12951295    lpDraw->dCaps.ulDepth));
    12961296    if(DD_OK!=lastError)
    12971297    {
    1298       dprintf(("Some Error Check Flags\n"));
     1298      dprintf(("DDRAW: Some Error Check Flags\n"));
    12991299      _dump_DDSCAPS(lpDDSurfaceDesc->dwFlags);
    13001300    }
    … …  
    13131313  WORD  *pPal16;
    13141314  #ifdef DEBUG
    1315     dprintf(("ColorFill with %08X\n", dwFillColor));
     1315    dprintf(("DDRAW: ColorFill with %08X\n", dwFillColor));
    13161316  #endif
    13171317
    … …  
    13191319  {
    13201320    #ifdef DEBUG
    1321       dprintf(("Fill only Rect(%d,%d)(%d,%d)\n", lpDestRect->left, lpDestRect->top,
     1321      dprintf(("DDRAW: Fill only Rect(%d,%d)(%d,%d)\n", lpDestRect->left, lpDestRect->top,
    13221322               lpDestRect->right, lpDestRect->bottom));
    13231323    #endif
    … …  
    13301330  else
    13311331  {
    1332     dprintf(("Fill all at addr "));
     1332    dprintf(("DDRAW: Fill all at addr "));
    13331333    FillWidth  = width;
    13341334    FillHeight = height -1;
    13351335    pLine = pDiveBuffer;
    13361336  }
    1337   dprintf(("0x%08X (%d/%d) at\n", pLine,FillWidth,FillHeight));
     1337  dprintf(("DDRAW: 0x%08X (%d/%d) at\n", pLine,FillWidth,FillHeight));
    13381338
    13391339  if(pDiveBuffer!=pFrameBuffer)
    … …  
    13731373  {
    13741374    case 1:
    1375       dprintf(("8 Bit\n"));
     1375      dprintf(("DDRAW: 8 Bit\n"));
    13761376      dwColor = (dwFillColor<<24) + (dwFillColor<<16) +
    13771377                (dwFillColor<<8)  + (dwFillColor);
    … …  
    13861386      break;
    13871387    case 2:
    1388       dprintf(("16 Bit\n"));
     1388      dprintf(("DDRAW: 16 Bit\n"));
    13891389      if(pDiveBuffer!=pFrameBuffer)
    13901390      {
    … …  
    13931393      }
    13941394      dwColor = (dwFillColor<<16) + (dwFillColor);
    1395       dprintf(("Fill with 0x%08X\n",dwColor));
     1395      dprintf(("DDRAW: Fill with 0x%08X\n",dwColor));
    13961396      for(i=0,pColor = (DWORD*)pLine;i<(FillWidth/2);i++)
    13971397        pColor[i] = dwColor;
    … …  
    14031403      break;
    14041404    case 3:
    1405       dprintf(("24 Bit\n"));
     1405      dprintf(("DDRAW: 24 Bit\n"));
    14061406
    14071407      dwColor = (dwFillColor<<8);
    … …  
    14131413      break;
    14141414    case 4:
    1415       dprintf(("32 Bit\n"));
     1415      dprintf(("DDRAW: 32 Bit\n"));
    14161416      dwColor = dwFillColor;
    14171417      for(i=0,pColor = (DWORD*)pLine;i<FillWidth;i++)
    … …  
    14201420    default:
    14211421      #ifdef DEBUG
    1422         dprintf(("Unexpected Bitdepth\n"));
     1422        dprintf(("DDRAW: Unexpected Bitdepth\n"));
    14231423      #endif
    14241424      return DDERR_GENERIC;
    … …  
    14481448    // Yeah! Color conversion needed ;)
    14491449    #ifdef DEBUG
    1450        dprintf(("Color converion ! Urks, may not work \n"));
     1450       dprintf(("DDRAW: Color converion ! Urks, may not work \n"));
    14511451    #endif
    14521452
    … …  
    14771477        {
    14781478          #ifdef DEBUG
    1479             dprintf(("Error creating Palette default to 0"));
     1479            dprintf(("DDRAW: Error creating Palette default to 0"));
    14801480          #endif
    14811481          ulColor = 0;
    … …  
    15771577      default:
    15781578        #ifdef DEBUG
    1579           dprintf(("Unexpected Bitdepth\n"));
     1579          dprintf(("DDRAW: Unexpected Bitdepth\n"));
    15801580        #endif
    15811581        return DDERR_GENERIC;
    … …  
    16591659  {
    16601660    case 8:
    1661       dprintf((" 8Bit target CC not implemented\n"));
     1661      dprintf(("DDRAW: 8Bit target CC not implemented\n"));
    16621662      break;
    16631663    case 15:
    1664       dprintf((" 15 Bit not implemented using 16bit might look ugly\n"));
     1664      dprintf(("DDRAW: 15 Bit not implemented using 16bit might look ugly\n"));
    16651665    case 16:
    16661666      if(8==lpDraw->GetScreenBpp())
    16671667      {
    1668         dprintf(("8->16Bit CC\n"));
     1668        dprintf(("DDRAW: 8->16Bit CC\n"));
    16691669        for(y=0;CCheight;CCheight--,y++)
    16701670        {
    … …  
    16801680      else
    16811681      {
    1682         dprintf(("%d ->16Bit Not implemented",lpDraw->GetScreenBpp()));
     1682        dprintf(("DDRAW: %d ->16Bit Not implemented",lpDraw->GetScreenBpp()));
    16831683      }
    16841684      break;
    … …  
    16861686      if(8==lpDraw->GetScreenBpp())
    16871687      {
    1688         dprintf(("8->24Bit CC"));
     1688        dprintf(("DDRAW: 8->24Bit CC"));
    16891689      }
    16901690      else
    16911691      {
    1692         dprintf(("%d ->24Bit Not implemented",lpDraw->GetScreenBpp()));
     1692        dprintf(("DDRAW: %d ->24Bit Not implemented",lpDraw->GetScreenBpp()));
    16931693      }
    16941694      break;
    … …  
    16961696      if(8==lpDraw->GetScreenBpp())
    16971697      {
    1698         dprintf(("8->32Bit CC"));
     1698        dprintf(("DDRAW: 8->32Bit CC"));
    16991699      }
    17001700      else
    17011701      {
    1702         dprintf(("%d ->32Bit Not implemented",lpDraw->GetScreenBpp()));
     1702        dprintf(("DDRAW: %d ->32Bit Not implemented",lpDraw->GetScreenBpp()));
    17031703      }
    17041704      break;
    … …  
    17611761                             dwPitchDB,
    17621762                             (PBYTE)pDiveBuffer);
    1763   dprintf(("AllocDiveDst Buffer rc= 0x%08X\n",rc));
     1763  dprintf(("DDRAW: AllocDiveDst Buffer rc= 0x%08X\n",rc));
    17641764
    17651765  rc = DiveSetupBlitter( hDiveCC,
    17661766                         &sBlt);
    1767   dprintf(("SetupBlitter rc= %X\n",rc));
     1767  dprintf(("DDRAW: SetupBlitter rc= %X\n",rc));
    17681768
    17691769  rc = DiveBlitImage( hDiveCC,
    … …  
    17711771                      ulDN2);
    17721772
    1773   dprintf(("Blit rc= %X\n",rc));
     1773  dprintf(("DDRAW: Blit rc= %X\n",rc));
    17741774
    17751775  rc = DiveFreeImageBuffer( hDiveCC,
    17761776                            ulDN1);
    1777   dprintf(("Free Src rc= %X\n",rc));
     1777  dprintf(("DDRAW: Free Src rc= %X\n",rc));
    17781778
    17791779  rc = DiveFreeImageBuffer( hDiveCC,
    17801780                            ulDN2);
    17811781
    1782   dprintf(("Free dst rc= %X\n",rc));
     1782  dprintf(("DDRAW: Free dst rc= %X\n",rc));
    17831783*/
    17841784}
    … …  
    18921892  {
    18931893
    1894     dprintf(("Remove Frontbuffer\n"));
     1894    dprintf(("DDRAW: Remove Frontbuffer\n"));
    18951895
    18961896    // The real Frontbuffer was removed check if I'm now the one
    18971897    if(NULL!=BackBuffer)
    18981898    {
    1899       dprintf(("We have the a backbuffer so we're the Frontbuffer\n"));
     1899      dprintf(("DDRAW: We have the a backbuffer so we're the Frontbuffer\n"));
    19001900      NextFlip = BackBuffer;
    19011901      DDSurfaceDesc.ddsCaps.dwCaps &= ~DDSCAPS_BACKBUFFER;
    … …  
    19061906    {
    19071907      // Flipchain is destroyed
    1908       dprintf(("No longer part of a flipchain\n"));
     1908      dprintf(("DDRAW: No longer part of a flipchain\n"));
    19091909      DDSurfaceDesc.ddsCaps.dwCaps &= ~(DDSCAPS_BACKBUFFER | DDSCAPS_FLIP);
    19101910    }
    … …  
    19121912  else
    19131913  {
    1914     dprintf(("Set new Frontbuffer to 0x%08X\n",NewFBuffer));
     1914    dprintf(("DDRAW: Set new Frontbuffer to 0x%08X\n",NewFBuffer));
    19151915    if(NULL==NewFBuffer->GetFrontBuffer())
    19161916    {
    1917       dprintf(("We're the 1st backbuffer\n"));
     1917      dprintf(("DDRAW: We're the 1st backbuffer\n"));
    19181918      DDSurfaceDesc.ddsCaps.dwCaps |=  DDSCAPS_BACKBUFFER | DDSCAPS_FLIP;
    19191919      FrontBuffer->NextFlip = this;
    … …  
    19211921    else
    19221922    {
    1923       dprintf(("We are oe of many buffers\n"));
     1923      dprintf(("DDRAW: We are oe of many buffers\n"));
    19241924      DDSurfaceDesc.ddsCaps.dwCaps &=  ~DDSCAPS_BACKBUFFER ;
    19251925      DDSurfaceDesc.ddsCaps.dwCaps |=  DDSCAPS_FLIP;
    … …  
    19401940  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    19411941
    1942   dprintf(("OS2IDirectDrawSurface::SurfQueryInterface\n"));
     1942  dprintf(("DDRAW: OS2IDirectDrawSurface::SurfQueryInterface\n"));
    19431943
    19441944  if(NULL==ppvObj)
    … …  
    19911991
    19921992  #ifdef DEBUG
    1993     dprintf(("OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
     1993    dprintf(("DDRAW: OS2IDirectDrawSurface::SurfAddRef %d\n", me->Referenced+1));
    19941994  #endif
    19951995
    … …  
    20032003
    20042004  #ifdef DEBUG
    2005     dprintf(("OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
    2006     dprintf(("OS2IDirectDrawSurface::Surface %X\n", me));
     2005    dprintf(("DDRAW: OS2IDirectDrawSurface::SurfRelease %d\n", me->Referenced-1));
     2006    dprintf(("DDRAW: OS2IDirectDrawSurface::Surface %X\n", me));
    20072007  #endif
    20082008  if(me->Referenced)
    … …  
    20292029
    20302030  #ifdef DEBUG
    2031     dprintf(("SurfAddAttachedSurface\n"));
     2031    dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    20322032  #endif
    20332033  return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
    … …  
    20392039
    20402040  #ifdef DEBUG
    2041     dprintf(("SurfAddAttachedSurface\n"));
     2041    dprintf(("DDRAW: SurfAddAttachedSurface\n"));
    20422042  #endif
    20432043  return SurfAddAttachedSurface4(This, (LPDIRECTDRAWSURFACE4)lpDDSurface);
    … …  
    20532053
    20542054  #ifdef DEBUG
    2055     dprintf(("SurfAddAttachedSurface4\n"));
     2055    dprintf(("DDRAW: SurfAddAttachedSurface4\n"));
    20562056  #endif
    20572057
    … …  
    20642064  {
    20652065    #ifdef DEBUG
    2066      dprintf(("Internal : Can't attach an implicit created surface to an other surface\n"));
     2066     dprintf(("DDRAW: Internal : Can't attach an implicit created surface to an other surface\n"));
    20672067    #endif
    20682068    return(DDERR_CANNOTATTACHSURFACE);
    … …  
    20722072  {
    20732073    #ifdef DEBUG
    2074      dprintf(("Can't attach an surface to itself\n"));
     2074     dprintf(("DDRAW: Can't attach an surface to itself\n"));
    20752075    #endif
    20762076    return(DDERR_CANNOTATTACHSURFACE);
    … …  
    20972097        {
    20982098          #ifdef DEBUG
    2099             dprintf(("Internal : Error attaching to MipMap\n"));
     2099            dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    21002100          #endif
    21012101          return(DDERR_CANNOTATTACHSURFACE);
    … …  
    21052105      {
    21062106        #ifdef DEBUG
    2107           dprintf(("Target Surface isn't a MipMap\n"));
     2107          dprintf(("DDRAW: Target Surface isn't a MipMap\n"));
    21082108        #endif
    21092109        return(DDERR_CANNOTATTACHSURFACE);
    … …  
    21232123      {
    21242124        #ifdef DEBUG
    2125           dprintf(("Internal : Error attaching to general Set\n"));
     2125          dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    21262126        #endif
    21272127        return(DDERR_CANNOTATTACHSURFACE);
    … …  
    21382138    {
    21392139      #ifdef DEBUG
    2140         dprintf(("Surfaces don't have same dimensions\n"));
     2140        dprintf(("DDRAW: Surfaces don't have same dimensions\n"));
    21412141      #endif
    21422142      return(DDERR_CANNOTATTACHSURFACE);
    … …  
    21492149        {
    21502150          #ifdef DEBUG
    2151             dprintf(("Surfaces already has a front/backbuffer\n"));
     2151            dprintf(("DDRAW: Surfaces already has a front/backbuffer\n"));
    21522152          #endif
    21532153          return(DDERR_SURFACEALREADYATTACHED);
    … …  
    21842184        {
    21852185          #ifdef DEBUG
    2186             dprintf(("Can't attach backbuffer to anything but a frontbuffer\n"));
     2186            dprintf(("DDRAW: Can't attach backbuffer to anything but a frontbuffer\n"));
    21872187          #endif
    21882188         return(DDERR_CANNOTATTACHSURFACE);
    … …  
    22082208            {
    22092209              #ifdef DEBUG
    2210                 dprintf(("Internal : Error attaching to MipMap\n"));
     2210                dprintf(("DDRAW: Internal : Error attaching to MipMap\n"));
    22112211              #endif
    22122212              return(DDERR_CANNOTATTACHSURFACE);
    … …  
    22162216          {
    22172217            #ifdef DEBUG
    2218               dprintf(("Tagget Surface isn't a MipMap\n"));
     2218              dprintf(("DDRAW: Tagget Surface isn't a MipMap\n"));
    22192219            #endif
    22202220           return(DDERR_CANNOTATTACHSURFACE);
    … …  
    22322232          {
    22332233            #ifdef DEBUG
    2234               dprintf(("Internal : Error attaching to general Set\n"));
     2234              dprintf(("DDRAW: Internal : Error attaching to general Set\n"));
    22352235            #endif
    22362236            return(DDERR_CANNOTATTACHSURFACE);
    … …  
    22402240    }
    22412241  }
    2242   dprintf(("Surface attached\n"));
     2242  dprintf(("DDRAW: Surface attached\n"));
    22432243  return(DD_OK);
    22442244}
    … …  
    22482248{
    22492249  #ifdef DEBUG
    2250     dprintf(("SurfAddOverlayDirtyRect Not implemented by M$ in V 6.0! \n"));
     2250    dprintf(("DDRAW: SurfAddOverlayDirtyRect Not implemented by M$ in V 6.0! \n"));
    22512251  #endif
    22522252
    … …  
    23132313  #ifdef DEBUG
    23142314    if ( (NULL!=lpDestRect)&& (NULL!=lpSrcRect))
    2315       dprintf(("SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
     2315      dprintf(("DDRAW: SurfBlt4 to (%d,%d)(%d,%d) at %08X from (%d,%d)(%d,%d) at %08X\n", lpDestRect->left, lpDestRect->top,
    23162316               lpDestRect->right, lpDestRect->bottom, dest, lpSrcRect->left, lpSrcRect->top,
    23172317               lpSrcRect->right, lpSrcRect->bottom, src));
    … …  
    24162416      delete pIRectDest;
    24172417      #ifdef DEBUG
    2418         dprintf(("Blt: Dest Surface partly locked\n"));
     2418        dprintf(("DDRAW: Blt: Dest Surface partly locked\n"));
    24192419      #endif
    24202420      return(DDERR_SURFACEBUSY);
    … …  
    24312431  if(dwFlags & DDBLT_COLORFILL)
    24322432  {
    2433     dprintf(("ColorFill\n"));
     2433    dprintf(("DDRAW: ColorFill\n"));
    24342434    if((NULL==lpDDBltFx)||(lpDDBltFx->dwSize!=sizeof(DDBLTFX)) )
    24352435      return DDERR_INVALIDPARAMS;
    … …  
    24452445  if (dwFlags & DDBLT_DEPTHFILL)
    24462446  {
    2447     dprintf(("DepthFill\n"));
     2447    dprintf(("DDRAW: DepthFill\n"));
    24482448  #ifdef USE_OPENGL
    24492449    GLboolean ztest;
    24502450    // Todo support more than one Z-Buffer
    24512451    // Clears the screen
    2452     dprintf(("Filling depth buffer with %ld\n", lpbltfx->b.dwFillDepth));
     2452    dprintf(("DDRAW: Filling depth buffer with %ld\n", lpbltfx->b.dwFillDepth));
    24532453    glClearDepth(lpDDBltFx->b.dwFillDepth / 65535.0); // We suppose a 16 bit Z Buffer
    24542454    glGetBooleanv(GL_DEPTH_TEST, &ztest);
    … …  
    25032503  {
    25042504    #ifdef DEBUG
    2505       dprintf(("Unsupported sourceless FX operation. Flags = 0x%04X\n",dwFlags));
     2505      dprintf(("DDRAW: Unsupported sourceless FX operation. Flags = 0x%04X\n",dwFlags));
    25062506    #endif
    25072507    return DD_OK;
    … …  
    26022602      delete pIRectSrc;
    26032603      #ifdef DEBUG
    2604         dprintf(("Blt: Src Surface partly locked\n"));
     2604        dprintf(("DDRAW: Blt: Src Surface partly locked\n"));
    26052605      #endif
    26062606      return(DDERR_SURFACEBUSY);
    … …  
    26122612  {
    26132613    #ifdef DEBUG
    2614       dprintf(("Blitting with scaleing\n Not supported.\n"));
     2614      dprintf(("DDRAW: Blitting with scaleing\n Not supported.\n"));
    26152615    #endif
    26162616    return DDERR_NOSTRETCHHW;
    … …  
    26222622  {
    26232623    // Stretching not supported
    2624     dprintf(("No stretched blits\n"));
     2624    dprintf(("DDRAW: No stretched blits\n"));
    26252625
    26262626    return DDERR_NOSTRETCHHW;
    … …  
    26292629  if (dest->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    26302630  {
    2631     dprintf(("Dest is Primary Surface\n"));
     2631    dprintf(("DDRAW: Dest is Primary Surface\n"));
    26322632    if(src->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
    26332633    {
    26342634      // special Type 1 : Bliting between parts of the screen
    26352635
    2636       dprintf(("Src is Primary Surface\n"));
     2636      dprintf(("DDRAW: Src is Primary Surface\n"));
    26372637
    26382638      if( *pIRectDest == *pIRectSrc)
    … …  
    26532653      if( src->diveBufNr>0)
    26542654      {
    2655 
     2655        dprintf(("DDRAW: DIVE Blit of all"));
    26562656        if( (NULL==lpSrcRect)&&( NULL== lpDestRect))
    26572657        {
    … …  
    26812681      if(!dwFlags)
    26822682      {
     2683        dprintf(("DDRAW: Solid Blit\n"));
     2684
    26832685        BlitWidth *= dest->dwBytesPPDive;
    26842686
    … …  
    26982700        }
    26992701        #endif
     2702
     2703        if(dest->pFrameBuffer != dest->pDiveBuffer)
     2704        {
     2705          // Copy Framebuffer also ...
     2706          pBltPos = (char*) dest->pFrameBuffer + (DestRect.top * dest->dwPitchFB) +
     2707                    (DestRect.left * dest->lpDraw->GetScreenBpp());
     2708
     2709          pSrcPos = (char*) src->pFrameBuffer + (SrcRect.top * src->dwPitchFB) +
     2710                    (SrcRect.left * dest->lpDraw->GetScreenBpp());
     2711
     2712          BlitHeight = pIRectDest->height();
     2713          BlitWidth  = pIRectDest->width();
     2714          BlitWidth *= dest->lpDraw->GetScreenBpp();
     2715
     2716          #ifdef USE_ASM
     2717          BltRec(pBltPos, pSrcPos, BlitWidth, BlitHeight,
     2718                 dest->dwPitchDB,
     2719                 src->dwPitchDB);
     2720          #else
     2721          // Solid Blit
     2722          while(1)
     2723          {
     2724            memcpy(pBltPos,pSrcPos,BlitWidth);
     2725            pBltPos += dest->dwPitchFB;
     2726            pSrcPos += src->dwPitchFB;
     2727            if(! (--BlitHeight))
     2728              break;
     2729          }
     2730          #endif
     2731        }
    27002732      }
    27012733      else
    … …  
    27042736        if( (dwFlags &DDBLT_KEYSRC) || (dwFlags & DDBLT_KEYSRCOVERRIDE) )
    27052737        {
    2706           dprintf(("Transparent src blit not done yet for primary!!"));
     2738          dprintf(("DDRAW: Transparent src blit not done yet for primary!!"));
    27072739        }
    27082740        else
    27092741        {
    2710           dprintf(("Unhandled Flags Destination colorkey ? 0x%04X",dwFlags));
     2742          dprintf(("DDRAW: Unhandled Flags Destination colorkey ? 0x%04X",dwFlags));
    27112743        }
    27122744      }
    … …  
    27632795        else
    27642796        {
    2765           dprintf(("Transblt not done yet"));
     2797          dprintf(("DDRAW: Transblt not done yet"));
    27662798          if(dwFlags & DDBLT_KEYSRC)
    27672799          {
    … …  
    32293261{
    32303262  #ifdef DEBUG
    3231     dprintf(("SurfBltBatch Not implemented by M$\n"));
     3263    dprintf(("DDRAW: SurfBltBatch Not implemented by M$\n"));
    32323264  #endif
    32333265
    … …  
    32433275                               DWORD dwTrans)
    32443276{
    3245   dprintf(("SurfBltFast=>"));
     3277  dprintf(("DDRAW: SurfBltFast=>"));
    32463278  return SurfBltFast4( This,
    32473279                       dwX,
    … …  
    32603292                               DWORD dwTrans)
    32613293{
    3262   dprintf(("SurfBltFast3=>"));
     3294  dprintf(("DDRAW: SurfBltFast3=>"));
    32633295  return SurfBltFast4( This,
    32643296                       dwX,
    … …  
    32843316
    32853317  #ifdef DEBUG
    3286     dprintf(("SurfBltFast4 %08X at(%d/%d) onto %08X with flags %08X\n",src, dwX,dwY, dest, dwTrans));
     3318    dprintf(("DDRAW: SurfBltFast4 %08X at(%d/%d) onto %08X with flags %08X\n",src, dwX,dwY, dest, dwTrans));
    32873319  #endif
    32883320
    … …  
    32923324      (dwY>dest->height))
    32933325  {
    3294     dprintf(("Invalid Parameters %08X, %d %d", lpDDSrcSurface ,dest->width , dest->height));
     3326    dprintf(("DDRAW: Invalid Parameters %08X, %d %d", lpDDSrcSurface ,dest->width , dest->height));
    32953327    return DDERR_INVALIDPARAMS;
    32963328  }
    … …  
    33463378  else
    33473379  {
    3348     dprintf(("TransBlit\n"));
     3380    dprintf(("DDRAW: TransBlit\n"));
    33493381
    33503382    if(dwTrans & DDBLTFAST_SRCCOLORKEY)
    33513383    {
    3352       dprintf(("Trans SRC\n"));
     3384      dprintf(("DDRAW: Trans SRC\n"));
    33533385      // transparent source
    33543386      dwSrcColor = src->DDSurfaceDesc.ddckCKSrcBlt.dwColorSpaceLowValue;
    33553387      if(dwTrans & DDBLTFAST_DESTCOLORKEY)
    33563388      {
    3357         dprintf(("And Dest Colorkey"));
     3389        dprintf(("DDRAW: And Dest Colorkey"));
    33583390        dwDestColor = dest->DDSurfaceDesc.ddckCKDestBlt.dwColorSpaceLowValue;
    33593391        // Source and dest colorkeying
    … …  
    34523484        // This MMX detection should be moved into OS2Draw
    34533485        // and into the surface constructor a setup for blitting pointers
    3454         dprintf(("Only Src ColorKey"));
     3486        dprintf(("DDRAW: Only Src ColorKey"));
    34553487        switch(dest->dwBytesPPDive)
    34563488        {
    … …  
    35233555      if(dwTrans & DDBLTFAST_DESTCOLORKEY)
    35243556      {
    3525         dprintf(("DestColorKey\n"));
     3557        dprintf(("DDRAW: DestColorKey\n"));
    35263558
    35273559        dwDestColor = dest->DDSurfaceDesc.ddckCKDestBlt.dwColorSpaceLowValue;
    … …  
    36033635      else
    36043636      {
    3605         dprintf(("Unexpected Flags"));
     3637        dprintf(("DDRAW: Unexpected Flags"));
    36063638      }
    36073639    }
    … …  
    36193651  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    36203652  #ifdef DEBUG
    3621     dprintf(("SurfDeleteAttachedSurface\n"));
     3653    dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    36223654  #endif
    36233655
    … …  
    36303662  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    36313663  #ifdef DEBUG
    3632     dprintf(("SurfDeleteAttachedSurface\n"));
     3664    dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    36333665  #endif
    36343666
    … …  
    36473679  BOOL Found = FALSE;
    36483680  #ifdef DEBUG
    3649     dprintf(("SurfDeleteAttachedSurface\n"));
     3681    dprintf(("DDRAW: SurfDeleteAttachedSurface\n"));
    36503682  #endif
    36513683
    … …  
    37893821  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    37903822  #ifdef DEBUG
    3791     dprintf(("SurfEnumAttachedSurfaces\n"));
     3823    dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    37923824  #endif
    37933825
    … …  
    38053837
    38063838  #ifdef DEBUG
    3807     dprintf(("SurfEnumAttachedSurfaces\n"));
     3839    dprintf(("DDRAW: SurfEnumAttachedSurfaces\n"));
    38083840  #endif
    38093841  if (NULL==lpCallBack)
    … …  
    38583890HRESULT __stdcall SurfEnumOverlayZOrders(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK)
    38593891{
    3860   dprintf(("SurfEnumOverlayZOrders\n"));
     3892  dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
    38613893
    38623894  return(DD_OK);
    … …  
    38663898HRESULT __stdcall SurfEnumOverlayZOrders4(THIS, DWORD,LPVOID,LPDDENUMSURFACESCALLBACK2)
    38673899{
    3868   dprintf(("SurfEnumOverlayZOrders\n"));
     3900  dprintf(("DDRAW: SurfEnumOverlayZOrders\n"));
    38693901
    38703902  return(DD_OK);
    … …  
    38763908  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    38773909
    3878   dprintf(("SurfFlip\n"));
     3910  dprintf(("DDRAW: SurfFlip\n"));
    38793911
    38803912  return(SurfFlip4(me, (LPDIRECTDRAWSURFACE4) lpDDSurf, dwFlags));
    … …  
    38863918  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    38873919
    3888   dprintf(("SurfFlip\n"));
     3920  dprintf(("DDRAW: SurfFlip\n"));
    38893921
    38903922  return(SurfFlip4(me, (LPDIRECTDRAWSURFACE4) lpDDSurf, dwFlags));
    … …  
    39013933  ULONG rc;
    39023934
    3903   dprintf(("SurfFlip4\n"));
     3935  dprintf(("DDRAW: SurfFlip4\n"));
    39043936
    39053937  if(!((me->DDSurfaceDesc.ddsCaps.dwCaps & DDSCAPS_FRONTBUFFER) &&
    … …  
    39083940  {
    39093941    #ifdef DEBUG
    3910       dprintf(("Flip called on none Frontbuffer/Flip surface\n Flags:\n"));
     3942      dprintf(("DDRAW: Flip called on none Frontbuffer/Flip surface\n Flags:\n"));
    39113943      _dump_DDSCAPS(me->DDSurfaceDesc.ddsCaps.dwCaps);
    3912       dprintf(("\n"));
     3944      dprintf(("DDRAW: \n"));
    39133945    #endif
    39143946    return(DDERR_NOTFLIPPABLE);
    … …  
    39173949  if(NULL!=lpDDSurf)
    39183950  {
    3919     dprintf(("Check if Surface is in Flipchain!\n"));
     3951    dprintf(("DDRAW: Check if Surface is in Flipchain!\n"));
    39203952
    39213953    // We got an override surface check if it is in the flipchain
    … …  
    39293961    if(FlipCursor!=FlipSurface)
    39303962    {
    3931       dprintf(("Surface not in Flipchain!\n"));
     3963      dprintf(("DDRAW: Surface not in Flipchain!\n"));
    39323964
    39333965      return (DDERR_INVALIDPARAMS); // Not sure if the returnvalue is right
    … …  
    39373969  {
    39383970    FlipSurface = me->NextFlip; // Take the next Surface in the Flipchain
    3939     dprintf(("Next Surface @ 0x%08X\n",FlipSurface));
     3971    dprintf(("DDRAW: Next Surface @ 0x%08X\n",FlipSurface));
    39403972  }
    39413973
    39423974  if((me->fLocked)||(FlipSurface->fLocked))
    39433975  {
    3944     dprintf(("Locked surface(s) Dest %d Src %d\n",me->fLocked,FlipSurface->fLocked));
     3976    dprintf(("DDRAW: Locked surface(s) Dest %d Src %d\n",me->fLocked,FlipSurface->fLocked));
    39453977
    39463978    return(DDERR_SURFACEBUSY);
    … …  
    39493981  if(-1 != me->diveBufNr)
    39503982  {
    3951     dprintf(("DIVE Flipchain"));
     3983    dprintf(("DDRAW: DIVE Flipchain"));
    39523984
    39533985    // we got some DIVE surfaces
    … …  
    39593991
    39603992    #ifdef DEBUG
    3961       dprintf(("DiveBlitImage rc = 0x%08X\n"));
     3993      dprintf(("DDRAW: DiveBlitImage rc = 0x%08X\n"));
    39623994    #endif
    39633995
    … …  
    39714003  {
    39724004    #ifdef DEBUG
    3973       dprintf(("Memory Flipchain"));
     4005      dprintf(("DDRAW: Memory Flipchain"));
    39744006    #endif
    39754007    // Memory Flipchain
    … …  
    40244056  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    40254057  #ifdef DEBUG
    4026     dprintf(("SurfGetAttachedSurface\n"));
     4058    dprintf(("DDRAW: SurfGetAttachedSurface\n"));
    40274059  #endif
    40284060
    … …  
    40364068  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    40374069  #ifdef DEBUG
    4038     dprintf(("SurfGetAttachedSurface3\n"));
     4070    dprintf(("DDRAW: SurfGetAttachedSurface3\n"));
    40394071  #endif
    40404072
    … …  
    40534085
    40544086  #ifdef DEBUG
    4055     dprintf(("SurfGetAttachedSurface4\n>Requested Caps: "));
     4087    dprintf(("DDRAW: SurfGetAttachedSurface4\n>Requested Caps: "));
    40564088    _dump_DDSCAPS(lpDDCaps->dwCaps);
    4057     dprintf(("\n"));
     4089    dprintf(("DDRAW: \n"));
    40584090  #endif
    40594091
    40604092  if( (NULL==lpDDCaps)||(NULL==lpDDSurf))
    40614093  {
    4062     dprintf(("Invalid params\n\n"));
     4094    dprintf(("DDRAW: Invalid params\n\n"));
    40634095    return (DDERR_INVALIDPARAMS);
    40644096  }
    … …  
    40704102      (me->BackBuffer->DDSurfaceDesc.ddsCaps.dwCaps & lpDDCaps->dwCaps) )
    40714103  {
    4072     dprintf(("Return Backbuffer\n"));
     4104    dprintf(("DDRAW: Return Backbuffer\n"));
    40734105    AttachedSurface = me->BackBuffer;
    40744106  }
    … …  
    41334165{
    41344166  #ifdef DEBUG
    4135     dprintf(("SurfGetBltStatus\n"));
     4167    dprintf(("DDRAW: SurfGetBltStatus\n"));
    41364168  #endif
    41374169
    … …  
    41454177
    41464178  #ifdef DEBUG
    4147     dprintf(("SurfGetCaps\n"));
     4179    dprintf(("DDRAW: SurfGetCaps\n"));
    41484180  #endif
    41494181
    … …  
    41634195  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    41644196  #ifdef DEBUG
    4165     dprintf(("SurfGetCaps4\n"));
     4197    dprintf(("DDRAW: SurfGetCaps4\n"));
    41664198  #endif
    41674199
    … …  
    41854217
    41864218  #ifdef DEBUG
    4187     dprintf(("SurfGetClipper\n"));
     4219    dprintf(("DDRAW: SurfGetClipper\n"));
    41884220  #endif
    41894221
    … …  
    42034235
    42044236#ifdef DEBUG
    4205   dprintf(("SurfGetColorKey\n"));
     4237  dprintf(("DDRAW: SurfGetColorKey\n"));
    42064238#endif
    42074239
    … …  
    42424274
    42434275  #ifdef DEBUG
    4244     dprintf(("SurfGetDC\n"));
     4276    dprintf(("DDRAW: SurfGetDC\n"));
    42454277  #endif
    42464278
    … …  
    42644296    {
    42654297      #ifdef DEBUG
    4266         dprintf(("Can't create compatible DC!\n"));
     4298        dprintf(("DDRAW: Can't create compatible DC!\n"));
    42674299      #endif
    42684300      me->Vtbl.Unlock(me,NULL);
    … …  
    42984330      case 1:
    42994331      case 4:
    4300         dprintf(("1/4 Bit Not yet supported\n"));
     4332        dprintf(("DDRAW: 1/4 Bit Not yet supported\n"));
    43014333        break;
    43024334      case 8:
    … …  
    43174349      case 16:
    43184350      case 32:
    4319         dprintf(("16/32 Bit not supported by OS/2"));
     4351        dprintf(("DDRAW: 16/32 Bit not supported by OS/2"));
    43204352        break;
    43214353      case 24:
    … …  
    43444376    {
    43454377      #ifdef DEBUG
    4346         dprintf(("Can't create bitmap!\n"));
     4378        dprintf(("DDRAW: Can't create bitmap!\n"));
    43474379      #endif
    43484380      DeleteDC(me->hdcImage);
    … …  
    43584390    {
    43594391      #ifdef DEBUG
    4360         dprintf(("The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
     4392        dprintf(("DDRAW: The Surface was locked/unlocked after the last DC was created =>Update Bitmap!\n"));
    43614393      #endif
    43624394
    … …  
    43954427        default:
    43964428          #ifdef DEBUG
    4397             dprintf(("Unexptected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
     4429            dprintf(("DDRAW: Unexptected BitCount %d => Bitmap not updated!\n",LockedSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    43984430          #endif
    43994431          break;
    … …  
    44104442    {
    44114443      #ifdef DEBUG
    4412         dprintf(("Can't select bitmap into dc!\n"));
     4444        dprintf(("DDRAW: Can't select bitmap into dc!\n"));
    44134445      #endif
    44144446      DeleteDC(me->hdcImage);
    … …  
    44324464{
    44334465  #ifdef DEBUG
    4434     dprintf(("SurfGetFlipStatus\n"));
     4466    dprintf(("DDRAW: SurfGetFlipStatus\n"));
    44354467  #endif
    44364468
    … …  
    44464478  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    44474479  #ifdef DEBUG
    4448     dprintf(("SurfGetOverlayPosition\n"));
     4480    dprintf(("DDRAW: SurfGetOverlayPosition\n"));
    44494481  #endif
    44504482
    … …  
    44754507
    44764508  #ifdef DEBUG
    4477     dprintf(("SurfGetPalette\n"));
     4509    dprintf(("DDRAW: SurfGetPalette\n"));
    44784510  #endif
    44794511
    … …  
    44934525
    44944526  #ifdef DEBUG
    4495     dprintf(("SurfGetPixelFormat\n"));
     4527    dprintf(("DDRAW: SurfGetPixelFormat\n"));
    44964528  #endif
    44974529
    … …  
    45124544
    45134545  #ifdef DEBUG
    4514     dprintf(("SurfGetSurfaceDesc\n"));
     4546    dprintf(("DDRAW: SurfGetSurfaceDesc\n"));
    45154547  #endif
    45164548
    … …  
    45314563
    45324564  #ifdef DEBUG
    4533     dprintf(("SurfGetSurfaceDesc4\n"));
     4565    dprintf(("DDRAW: SurfGetSurfaceDesc4\n"));
    45344566  #endif
    45354567
    … …  
    45484580{
    45494581  #ifdef DEBUG
    4550     dprintf(("SurfInitialize\n"));
     4582    dprintf(("DDRAW: SurfInitialize\n"));
    45514583  #endif
    45524584
    … …  
    45584590{
    45594591  #ifdef DEBUG
    4560     dprintf(("SurfInitialize\n"));
     4592    dprintf(("DDRAW: SurfInitialize\n"));
    45614593  #endif
    45624594
    … …  
    45724604  //
    45734605  #ifdef DEBUG
    4574     dprintf(("SurfIsLost\n"));
     4606    dprintf(("DDRAW: SurfIsLost\n"));
    45754607  #endif
    45764608
    … …  
    45894621
    45904622  #ifdef DEBUG
    4591     dprintf(("SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
     4623    dprintf(("DDRAW: SurfLock %d %08X %d %d\n", (int)lpRect, (int)lpSurfaceDesc, dwFlags, hEvent));
    45924624  #endif
    45934625
    … …  
    46674699    {
    46684700      // If anything is locked we can't locke the complete surface
    4669       dprintf(("Surface has locked Rectangles, and we want to complete lock it\n"));
     4701      dprintf(("DDRAW: Surface has locked Rectangles, and we want to complete lock it\n"));
    46704702      Found = TRUE;
    46714703    }
    … …  
    46754707      // be locked so check for this
    46764708
    4677       dprintf(("Surface has locked Rectangles, check if the overlap\n"));
     4709      dprintf(("DDRAW: Surface has locked Rectangles, check if the overlap\n"));
    46784710
    46794711      i=0;
    … …  
    46984730      delete pIRectNew;
    46994731      #ifdef DEBUG
    4700         dprintf(("SurfLock4: Surface already locked\n\n"));
     4732        dprintf(("DDRAW: SurfLock4: Surface already locked\n\n"));
    47014733      #endif
    47024734      rc = DDERR_SURFACEBUSY;
    … …  
    47154747                                  (lpRect->left * (lpSurfaceDesc->ddpfPixelFormat.dwRGBBitCount>>3)));
    47164748      #ifdef DEBUG
    4717         dprintf(("SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
     4749        dprintf(("DDRAW: SurfLock4 %08X (x,y) = (%d,%d)\n\n", lpSurfaceDesc->lpSurface, lpRect->top, lpRect->left));
    47184750      #endif
    47194751    }
    … …  
    47214753    {
    47224754      #ifdef DEBUG
    4723         dprintf(("SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
     4755        dprintf(("DDRAW: SurfLock4 %08X \n\n", lpSurfaceDesc->lpSurface));
    47244756      #endif
    47254757    }
    … …  
    47534785
    47544786  #ifdef DEBUG
    4755     dprintf(("SurfReleaseDC\n"));
     4787    dprintf(("DDRAW: SurfReleaseDC\n"));
    47564788  #endif
    47574789
    … …  
    48234855    default:
    48244856      #ifdef DEBUG
    4825         dprintf(("Unexptected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
     4857        dprintf(("DDRAW: Unexptected BitCount %d => Surface unlocked but no data copied back\n",me->DDSurfaceDesc.ddpfPixelFormat.dwRGBBitCount));
    48264858      #endif
    48274859      // we might could keep the surface locked and return an error but this is more "safe"
    … …  
    48504882{
    48514883  #ifdef DEBUG
    4852     dprintf(("SurfRestore\n"));
     4884    dprintf(("DDRAW: SurfRestore\n"));
    48534885  #endif
    48544886
    … …  
    48624894
    48634895  #ifdef DEBUG
    4864     dprintf(("SurfSetClipper\n"));
     4896    dprintf(("DDRAW: SurfSetClipper\n"));
    48654897  #endif
    48664898
    … …  
    48994931  HRESULT rc;
    49004932  #ifdef DEBUG
    4901     dprintf(("SurfSetColorKey\n"));
     4933    dprintf(("DDRAW: SurfSetColorKey\n"));
    49024934  #endif
    49034935
    … …  
    49394971
    49404972  #ifdef DEBUG
    4941     dprintf(("SurfSetOverlayPosition\n"));
     4973    dprintf(("DDRAW: SurfSetOverlayPosition\n"));
    49424974  #endif
    49434975
    … …  
    49685000
    49695001  #ifdef DEBUG
    4970     dprintf(("SurfSetPalette\n"));
     5002    dprintf(("DDRAW: SurfSetPalette\n"));
    49715003  #endif
    49725004
    … …  
    50315063
    50325064  #ifdef DEBUG
    5033     dprintf(("SurfUnlock at %08X\n",lpSurfaceData));
     5065    dprintf(("DDRAW: SurfUnlock at %08X\n",lpSurfaceData));
    50345066  #endif
    50355067
    … …  
    50375069  {
    50385070    #ifdef DEBUG
    5039       dprintf(("Surface not locked!\n"));
     5071      dprintf(("DDRAW: Surface not locked!\n"));
    50405072    #endif
    50415073    return(DDERR_NOTLOCKED);
    … …  
    50435075
    50445076  #ifdef DEBUG
    5045     dprintf(("Start Emuneration of Locked Rects\n"));
     5077    dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
    50465078  #endif
    50475079
    … …  
    50495081  if(NULL!=lpSurfaceData)
    50505082  {
    5051     dprintf(("Buffer Pointer Compare"));
     5083    dprintf(("DDRAW: Buffer Pointer Compare"));
    50525084
    50535085    // We got a pinter to the surface memory so we must search for
    … …  
    50695101      {
    50705102        #ifdef DEBUG
    5071           dprintf(("Not Found, try Next rect\n"));
     5103          dprintf(("DDRAW: Not Found, try Next rect\n"));
    50725104        #endif
    50735105        i++;
    … …  
    50765108      else
    50775109      {
    5078         dprintf(("Found Rect\n"));
     5110        dprintf(("DDRAW: Found Rect\n"));
    50795111      }
    50805112      #endif
    … …  
    50855117    // If a NULL pointer was passed in the SW tries to unlock the
    50865118    // complete surface so we must compare the rects.
    5087     dprintf(("Rectangle compare"));
     5119    dprintf(("DDRAW: Rectangle compare"));
    50885120
    50895121    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
    … …  
    51045136      {
    51055137        #ifdef DEBUG
    5106           dprintf(("Not Found, try Next rect\n"));
     5138          dprintf(("DDRAW: Not Found, try Next rect\n"));
    51075139        #endif
    51085140        i++;
    … …  
    51115143      else
    51125144      {
    5113         dprintf(("Found Rect\n"));
     5145        dprintf(("DDRAW: Found Rect\n"));
    51145146      }
    51155147      #endif
    … …  
    51215153  {
    51225154    #ifdef DEBUG
    5123       dprintf(("Rectangle not locked, wrong Rect!\n\n"));
     5155      dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    51245156    #endif
    51255157    rc = DDERR_INVALIDRECT;
    … …  
    51285160  {
    51295161    #ifdef DEBUG
    5130       dprintf(("Remove Rect %d from Seq.\n",i));
     5162      dprintf(("DDRAW: Remove Rect %d from Seq.\n",i));
    51315163    #endif
    51325164
    … …  
    51345166
    51355167    #ifdef DEBUG
    5136       dprintf(("Test if locked Rects main\n"));
     5168      dprintf(("DDRAW: Test if locked Rects main\n"));
    51375169    #endif
    51385170
    … …  
    51405172    {
    51415173      #ifdef DEBUG
    5142         dprintf(("No Locked Rects left for surface\n"));
     5174        dprintf(("DDRAW: No Locked Rects left for surface\n"));
    51435175      #endif
    51445176      me->fLocked = FALSE;
    … …  
    51815213    // me->lpVtbl->ChangeUniquenessValue(me);
    51825214
    5183     dprintf(("Unlock OK\n\n"));
     5215    dprintf(("DDRAW: Unlock OK\n\n"));
    51845216
    51855217    rc = DD_OK;
    … …  
    52075239
    52085240  #ifdef DEBUG
    5209     dprintf(("SurfUnlock4\n"));
     5241    dprintf(("DDRAW: SurfUnlock4\n"));
    52105242  #endif
    52115243
    … …  
    52135245  {
    52145246    #ifdef DEBUG
    5215       dprintf(("Surface not locked!\n"));
     5247      dprintf(("DDRAW: Surface not locked!\n"));
    52165248    #endif
    52175249    return(DDERR_NOTLOCKED);
    … …  
    52205252  if(NULL!=lpSurfaceRect)
    52215253  {
    5222     dprintf(("Unlock rectangle\n"));
     5254    dprintf(("DDRAW: Unlock rectangle\n"));
    52235255    pIRectUnlock = new DDRectangle( lpSurfaceRect->top,
    52245256                                    lpSurfaceRect->left,
    … …  
    52285260  else
    52295261  {
    5230     dprintf(("Unlock complete surface\n"));
     5262    dprintf(("DDRAW: Unlock complete surface\n"));
    52315263    pIRectUnlock = new DDRectangle( 0, 0, me->height, me->width);
    52325264  }
    … …  
    52395271
    52405272  #ifdef DEBUG
    5241     dprintf(("Start Emuneration of Locked Rects\n"));
     5273    dprintf(("DDRAW: Start Emuneration of Locked Rects\n"));
    52425274  #endif
    52435275
    … …  
    52565288    {
    52575289      #ifdef DEBUG
    5258         dprintf(("Not Found, try Next rect\n"));
     5290        dprintf(("DDRAW: Not Found, try Next rect\n"));
    52595291      #endif
    52605292      i++;
    … …  
    52635295    else
    52645296    {
    5265       dprintf(("Found Rect\n"));
     5297      dprintf(("DDRAW: Found Rect\n"));
    52665298    }
    52675299    #endif
    … …  
    52745306    {
    52755307      #ifdef DEBUG
    5276         dprintf(("Rectangle not locked, wrong Rect!\n\n"));
     5308        dprintf(("DDRAW: Rectangle not locked, wrong Rect!\n\n"));
    52775309      #endif
    52785310      return(DDERR_INVALIDRECT);
    … …  
    52845316  {
    52855317    #ifdef DEBUG
    5286       dprintf(("Remove Rect from Seq.\n"));
     5318      dprintf(("DDRAW: Remove Rect from Seq.\n"));
    52875319    #endif
    52885320
    … …  
    52925324    {
    52935325      #ifdef DEBUG
    5294         dprintf(("No Locked Rects left for surface\n"));
     5326        dprintf(("DDRAW: No Locked Rects left for surface\n"));
    52955327      #endif
    52965328      me->fLocked = FALSE;
    … …  
    53095341    // me->lpVtbl->ChangeUniquenessValue(me);
    53105342
    5311     dprintf(("Unlock OK\n\n"));
     5343    dprintf(("DDRAW: Unlock OK\n\n"));
    53125344    rc = DD_OK;
    53135345  }
    … …  
    53205352{
    53215353  #ifdef DEBUG
    5322     dprintf(("SurfUpdateOverlay\n"));
     5354    dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53235355  #endif
    53245356  return(DD_OK);
    … …  
    53295361{
    53305362  #ifdef DEBUG
    5331     dprintf(("SurfUpdateOverlay\n"));
     5363    dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53325364  #endif
    53335365  return(DD_OK);
    … …  
    53385370{
    53395371  #ifdef DEBUG
    5340     dprintf(("SurfUpdateOverlay\n"));
     5372    dprintf(("DDRAW: SurfUpdateOverlay\n"));
    53415373  #endif
    53425374  return(DD_OK);
    … …  
    53475379{
    53485380  #ifdef DEBUG
    5349     dprintf(("SurfUpdateOverlayDisplay\n"));
     5381    dprintf(("DDRAW: SurfUpdateOverlayDisplay\n"));
    53505382  #endif
    53515383  return(DD_OK);
    … …  
    53565388{
    53575389  #ifdef DEBUG
    5358     dprintf(("SurfUpdateOverlayZOrder\n"));
     5390    dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    53595391  #endif
    53605392  return(DD_OK);
    … …  
    53655397{
    53665398  #ifdef DEBUG
    5367     dprintf(("SurfUpdateOverlayZOrder\n"));
     5399    dprintf(("DDRAW: SurfUpdateOverlayZOrder\n"));
    53685400  #endif
    53695401  return(DD_OK);
    … …  
    53745406{
    53755407  #ifdef DEBUG
    5376     dprintf(("SurfUpdateOverlayZOrder4\n"));
     5408    dprintf(("DDRAW: SurfUpdateOverlayZOrder4\n"));
    53775409  #endif
    53785410  return(DD_OK);
    … …  
    53855417
    53865418  #ifdef DEBUG
    5387     dprintf(("SurfGetDDInterface\n"));
     5419    dprintf(("DDRAW: SurfGetDDInterface\n"));
    53885420  #endif
    53895421  *lplpDirectDraw = (LPVOID FAR *)me->lpDraw;
    … …  
    53985430  // from malloc to DosAllocMem and use OBJ_TILE flag
    53995431  #ifdef DEBUG
    5400     dprintf(("SurfPageLock\n"));
     5432    dprintf(("DDRAW: SurfPageLock\n"));
    54015433  #endif
    54025434  return(DD_OK);
    … …  
    54075439{
    54085440  #ifdef DEBUG
    5409     dprintf(("SurfPageUnlock\n"));
     5441    dprintf(("DDRAW: SurfPageUnlock\n"));
    54105442  #endif
    54115443  return(DD_OK);
    … …  
    54185450{
    54195451  #ifdef DEBUG
    5420     dprintf(("SurfSetSurfaceDesc\n"));
     5452    dprintf(("DDRAW: SurfSetSurfaceDesc\n"));
    54215453  #endif
    54225454
    … …  
    54495481{
    54505482  #ifdef DEBUG
    5451     dprintf(("SurfSetSurfaceDesc4\n"));
     5483    dprintf(("DDRAW: SurfSetSurfaceDesc4\n"));
    54525484  #endif
    54535485
    … …  
    54905522
    54915523  #ifdef DEBUG
    5492     dprintf(("SurfSetPrivateData\n"));
     5524    dprintf(("DDRAW: SurfSetPrivateData\n"));
    54935525  #endif
    54945526
    … …  
    56735705
    56745706  #ifdef DEBUG
    5675     dprintf(("SurfGetPrivateData\n"));
     5707    dprintf(("DDRAW: SurfGetPrivateData\n"));
    56765708  #endif
    56775709
    … …  
    57335765
    57345766  #ifdef DEBUG
    5735     dprintf(("SurfFreePrivateData\n"));
     5767    dprintf(("DDRAW: SurfFreePrivateData\n"));
    57365768  #endif
    57375769
    … …  
    57785810{
    57795811  #ifdef DEBUG
    5780     dprintf(("SurfGetUniquenessValue\n"));
     5812    dprintf(("DDRAW: SurfGetUniquenessValue\n"));
    57815813  #endif
    57825814  OS2IDirectDrawSurface *me = (OS2IDirectDrawSurface *)This;
    … …  
    57975829
    57985830  #ifdef DEBUG
    5799     dprintf(("SurfChangeUniquenessValue\n"));
     5831    dprintf(("DDRAW: SurfChangeUniquenessValue\n"));
    58005832  #endif
    58015833  me->dwUniqueValue++;

  • trunk/src/ddraw/OS2UTIL.CPP

    r1502 r1568  
    1 /* $Id: OS2UTIL.CPP,v 1.6 1999-10-28 22:39:28 hugh Exp $ */
     1/* $Id: OS2UTIL.CPP,v 1.7 1999-11-02 22:41:23 hugh Exp $ */
    22
    33/*
    … …  
    2424  rc = DosAllocMem(&lpMem, size, PAG_READ|PAG_WRITE|PAG_COMMIT);
    2525  if(rc) {
    26     dprintf(("DosAllocMem returned %d", rc));
     26    dprintf(("DDRAW: DosAllocMem returned %d", rc));
    2727    return(NULL);
    2828  }
    … …  
    3737  rc = DosFreeMem(lpMem);
    3838  if(rc) {
    39     dprintf(("DosFreeMem returned %d", rc));
     39    dprintf(("DDRAW: DosFreeMem returned %d", rc));
    4040  }
    4141}//******************************************************************************

  • trunk/src/ddraw/ddraw.CPP

    r1502 r1568  
    1919  HRESULT         rc;
    2020
    21   dprintf(("DirectDrawCreate %X %X %X\n", lpGUID, lplpDD, pUnkOuter));
     21  dprintf(("DDRAW: DirectDrawCreate %X %X %X\n", lpGUID, lplpDD, pUnkOuter));
    2222
    2323  newdraw = new OS2IDirectDraw(lpGUID);
    … …  
    4848               LPVOID lpContext)
    4949{
    50   dprintf(("DirectDrawEnumerateA\n Callback for DIVE\n"));
     50  dprintf(("DDRAW: DirectDrawEnumerateA\n Callback for DIVE\n"));
    5151  //call it twice for the DirectDraw & Direct3D classes
    5252 if(lpCallback(NULL, "DIVE DirectDraw for OS/2",
    5353                "DirectDraw/2 v0.2", lpContext) == DDENUMRET_CANCEL)
    5454  {
    55     dprintf(("Cancel Callback\n"));
     55    dprintf(("DDRAW: Cancel Callback\n"));
    5656    return(DD_OK);
    5757  }
    5858  else //now for Direct3D
    5959  {
    60     dprintf(("Callback for 3Dfx Voodoo"));
     60    dprintf(("DDRAW: Callback for 3Dfx Voodoo"));
    6161    if(lpCallback((GUID *)&IID_IDirect3D, "3Dfx Voodoo Direct3D/2",
    6262      "Direct3D/2 v0.2", lpContext) == DDENUMRET_CANCEL)
    6363    {
    64       dprintf(("Cancel Callback\n"));
     64      dprintf(("DDRAW: Cancel Callback\n"));
    6565      return(DD_OK);
    6666    }
    6767  }
    68   dprintf(("Done Enumeration\n\n"));
     68  dprintf(("DDRAW: Done Enumeration\n\n"));
    6969
    7070  return(DD_OK);
    … …  
    8686  PENUMDATA pData;
    8787
    88   dprintf(("SimpleEnum\n"));
     88  dprintf(("DDRAW: SimpleEnum\n"));
    8989
    9090  pData = (PENUMDATA)lpContext;
    … …  
    9595                            NULL);
    9696
    97   dprintf(("Callback returned\n"));
     97  dprintf(("DDRAW: Callback returned\n"));
    9898  return rc;
    9999}
    … …  
    106106  ENUMDATA data;
    107107
    108   dprintf(("DirectDrawEnumerateExA\n"));
     108  dprintf(("DDRAW: DirectDrawEnumerateExA\n"));
    109109
    110110  data.lpCallbackEx = lpCallbackEx;
    … …  
    119119DWORD WIN32API DDHAL32_VidMemFree(DWORD address)
    120120{
    121   dprintf(("DDHAL32_VidMemFree, not supported\n"));
     121  dprintf(("DDRAW: DDHAL32_VidMemFree, not supported\n"));
    122122  return(0);
    123123}
    … …  
    126126DWORD WIN32API DDHAL32_VidMemAlloc(DWORD size)
    127127{
    128   dprintf(("DDHAL32_VidMemAlloc, not supported\n"));
     128  dprintf(("DDRAW: DDHAL32_VidMemAlloc, not supported\n"));
    129129  return(0);
    130130}
Note: See TracChangeset for help on using the changeset viewer.