Initial community commit

1 files changed, 1476 insertions, 0 deletions

diff --git a/Src/Plugins/Visualization/vis_avs/draw.cpp b/Src/Plugins/Visualization/vis_avs/draw.cpp
new file mode 100644
index 00000000..5eddc451
--- /dev/null
+++ b/Src/Plugins/Visualization/vis_avs/draw.cpp
@@ -0,0 +1,1476 @@
+/*
+  LICENSE
+  -------
+Copyright 2005 Nullsoft, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer. 
+
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution. 
+
+  * Neither the name of Nullsoft nor the names of its contributors may be used to 
+    endorse or promote products derived from this software without specific prior written permission. 
+ 
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#include <windows.h>
+#include <ddraw.h>
+#include "draw.h"
+#include <stdio.h>
+#include <process.h>
+#include "r_defs.h"
+#include "resource.h"
+#include "vis.h"
+#include "../Agave/Language/api_language.h"
+
+extern HINSTANCE g_hInstance;
+
+#define RESIZE_ONRESIZE
+int draw_title_p=0;
+int cfg_cancelfs_on_deactivate=1;
+extern int g_dlg_fps,g_dlg_w,g_dlg_h;
+extern int cfg_fs_fps,cfg_fs_flip,cfg_fs_height,cfg_fs_use_overlay;
+extern int cfg_bkgnd_render, cfg_bkgnd_render_color;
+static LPDIRECTDRAW		   g_lpDD;
+static LPDIRECTDRAWSURFACE g_lpRenderSurf[2], g_lpPrimSurf, g_lpPrimSurfBack;
+static int g_bpp, g_fs, g_noshoww;
+int g_w, g_h, g_dsw, g_dsh;
+extern HWND g_hwnd;
+static CRITICAL_SECTION g_cs;
+static int g_windowed_dsize;
+static int g_initted, g_fs_flip, g_fs_height, g_fs_w, g_fs_h;
+static int nodraw=0;
+extern int inWharf;
+#ifdef RESIZE_ONRESIZE
+static int last_used;
+#endif
+static LPDIRECTDRAWSURFACE g_lpddsOverlay = NULL;
+static LPDIRECTDRAWSURFACE g_lpddsPrimary = NULL;
+static int g_overlay_init_ok=0;
+typedef enum {
+  UYVY,
+  YUY2
+} fourcc_enum;
+static fourcc_enum g_overlay_fourcc=UYVY;
+static int g_saved_desktop_values=0;
+
+static char g_saved_desktop_wallpaper[256];
+static char g_saved_reg_bkgnd_color[64];
+static DWORD g_saved_bkgnd_color;
+
+extern void Wnd_GoWindowed(HWND hwnd);
+
+#define INIT_DIRECTDRAW_STRUCT(x) (ZeroMemory(&x, sizeof(x)), x.dwSize=sizeof(x))
+DDPIXELFORMAT g_ddpfOverlayFormats[] = 
+{   {sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0}, // UYVY
+    {sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0}};  // YUY2
+
+#define NUM_OVERLAY_FORMATS (sizeof(g_ddpfOverlayFormats) / sizeof(g_ddpfOverlayFormats[0]))
+
+static HWND hwndOverlayWnd;
+
+static LRESULT CALLBACK FSOverlayWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+  static unsigned int start_t;
+
+	if (
+    
+        (((message == WM_KEYDOWN && (wParam == VK_ESCAPE || wParam == VK_RETURN)) || 
+		     message == WM_LBUTTONUP) && GetTickCount()-start_t > 1000)
+         
+         || 
+
+         (cfg_cancelfs_on_deactivate && ((message == WM_NCACTIVATE && !wParam) ||
+         message == WM_KILLFOCUS))
+        )
+	{
+    DestroyWindow(hwnd);
+    Wnd_GoWindowed(g_hwnd);
+    return 0;
+	}
+  switch(message)
+  {
+  case WM_CREATE:
+    start_t=GetTickCount();
+  return 0;
+  case WM_SETCURSOR:
+    SetCursor(NULL);
+  return TRUE;
+  case WM_DESTROY:
+    hwndOverlayWnd=0;
+  return 0;
+  case WM_PAINT:
+    {
+      PAINTSTRUCT ps;
+      HDC hdc=BeginPaint(hwnd,&ps);
+      RECT r;
+      GetClientRect(hwnd,&r);
+      int rv=0xff&(cfg_bkgnd_render_color>>16), gv=0xff&(cfg_bkgnd_render_color>>8), bv=0xff&cfg_bkgnd_render_color;
+      HBRUSH b=CreateSolidBrush(RGB(rv,gv,bv));
+      SelectObject(ps.hdc, b); 
+      Rectangle(ps.hdc, r.left, r.top, r.right, r.bottom); 
+      DeleteObject(b);
+      EndPaint(hwnd,&ps);
+    }
+    return 0;
+  case WM_KEYDOWN:
+    return SendMessage(g_hwnd, message, wParam, lParam);
+  }
+  return DefWindowProc(hwnd, message, wParam, lParam);
+}
+
+static void DD_CreateFullscreenOverlayWindow()
+{
+  static int inited=0;
+  if(!inited)
+  {
+  	WNDCLASSW wc={0,};
+  	wc.style = CS_DBLCLKS|CS_VREDRAW|CS_HREDRAW;
+  	wc.lpfnWndProc = FSOverlayWndProc;
+  	wc.hInstance = g_hInstance;
+  	wc.hbrBackground = NULL;
+  	wc.lpszClassName = L"avsfsoverlaywnd";
+  	wc.hCursor=NULL;
+  	if(!RegisterClassW(&wc)) return;
+    inited=1;
+  }
+  hwndOverlayWnd=CreateWindowExW(WS_EX_TOPMOST|WS_EX_TOOLWINDOW,L"avsfsoverlaywnd",L"",WS_VISIBLE|WS_POPUP,0,0,GetSystemMetrics(SM_CXSCREEN),GetSystemMetrics(SM_CYSCREEN),NULL,NULL,g_hInstance,0);
+}
+
+static void DD_RestoreBkgndSettings()
+{
+  if (g_saved_desktop_values)
+  {
+    int e=COLOR_DESKTOP;
+    unsigned long c=g_saved_bkgnd_color;
+    SetSysColors(1, &e, &c); // FUCKING MESSAGE PUMP AND SETSYSCOLORS
+    SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, g_saved_desktop_wallpaper, NULL);
+    g_saved_desktop_values=0;
+  }
+}
+
+void DD_CreateSurfaces(int w, int h, int fsh, int fs, int fsbpp, int flip, int dbl, int fsovl) // fsh is the height to use (not screen res)
+{
+  int resize_h=8, resize_w=8;
+#ifdef RESIZE_ONRESIZE
+  int fb_save[64*65+1];
+  int fb_save_use=0;
+#endif
+  EnterCriticalSection(&g_cs);
+  nodraw=0;
+  if (g_lpDD)
+  {
+    extern int config_reuseonresize;
+#ifdef RESIZE_ONRESIZE
+    HRESULT han;
+    int ll=!!last_used;
+    DDSURFACEDESC d={sizeof(d),};
+  	if (config_reuseonresize && g_w && g_h && g_lpRenderSurf[ll] &&
+        (han = g_lpRenderSurf[ll]->Lock(NULL,&d,DDLOCK_WAIT,NULL)) == DD_OK) 
+    {
+      if (d.lpSurface)
+      {
+        int x,y;
+        int dxpos=(g_w<<16)/64;
+        int ypos=0;
+        int dypos=(g_h<<16)/64;
+        int *pp=((int *)d.lpSurface);
+
+        if (g_fs && g_fs_height < g_h) // adjust to use partial screen when 
+        {
+          int fsy=g_h/2-g_fs_height/2;
+          dypos=(g_fs_height<<16)/64;
+          pp+=fsy * g_w;
+        }
+
+        for (y = 0; y < 64; y++)
+        {
+          int *p=pp + g_w * (ypos>>16);
+          int xpos=0;
+          for (x = 0; x < 64; x ++)
+          {
+            fb_save[(y<<6)+x]=p[xpos>>16];
+            xpos+=dxpos;
+          }
+          ypos+=dypos;
+        }
+        memset(fb_save+64*64,0,sizeof(int)*65);
+        fb_save_use=1;
+      }
+      g_lpRenderSurf[ll]->Unlock(d.lpSurface);
+    }
+#endif
+
+		if (g_lpPrimSurf)
+		{
+			g_lpPrimSurf->Release();
+			g_lpPrimSurfBack=g_lpPrimSurf=NULL;
+		}
+    if (g_lpRenderSurf[0]) g_lpRenderSurf[0]->Release();
+    if (g_lpRenderSurf[1]) g_lpRenderSurf[1]->Release();
+    g_lpRenderSurf[0]=0;
+    g_lpRenderSurf[1]=0;
+    if (g_lpddsOverlay) g_lpddsOverlay->Release();
+    if (g_lpddsPrimary) g_lpddsPrimary->Release();
+    g_lpddsOverlay=g_lpddsPrimary=NULL;
+    g_lpDD->Release();
+    g_lpDD=NULL;
+  }
+  
+  if (DirectDrawCreate(NULL,&g_lpDD,NULL) != DD_OK) 
+	{
+    g_lpDD=NULL;
+		MessageBox(g_hwnd,WASABI_API_LNGSTRING(IDS_ERROR_CREATING_DDRAW_OBJECT),"DDraw",0);
+    LeaveCriticalSection(&g_cs);
+		return;
+	}
+	if (fs && !fsovl)
+	{
+    g_fs_w=w;
+    g_fs_h=h;
+    g_fs_height=fsh>>dbl;
+    g_fs_flip=flip;
+    resize_w=w>>dbl;
+		resize_h=h>>dbl;
+		if (g_lpDD->SetCooperativeLevel(g_hwnd,DDSCL_NOWINDOWCHANGES|DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN) != DD_OK)
+		{
+			fs=0;
+		}
+		else
+		{
+			if (g_lpDD->SetDisplayMode(w,h,fsbpp) != DD_OK)
+			{
+				fs=0;
+			}
+			else
+			{
+				DDSURFACEDESC DDsd={sizeof(DDsd),};
+				DDsd.dwFlags = DDSD_CAPS;
+				DDsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+        if (g_fs_flip&1) 
+        {
+          DDsd.ddsCaps.dwCaps |= DDSCAPS_COMPLEX|DDSCAPS_FLIP;
+          DDsd.dwFlags|=DDSD_BACKBUFFERCOUNT;
+          DDsd.dwBackBufferCount = 1;
+        }
+				if (g_lpDD->CreateSurface(&DDsd, &g_lpPrimSurf, NULL) != DD_OK)
+				{
+					fs=0;
+				}
+				else
+				{
+          DDBLTFX ddbfx={sizeof(ddbfx),};
+          g_lpPrimSurf->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+          if (g_fs_flip&1)
+          {
+						DDSCAPS ddscaps;
+						ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
+						if (g_lpPrimSurf->GetAttachedSurface(&ddscaps, &g_lpPrimSurfBack) != DD_OK) 
+						{
+							g_lpPrimSurf->Release();
+							fs=0;
+						}
+            else g_lpPrimSurfBack->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+          }
+          else
+            g_lpPrimSurfBack=g_lpPrimSurf;
+				}
+			}
+		}
+    SetForegroundWindow(g_hwnd);
+  } else {
+    g_lpDD->SetCooperativeLevel(g_hwnd,DDSCL_NOWINDOWCHANGES|DDSCL_NORMAL);
+    resize_w=(((w>>dbl)+3)&~3);
+    g_noshoww=resize_w-(w>>dbl);
+    resize_h=h>>dbl;
+	}
+	g_fs=fs;
+
+  int wh;
+  for (wh = 0; wh < 2; wh ++)
+	{
+		DDSURFACEDESC DDsd={sizeof(DDsd),};
+		DDsd.dwFlags = DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT|DDSD_PITCH|DDSD_PIXELFORMAT;
+		DDsd.dwWidth=resize_w;
+		DDsd.dwHeight=resize_h;
+		DDsd.lPitch=resize_w*sizeof(int);
+		DDsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY;
+		DDsd.ddpfPixelFormat.dwSize = sizeof(DDsd.ddpfPixelFormat);
+		DDsd.ddpfPixelFormat.dwFlags=DDPF_RGB;
+		DDsd.ddpfPixelFormat.dwRGBBitCount = 32;
+		DDsd.ddpfPixelFormat.dwRBitMask=0xff0000;
+		DDsd.ddpfPixelFormat.dwGBitMask=0x00ff00;
+		DDsd.ddpfPixelFormat.dwBBitMask=0x0000ff;
+		if (g_lpDD->CreateSurface(&DDsd, &g_lpRenderSurf[wh], NULL) != DD_OK)
+		{
+      if (wh)
+      {
+        g_lpRenderSurf[0]->Release();
+        g_lpRenderSurf[0]=0;
+      }
+			g_lpRenderSurf[wh]=0;
+			LeaveCriticalSection(&g_cs);
+			return;
+		}
+
+#ifdef RESIZE_ONRESIZE
+    DDSURFACEDESC d={sizeof(d),};
+    HRESULT han;
+  	if (fb_save_use && g_lpRenderSurf[wh] &&
+        (han = g_lpRenderSurf[wh]->Lock(NULL,&d,DDLOCK_WAIT,NULL)) == DD_OK) 
+    {
+      if (d.lpSurface)
+      {
+        int x,y;
+        int dxpos=(64<<16)/resize_w;
+        int ypos=0;
+        int *p=(int *)d.lpSurface;
+        int h=resize_h;
+
+        if (fs && (fsh>>dbl) < resize_h)
+        {
+          int fsy=resize_h/2-(((fsh>>dbl)/2));
+          p+=fsy * resize_w;
+          h -= fsy*2;
+        }
+        int dypos=(64<<16)/h;
+
+        for (y = 0; y < h; y ++)
+        {
+          int xpos=0;
+          for (x = 0; x < resize_w; x ++)
+          {
+            *p++ = BLEND4_16((unsigned int *)fb_save + ((ypos>>10)&~63) + (xpos>>16),64,xpos,ypos);
+            xpos+=dxpos;
+          }
+          ypos+=dypos;
+        }
+#ifndef NO_MMX
+        __asm emms;
+#endif
+      }
+      g_lpRenderSurf[wh]->Unlock(d.lpSurface);
+    }
+#endif
+	}
+	g_w=resize_w;
+	g_h=resize_h;
+  g_dsh=g_h<<dbl;
+  g_dsw=g_w<<dbl;
+	g_bpp=fs?fsbpp:32;
+  g_windowed_dsize=dbl;
+
+  g_overlay_init_ok=0;
+  if(!(cfg_bkgnd_render&1)) DD_RestoreBkgndSettings();
+  if((cfg_bkgnd_render&1) || (g_fs && fsovl)) {
+    // init overlay stuff
+    DDSURFACEDESC   ddsdOverlay;
+    HRESULT         ddrval;
+    int             i;
+
+    // It's currently not possible to query for pixel formats supported by the
+    // overlay hardware (though GetFourCCCodes() usually provides a partial 
+    // list).  Instead you need to call CreateSurface() to try a variety of  
+    // formats till one works.  
+    INIT_DIRECTDRAW_STRUCT(ddsdOverlay);
+    ddsdOverlay.ddsCaps.dwCaps=DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
+    ddsdOverlay.dwFlags= DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT|DDSD_PITCH;
+    ddsdOverlay.dwWidth=resize_w;
+    ddsdOverlay.dwHeight=resize_h;
+    ddsdOverlay.lPitch=resize_w*sizeof(int);
+    ddsdOverlay.dwBackBufferCount=0;
+
+    // Try to create an overlay surface using one of the pixel formats in our
+    // global list.
+    i=0;
+    do 
+    {
+      ddsdOverlay.ddpfPixelFormat=g_ddpfOverlayFormats[i];
+      // Try to create the overlay surface
+      ddrval = g_lpDD->CreateSurface(&ddsdOverlay, &g_lpddsOverlay, NULL);
+    } while( FAILED(ddrval) && (++i < NUM_OVERLAY_FORMATS) );
+
+    if(!FAILED(ddrval))
+    {
+      g_overlay_fourcc=(fourcc_enum)i;
+
+      HRESULT ddrval;
+	    DDSURFACEDESC   ddsd;
+      INIT_DIRECTDRAW_STRUCT(ddsd);
+      ddsd.dwFlags = DDSD_CAPS;
+      ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
+      ddrval = g_lpDD->CreateSurface(&ddsd, &g_lpddsPrimary, NULL );
+
+      RECT            rs, rd;
+      DDOVERLAYFX     ovfx;
+      DDCAPS          capsDrv;
+      unsigned int    uDestSizeAlign, uSrcSizeAlign;
+      DWORD           dwUpdateFlags;
+
+      INIT_DIRECTDRAW_STRUCT(capsDrv);
+      ddrval = g_lpDD->GetCaps(&capsDrv, NULL);
+
+      uDestSizeAlign = capsDrv.dwAlignSizeDest;
+      uSrcSizeAlign =  capsDrv.dwAlignSizeSrc;
+
+      dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX | DDOVER_KEYDESTOVERRIDE;
+
+      DEVMODE d;
+      d.dmSize=sizeof(d);
+      d.dmDriverExtra=0;
+      EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &d);
+
+      int rv=0xff&(cfg_bkgnd_render_color>>16), gv=0xff&(cfg_bkgnd_render_color>>8), bv=0xff&cfg_bkgnd_render_color;
+
+      if(!fsovl)
+      {
+        if (cfg_bkgnd_render&2)
+        {
+          if (!g_saved_desktop_values)
+          {
+            HKEY key;
+            g_saved_desktop_wallpaper[0]=0;
+            g_saved_reg_bkgnd_color[0]=0;
+  
+            // get wallpaper
+            if(RegOpenKey(HKEY_CURRENT_USER, "Control Panel\\Desktop",&key)==ERROR_SUCCESS)
+            {
+              unsigned long s=sizeof(g_saved_desktop_wallpaper),vt;
+              RegQueryValueEx(key,"Wallpaper", 0, &vt, (unsigned char *)g_saved_desktop_wallpaper, &s);
+            }
+  
+            // get registry bkgnd color
+            if(RegOpenKey(HKEY_CURRENT_USER, "Control Panel\\Colors",&key)==ERROR_SUCCESS)
+            {
+              unsigned long s=sizeof(g_saved_reg_bkgnd_color),vt;
+              RegQueryValueEx(key,"Background", 0, &vt, (unsigned char *)g_saved_reg_bkgnd_color, &s);
+            }
+          
+            g_saved_bkgnd_color=GetSysColor(COLOR_DESKTOP);
+            g_saved_desktop_values=1;
+          }
+          int e=COLOR_DESKTOP;
+          unsigned long c=RGB(rv,gv,bv);
+          SetSysColors(1, &e, &c);
+          SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, "", NULL);
+  
+          // rewrite registry settings right now so we don't fuck the user desktop if avs crashes
+          {
+            HKEY key;
+            if(RegOpenKey(HKEY_CURRENT_USER, "Control Panel\\Desktop",&key)==ERROR_SUCCESS)
+              RegSetValueEx(key,"Wallpaper", 0, REG_SZ, (unsigned char *)g_saved_desktop_wallpaper, strlen(g_saved_desktop_wallpaper)+1);
+            if(RegOpenKey(HKEY_CURRENT_USER, "Control Panel\\Colors",&key)==ERROR_SUCCESS)
+              RegSetValueEx(key,"Background", 0, REG_SZ, (unsigned char *)g_saved_reg_bkgnd_color, strlen(g_saved_reg_bkgnd_color)+1);
+          }
+        }
+        else DD_RestoreBkgndSettings();
+      }
+
+      INIT_DIRECTDRAW_STRUCT(ovfx);
+      switch(d.dmBitsPerPel)
+      {
+      case 16:
+        ovfx.dckDestColorkey.dwColorSpaceLowValue=((rv>>3) << 11) | ((gv>>2) << 5) | (bv>>3);
+        break;
+      case 15:
+        ovfx.dckDestColorkey.dwColorSpaceLowValue=((rv>>3) << 10) | ((gv>>3) << 5) | (bv>>3);
+        break;
+      case 24: case 32:
+        ovfx.dckDestColorkey.dwColorSpaceLowValue=(rv << 16) | (gv << 8) | bv;
+        break;
+      }
+      ovfx.dckDestColorkey.dwColorSpaceHighValue=ovfx.dckDestColorkey.dwColorSpaceLowValue;
+
+      rs.left=0; rs.top=0;
+      rs.right = resize_w;
+      rs.bottom = resize_h;
+      if (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC && uSrcSizeAlign)
+          rs.right -= rs.right % uSrcSizeAlign;
+      rd.left=0; rd.top=0; 
+      rd.right=GetSystemMetrics(SM_CXSCREEN); rd.bottom=GetSystemMetrics(SM_CYSCREEN);
+      if (capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST && uDestSizeAlign)
+          rd.right = (int)((rd.right+uDestSizeAlign-1)/uDestSizeAlign)*uDestSizeAlign;
+      // Make the call to UpdateOverlay() which actually displays the overlay on
+      // the screen.
+      ddrval = g_lpddsOverlay->UpdateOverlay(&rs, g_lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
+      if(!FAILED(ddrval)) g_overlay_init_ok=1;
+    }
+  }
+
+  if(g_fs && fsovl) 
+  {
+    g_fs_height=fsh>>dbl;
+    DD_CreateFullscreenOverlayWindow();
+  }
+
+	LeaveCriticalSection(&g_cs);
+}
+
+#ifndef NO_MMX
+bool CopyRGBSurfaceToYUVSurfaceMMX(
+        LPDDSURFACEDESC pddsd1,
+        LPDDSURFACEDESC pddsd2,
+		fourcc_enum eOverlayFormat)
+{
+    if (pddsd1->dwWidth != pddsd2->dwWidth) 
+        return false;
+    if (pddsd1->dwHeight != pddsd2->dwHeight) 
+        return false;
+    
+    DWORD  w = pddsd1->dwWidth;
+    DWORD  h = pddsd1->dwHeight;
+    LONG   pitch1 = pddsd1->lPitch;
+    LONG   pitch2 = pddsd2->lPitch;
+    unsigned __int32 *pPixels1 = (unsigned __int32 *)pddsd1->lpSurface;
+    unsigned __int32 *pPixels2 = (unsigned __int32 *)pddsd2->lpSurface;
+	signed __int16 cm1[4];
+	signed __int16 cm2[4];
+	signed __int16 cm3[4];
+	signed __int16 cm4[4];
+	int loops_per_scanline = w/2;
+	int extra_bytes_per_scanline_src  = pitch1 - w*4;
+	int extra_bytes_per_scanline_dest = pitch2 - w*2;
+
+    if (eOverlayFormat == UYVY) // U Y V Y
+    {
+		// swap 0<->1, and 2<->3
+		cm1[1] = 77/2;  cm1[0] = -38/2;   cm1[3] = 77/2;  cm1[2] = 110/2;
+		cm2[1] = 150/2; cm2[0] = -74/2;   cm2[3] = 150/2; cm2[2] = -92/2;
+		cm3[1] = 29/2;  cm3[0] = 112/2;   cm3[3] = 29/2;  cm3[2] = -18/2;
+		cm4[1] = 0;     cm4[0] = 32768/2; cm4[3] = 0;     cm4[2] = 32768/2;
+    }
+    else    // Y U Y 2
+    {
+		// (laptop)
+		cm1[0] = 77/2;  cm1[1] = -38/2;   cm1[2] = 77/2;  cm1[3] = 110/2;
+		cm2[0] = 150/2; cm2[1] = -74/2;   cm2[2] = 150/2; cm2[3] = -92/2;
+		cm3[0] = 29/2;  cm3[1] = 112/2;   cm3[2] = 29/2;  cm3[3] = -18/2;
+		cm4[0] = 0;     cm4[1] = 32768/2; cm4[2] = 0;     cm4[3] = 32768/2;
+    }
+    
+	__asm
+	{
+		mov   edx, h
+
+		mov   esi, pPixels1
+		mov   edi, pPixels2
+		sub   edi, 4			// pre-subtract
+		movq  mm4, cm4
+		movq  mm5, cm1
+		movq  mm6, cm2
+		movq  mm7, cm3
+
+		ALIGN 8
+		yuvscanlineloop:
+
+			mov   ecx, loops_per_scanline
+
+			ALIGN 8
+			yuvloop:
+
+                /*
+                // prefetch
+			    test     ecx, 0x000001ff
+			    jnz      PROCESS_PIXEL_MMX32           // every 256th pixel do some prefetches
+
+						 mov      ebx, 2*256                 // need to prefetch 256*6 bytes
+                        ALIGN 8
+					    LOAD_ESI_ARRAY_MMX32:
+						 mov      eax, [ebx+esi]
+						 mov      eax, [ebx+esi+32]
+						 sub      ebx, 64
+						 jnz      LOAD_ESI_ARRAY_MMX32
+
+                ALIGN 8
+				PROCESS_PIXEL_MMX32:
+                */
+
+				// read in 2 pixels
+				movq mm0, qword ptr [esi]	// -- b1 g1 r1 -- b2 g2 r2
+				movq mm1, qword ptr [esi]	// -- b1 g1 r1 -- b2 g2 r2
+				movq mm2, qword ptr [esi]	// -- b1 g1 r1 -- b2 g2 r2
+
+                // quick reference:
+                // punpcklbw mm7, mm7     // abcdefgh -> eeffgghh
+                // punpcklbw mm7, mm0     // abcdefgh -> 0e0f0g0h (if mm0 is zero)
+				// packuswb mm7, mm7      // 0a0b0g0r -> abgrabgr ?
+
+				// step 1: get to this state:
+				//	mm0: r1   r1   r2   r2
+				//	mm1: g1   g1   g2   g2
+				//	mm2: b1   b1   b2   b2
+				//  mm3: junk
+				//  mm4: 0    32k  0    32k
+				//  mm5: c1r1 c1r2 c2r1 c2r2
+				//  mm6: c1g1 c1g2 c2g1 c2g2
+				//  mm7: c1b1 c1b2 c2b1 c2b2
+
+				// NOTE: the shifts of 8, 16, and 24 below are
+				//       correct (vs. 0-8-16) but might be in
+				//       backwards order!
+
+				pslld mm0, 8
+				pslld mm1, 16
+				pslld mm2, 24
+				psrld mm0, 24    // 00 00 00 r1 00 00 00 r2
+				psrld mm1, 24    // 00 00 00 g1 00 00 00 g2
+				psrld mm2, 24    // 00 00 00 b1 00 00 00 b2
+				
+                movq  mm3, mm0
+				pslld mm0, 16
+				por   mm0, mm3   // 00 r1 00 r1 00 r2 00 r2
+
+				movq  mm3, mm1
+				pslld mm1, 16
+				por   mm1, mm3   // 00 g1 00 g1 00 g2 00 g2
+
+				movq  mm3, mm2
+				pslld mm2, 16
+				por   mm2, mm3   // 00 b1 00 b1 00 b2 00 b2
+
+				// step 2: multiply to get to this state:
+				//	mm0: r1*c1r1  r1*c1r2  r2*c2r1  r2*c2r2
+				//	mm1: g1*c1g1  g1*c1g2  g2*c2g1  g2*c2g2
+				//	mm2: b1*c1b1  b1*c1b2  b2*c2b1  b2*c2b2
+				//  mm4: 0    32k  0    32k
+				pmullw mm0, mm5
+				 add  edi, 4
+				pmullw mm1, mm6
+				 add  esi, 8
+					pmullw mm2, mm7
+				
+				// step 3: add to get to this state:
+				//	mm0: d1*256   d2*256   d3*256   d4*256
+				paddsw mm0, mm4
+				paddsw mm0, mm1
+				paddsw mm0, mm2
+
+				psrlw    mm0, 7
+				packuswb mm0, mm0    // bytes: abgrabgr
+				movd     dword ptr [edi], mm0  // store 
+				
+				loop yuvloop
+
+			// scanline complete
+			add esi, extra_bytes_per_scanline_src
+			add edi, extra_bytes_per_scanline_dest
+
+			dec edx
+			jnz yuvscanlineloop
+
+		emms
+	}
+   
+    return true;
+}
+#else
+bool CopyRGBSurfaceToYUVSurface(
+        LPDDSURFACEDESC pddsd1,
+        LPDDSURFACEDESC pddsd2,
+		fourcc_enum eOverlayFormat)
+{
+  if (pddsd1->dwWidth != pddsd2->dwWidth) 
+    return false;
+  if (pddsd1->dwHeight != pddsd2->dwHeight) 
+    return false;
+    
+  DWORD  w = pddsd1->dwWidth;
+  DWORD  h = pddsd1->dwHeight;
+  LONG   pitch1 = pddsd1->lPitch;
+  LONG   pitch2 = pddsd2->lPitch;
+  unsigned __int32 *pPixels1 = (unsigned __int32 *)pddsd1->lpSurface;
+  unsigned __int32 *pPixels2 = (unsigned __int32 *)pddsd2->lpSurface;
+  unsigned __int32 color1;
+  LONG   offset1 = 0;
+  LONG   offset2 = 0;
+  unsigned int    R, G, B, i1, i2, i3, i4;
+  BYTE            yuv[4];
+
+  if (eOverlayFormat == UYVY) // U Y V Y
+  {
+    i1 = 1;
+    i2 = 0;
+    i3 = 3;
+    i4 = 2;
+  }
+  else    // Y U Y 2
+  {
+    i1 = 0;
+    i2 = 1;
+    i3 = 2;
+    i4 = 3;
+  }
+    
+  // Go through the image 2 pixels at a time and convert to YUV
+  for (unsigned int y=0; y<h; y++)
+  {
+    offset1 = y*pitch1/4;
+    offset2 = y*pitch2/4;
+
+	  for (unsigned int x=0; x<w; x+=2)
+    {
+      color1 = pPixels1[offset1++];
+      B = (color1) & 0xFF;
+      G = (color1 >> 8) & 0xFF;
+      R = (color1 >> 16) & 0xFF;
+      yuv[i1] = (77*R + 150*G + 29*B) >> 8;
+      yuv[i2] = (32768 - 38*R - 74*G + 112*B) >> 8;
+            
+      color1 = pPixels1[offset1++];
+      B = (color1) & 0xFF;
+      G = (color1 >> 8) & 0xFF;
+      R = (color1 >> 16) & 0xFF;
+      yuv[i3] = (77*R + 150*G + 29*B) >> 8;
+      yuv[i4] = (32768 + 110*R - 92*G - 18*B) >> 8;
+
+      pPixels2[offset2++] = *((unsigned __int32 *)yuv);
+    }
+  }    
+  return true;
+}
+#endif
+
+int DDraw_Init()
+{
+	InitializeCriticalSection(&g_cs);
+	return 0;
+
+}
+void DDraw_Quit(void)
+{
+  if (g_lpDD)
+  {
+		if (g_lpPrimSurf)
+		{
+			g_lpPrimSurf->Release();
+			g_lpPrimSurfBack=g_lpPrimSurf=NULL;
+		}
+    if (g_lpRenderSurf[0]) g_lpRenderSurf[0]->Release();
+    if (g_lpRenderSurf[1]) g_lpRenderSurf[1]->Release();
+    g_lpRenderSurf[0]=0;
+    g_lpRenderSurf[1]=0;
+    if (g_lpddsOverlay) g_lpddsOverlay->Release();
+    if (g_lpddsPrimary) g_lpddsPrimary->Release();
+    g_lpddsOverlay=g_lpddsPrimary=NULL;
+    g_lpDD->Release();
+    g_lpDD=NULL;
+    DD_RestoreBkgndSettings();
+  }
+	DeleteCriticalSection(&g_cs);
+}
+
+
+void DDraw_BeginResize(void)
+{
+  if (!g_fs) nodraw=1;
+}
+void DDraw_Resize(int w, int h, int dsize)
+{
+  if (!g_fs) DD_CreateSurfaces(w, h, 0, 0, 0, 0, !!dsize, 0);
+}
+
+static void *g_lpsurf[2];
+
+static DDSURFACEDESC d={sizeof(d),};
+static DDSURFACEDESC d2={sizeof(d),};
+
+void DDraw_Enter(int *w, int *h, int **fb1, int **fb2)
+{
+	HRESULT han;
+  if (nodraw) 
+  {
+    *fb1=*fb2=0;
+    return;
+  }
+  EnterCriticalSection(&g_cs);
+	*w=g_w;
+	*h=g_h;
+  if (!g_lpDD || !g_lpRenderSurf[0] || !g_lpRenderSurf[1]) 
+  {
+    *fb1=*fb2=0;
+    LeaveCriticalSection(&g_cs);
+    return;
+  }
+	if ((han = g_lpRenderSurf[0]->Lock(NULL,&d,DDLOCK_WAIT,NULL)) != DD_OK) 
+	{
+    *fb1=*fb2=0;
+    LeaveCriticalSection(&g_cs);
+		return;
+	}
+	if ((han = g_lpRenderSurf[1]->Lock(NULL,&d2,DDLOCK_WAIT,NULL)) != DD_OK) 
+	{
+    g_lpRenderSurf[0]->Unlock(d.lpSurface);
+    *fb1=*fb2=0;
+    LeaveCriticalSection(&g_cs);
+		return;
+	}
+	*fb1=(int*)(g_lpsurf[0]=d.lpSurface);
+	*fb2=(int*)(g_lpsurf[1]=d2.lpSurface);
+
+  if (g_fs && g_fs_height!=g_h)// && !cfg_fs_use_overlay)
+  {
+    int y=g_h/2-((g_fs_height/2));
+    *h-=y*2;
+    *fb1 += y*g_w;
+    *fb2 += y*g_w;
+  }
+}
+      
+static unsigned int draw_title_time;
+static char last_title[1024];
+
+extern HWND hwnd_WinampParent;
+
+static void do_gettitle()
+{
+  if (draw_title_p < 1 && --draw_title_p < -7)
+  {
+    char this_title[2048]={0,};
+    char *p;
+	  if (IsWindow(hwnd_WinampParent)) 
+    {
+      DWORD id;
+      if (!SendMessageTimeout( hwnd_WinampParent,WM_GETTEXT,(WPARAM)sizeof(this_title),(LPARAM)this_title,SMTO_BLOCK,50,&id) || !id) return;
+    }
+	  p = this_title+strlen(this_title);
+	  while (p >= this_title)
+	  {
+		  char buf[9];
+		  memcpy(buf,p,8);
+		  buf[8]=0;
+		  if (!lstrcmpi(buf,"- Winamp")) break;
+		  p--;
+	  }
+	  if (p >= this_title) p--;
+	  while (p >= this_title && *p == ' ') p--;
+	  *++p=0;
+	  if (lstrcmpi(this_title,last_title))
+	  {
+		  strcpy(last_title,this_title);
+      draw_title_p=1;
+      draw_title_time=GetTickCount()+1000;
+	  }
+    else draw_title_p=0;
+  }
+  if (draw_title_p == 2)
+  {
+    draw_title_p=1;
+    draw_title_time=GetTickCount()+1000;
+  }
+}
+
+
+char statustext[256];
+DWORD statustext_life;
+int statustext_len;
+
+void DDraw_SetStatusText(char *text, int life)
+{
+  strcpy(statustext,text);
+  statustext_len=life?life:2000;
+  statustext_life=1;
+
+}
+
+
+
+#ifndef NO_X86ASM
+void homemadeBlitFrom32bpp(DDSURFACEDESC *out, void *in, int w, int h, int sy, int ey)
+{
+  int mh=min(h,(int)out->dwHeight);
+  if (sy < 0) sy=0;
+  if (ey > mh) ey=mh;
+    if (out->ddpfPixelFormat.dwRGBBitCount == 15)
+  {
+    int y;
+    int mw;
+    mw=min(w,out->lPitch/2);
+    unsigned int *inptr=(unsigned int *)in + w*sy;
+    for (y = sy; y < ey; y ++)
+    {
+      unsigned char *optr = (unsigned char *)out->lpSurface + (y * out->lPitch);
+      __asm
+      {
+        mov edi, optr
+        mov esi, inptr
+        mov ecx, mw
+        mov ebx, 00000000111110001111100011111000b
+        shr ecx, 1
+      conv15_loop:
+        mov eax,[esi]
+
+        mov edx,[esi+4]
+
+        and eax, ebx
+        and edx, ebx
+
+                  // 00000000RRRRR000GGGGG000BBBBB000
+        shr ah,3  // 00000000RRRRR000000GGGGGBBBBB000
+        shr dh,3
+
+        shr ax,3  // 00000000RRRRR000000000GGGGGBBBBB
+        shr dx,3
+
+                  // ----------------HHHHHHHHLLLLLLLL
+        ror eax,10// GGGGGBBBBB00000000RRRRR000000000
+        ror edx,10
+
+        shr ah,1
+        shr dh,1
+
+        mov al,ah
+        mov dl,dh
+
+        rol eax,10
+
+        rol edx,10
+
+        shl edx, 16
+
+        and eax, 0x0000ffff
+        add esi,8
+
+        or eax, edx
+
+        mov [edi], eax
+
+        add edi, 4
+        dec ecx
+        jnz conv15_loop  
+      }
+      inptr += w;
+    }
+
+  }
+  else if (out->ddpfPixelFormat.dwRGBBitCount == 16)
+  {
+    int y;
+    int mw;
+    mw=min(w,out->lPitch/2);
+    unsigned int *inptr=(unsigned int *)in + w*sy;
+    for (y = sy; y < ey; y ++)
+    {
+      unsigned char *optr = (unsigned char *)out->lpSurface + (y * out->lPitch);
+      __asm
+      {
+        mov edi, optr
+        mov esi, inptr
+        mov ecx, mw
+        mov ebx, 00000000111110001111110011111000b
+        shr ecx, 1
+      conv16_loop:
+        mov eax,[esi]
+
+        mov edx,[esi+4]
+
+        and eax, ebx
+        and edx, ebx
+
+        // RRRRR000GGGGGG00BBBBB000
+
+        shr ah,2        // RRRRR00000GGGGGGBBBBB000
+        shr dh,2
+
+        shr ax,3        // RRRRR00000000GGGGGGBBBBB
+        shr dx,3
+
+        ror eax,8       // GGGBBBBBRRRRR00000000GGG
+        ror edx,8
+
+        add al,ah       // GGGBBBBBRRRRR000RRRRRGGG
+        add dl,dh
+
+        rol eax,8       // RRRRR000RRRRRGGGGGGBBBBB
+
+        rol edx,8
+
+        shl edx, 16
+
+        and eax, 0x0000ffff
+        add esi,8
+
+        or eax, edx
+
+        mov [edi], eax
+
+        add edi, 4
+        dec ecx
+        jnz conv16_loop  
+      }
+      inptr += w;
+    }
+
+  }
+  else if (out->ddpfPixelFormat.dwRGBBitCount == 24)
+  { // very unoptimized
+    int y,x;
+    int mw;
+    unsigned int *inptr=(unsigned int *)in+sy;
+    mw=min(w,out->lPitch/3);
+    for (y = sy; y < ey; y ++)
+    {
+      unsigned char *optr = (unsigned char *)out->lpSurface + (y * out->lPitch);
+      x=mw/2;
+      while (x--)
+      {
+        int a=inptr[0];
+        int b=inptr[1];
+        optr[0]=(unsigned char) a;
+        optr[3]=(unsigned char) b;
+        optr[1]=(unsigned char) (a>>8);
+        optr[4]=(unsigned char) (b>>8);
+        optr[2]=(unsigned char) (a>>16);
+        optr[5]=(unsigned char) (b>>16);
+
+        optr+=6;
+        inptr+=2;
+      }
+      inptr += (w-mw);
+    }
+  }
+  else
+  {
+    unsigned char *outptr;
+    unsigned int *inptr;
+    int mw=min(w*4,out->lPitch);
+    int y;
+    inptr=(unsigned int*)in + (sy*w);
+    outptr=(unsigned char *)out->lpSurface + (sy*out->lPitch);
+    for (y = sy; y < ey; y ++)
+    {
+      memcpy(outptr,inptr,mw);
+      inptr+=w;
+      outptr+=out->lPitch;
+    }
+  }
+}
+#endif
+
+static int unlocksurfaces()
+{
+  int a=0;
+  if (g_lpRenderSurf[0] && g_lpRenderSurf[0]->Unlock(g_lpsurf[0]) != DD_OK) a=1;
+  if (g_lpRenderSurf[1] && g_lpRenderSurf[1]->Unlock(g_lpsurf[1]) != DD_OK) a=1;
+  return a;
+}
+
+void DDraw_Exit(int which)
+{
+  if (!g_lpRenderSurf[0] || !g_lpRenderSurf[1]) 
+  {
+    unlocksurfaces();
+    goto endfunc;
+  }
+#ifdef RESIZE_ONRESIZE
+  last_used=which;
+#endif
+
+	if (g_fs && !cfg_fs_use_overlay)
+	{
+    int fsy=g_h/2-((g_fs_height/2));
+		RECT r={0,0,g_w,g_h};
+    if (g_bpp != 32) // non-32bpp mode
+    {      
+      if (fsy>0 && ((cfg_fs_fps&1) || (statustext_life&&!(cfg_fs_fps&8)))) // clear portions of backbuffer if necessary
+      {
+        DDBLTFX ddbfx={sizeof(ddbfx),};
+        int ty=min(fsy,16);
+        RECT r2={0,0,g_w,ty};
+        g_lpPrimSurfBack->Blt(&r2,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+        r2.top=g_h-ty;
+        r2.bottom=g_h-1;
+        g_lpPrimSurfBack->Blt(&r2,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+      }
+#ifndef NO_X86ASM
+		  if (!(g_fs_flip&8) && !g_windowed_dsize) // homemade bltshit
+      {
+	      DDSURFACEDESC d={sizeof(d),};
+        HRESULT han;
+	      han = g_lpPrimSurfBack->Lock(NULL,&d,DDLOCK_WAIT,NULL);
+        if (han == DDERR_SURFACELOST)
+        {
+          DDBLTFX ddbfx={sizeof(ddbfx),};
+          g_lpPrimSurfBack->Restore();
+          g_lpPrimSurfBack->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+          han = g_lpPrimSurfBack->Lock(NULL,&d,DDLOCK_WAIT,NULL);
+        }
+        if (han != DD_OK) goto slow_fs_non32bpp;
+
+        homemadeBlitFrom32bpp(&d,g_lpsurf[which],g_w,g_h,fsy,g_h-fsy);
+
+        int a=0;
+        if (g_lpPrimSurfBack->Unlock(d.lpSurface) != DD_OK ) a=1;
+	      if (unlocksurfaces()||a)
+	      {
+          goto endfunc;
+	      }
+      }
+      else // slow (stretchblt)
+#endif
+      {
+		    HDC in, out;
+#ifndef NO_X86ASM
+slow_fs_non32bpp:
+#endif
+        if (unlocksurfaces() || g_lpPrimSurfBack->GetDC(&out) != DD_OK)
+        {
+          goto endfunc;
+        }
+		    if (g_lpRenderSurf[which]->GetDC(&in) != DD_OK)
+		    {
+          g_lpPrimSurfBack->ReleaseDC(out);
+          goto endfunc;
+		    }
+        if (g_windowed_dsize) StretchBlt(out,0,fsy*2,g_dsw,g_dsh-fsy*4,in,0,fsy,g_w,g_h-fsy*2,SRCCOPY);
+        else BitBlt(out,0,fsy,g_w,g_h-fsy*2,in,0,fsy,SRCCOPY);
+		    g_lpRenderSurf[which]->ReleaseDC(in);
+        g_lpPrimSurfBack->ReleaseDC(out);        
+      }
+    }
+    else // 32bpp - always just use Blt() - will scale if necessary (yay Blt!)
+    {
+      //RECT or={0,g_go_fs_h/2-g_go_fs_height/2,g_go_fs_w,g_go_fs_h/2+g_go_fs_height/2};
+      //RECT ir={0,g_h/2-g_go_fs_height/2,g_w,g_h/2+g_go_fs_height/2};
+      if (unlocksurfaces())
+      {
+        goto endfunc;
+	    }
+		  if (g_lpPrimSurfBack->Blt(NULL,g_lpRenderSurf[which],&r,DDBLT_WAIT,NULL) == DDERR_SURFACELOST)
+		  {
+        DDBLTFX ddbfx={sizeof(ddbfx),};
+			  if (g_fs_flip&1)
+        {
+          g_lpPrimSurfBack->Restore();
+          g_lpPrimSurfBack->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+        }
+			  g_lpPrimSurf->Restore();
+        g_lpPrimSurf->Blt(NULL,NULL,NULL,DDBLT_WAIT|DDBLT_COLORFILL,&ddbfx);
+        goto endfunc;
+		  }
+    }
+    do_gettitle();
+    if ((cfg_fs_fps&1) || (draw_title_p>0&&!(cfg_fs_fps&16)) || (statustext_life&&!(cfg_fs_fps&8)))
+    {
+		  HDC out;
+      if (g_lpPrimSurfBack->GetDC(&out) == DD_OK)
+      {
+        char str[2048];
+        SetBkMode(out,TRANSPARENT);
+        if (cfg_fs_fps&1) 
+        {
+          RECT r={2,2,g_fs_w,g_fs_h};
+          wsprintf(str,"%d.%d",g_dlg_fps/10,g_dlg_fps%10);
+			    SetTextColor(out,RGB(0,0,0));
+          DrawText(out,str,-1,&r,DT_TOP|DT_LEFT|DT_SINGLELINE|DT_NOCLIP|DT_NOPREFIX);
+			    r.left=r.top=0;
+			    SetTextColor(out,RGB(255,255,255));
+          DrawText(out,str,-1,&r,DT_TOP|DT_LEFT|DT_SINGLELINE|DT_NOCLIP|DT_NOPREFIX);
+        }
+        if (statustext_life&&!(cfg_fs_fps&8))
+        {
+          if (statustext_life==1) statustext_life=GetTickCount()+statustext_len;
+          RECT r={0,0,g_fs_w,g_fs_h};
+          if (GetTickCount() > statustext_life) 
+          {
+            if (statustext_life==2) statustext_life=0;
+            else statustext_life=2;
+          }
+          else
+          {
+            SetTextColor(out,RGB(0,0,0));
+            DrawText(out,statustext,-1,&r,DT_BOTTOM|DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX);
+            SetTextColor(out,RGB(255,255,255));
+            r.right-=2;
+            r.bottom-=2;
+            DrawText(out,statustext,-1,&r,DT_BOTTOM|DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX);
+          }
+        }
+        if (draw_title_p>0&&!(cfg_fs_fps&16)) 
+        { 
+          RECT r={4,4,g_fs_w,g_fs_h};
+			    SetTextColor(out,RGB(0,0,0));
+          DrawText(out,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+			    r.left=r.top=0;
+			    SetTextColor(out,RGB(255,255,255));
+          DrawText(out,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+        }
+        g_lpPrimSurfBack->ReleaseDC(out);
+      }
+      if (draw_title_p>0 && draw_title_time < GetTickCount() && !(cfg_fs_fps&16))
+      {
+        if (g_lpRenderSurf[which]->GetDC(&out) == DD_OK)
+        {
+          RECT r={4,4,g_w,g_h};
+			    SetBkMode(out,TRANSPARENT);
+			    SetTextColor(out,RGB(0,0,0));
+          DrawText(out,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+			    r.left=r.top=0;
+			    SetTextColor(out,RGB(255,255,255));
+          DrawText(out,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+          g_lpRenderSurf[which]->ReleaseDC(out);
+        }
+        draw_title_p=0;
+      }    
+    }
+		if (g_fs_flip&1) g_lpPrimSurf->Flip(NULL, DDFLIP_WAIT);
+    else if (!(g_fs_flip&2)) g_lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
+	}
+	else
+	{
+    if(g_overlay_init_ok)
+    {
+      LPDDSURFACEDESC pd=(which==0?&d:&d2);
+	    DDSURFACEDESC dd={sizeof(dd),};
+      if (g_fs) if (!(cfg_fs_flip&2)) g_lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
+
+	    if (g_lpddsOverlay->Lock(NULL,&dd,DDLOCK_WAIT,NULL) != DD_OK) 
+      {
+        g_overlay_init_ok=0;
+        goto endfunc;
+      }
+#ifndef NO_MMX
+        CopyRGBSurfaceToYUVSurfaceMMX(pd,&dd,g_overlay_fourcc);
+#else
+        CopyRGBSurfaceToYUVSurface(pd,&dd,g_overlay_fourcc);
+#endif
+      g_lpddsOverlay->Unlock(&dd);
+      if (g_fs) 
+      {
+        unlocksurfaces();
+        goto endfunc;
+      }
+    }
+
+		HDC in1, out, in2=NULL;
+	  if (unlocksurfaces() || g_lpRenderSurf[which]->GetDC(&in1) != DD_OK)
+	  {
+      goto endfunc;
+	  }
+    do_gettitle();
+    if (draw_title_p>0&&!(cfg_fs_fps&4) && draw_title_time < GetTickCount())
+    {
+      RECT r={4,4,g_w,g_h};
+			SetBkMode(in1,TRANSPARENT);
+			SetTextColor(in1,RGB(0,0,0));
+      DrawText(in1,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+			r.left=r.top=0;
+			SetTextColor(in1,RGB(255,255,255));
+      DrawText(in1,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+      draw_title_p=0;
+    }
+    if ((draw_title_p > 0&&!(cfg_fs_fps&4)) || (statustext_life&&!(cfg_fs_fps&2)))
+    {
+      // draw perframe
+      RECT r={4,4,g_w,g_h};
+		  if (g_lpRenderSurf[which^1]->GetDC(&in2) != DD_OK)
+		  {
+        in2=NULL; 
+        goto abort_thingy;
+		  }
+      BitBlt(in2,0,0,g_w,g_h,in1,0,0,SRCCOPY);
+      SetBkMode(in2,TRANSPARENT);
+      if (draw_title_p > 0&&!(cfg_fs_fps&4))
+      {
+			  SetTextColor(in2,RGB(0,0,0));
+        DrawText(in2,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+			  r.left=r.top=0;
+			  SetTextColor(in2,RGB(255,255,255));
+        DrawText(in2,last_title,-1,&r,DT_VCENTER|DT_CENTER|DT_SINGLELINE|DT_NOPREFIX);
+      }
+      if (statustext_life&&!(cfg_fs_fps&2))
+      {
+        if (statustext_life==1) statustext_life=GetTickCount()+statustext_len;
+        if (GetTickCount() > statustext_life) statustext_life=0;
+			  SetTextColor(in2,RGB(0,0,0));
+        DrawText(in2,statustext,-1,&r,DT_BOTTOM|DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX);
+        r.right-=2;
+        r.bottom-=2;
+			  SetTextColor(in2,RGB(255,255,255));
+        DrawText(in2,statustext,-1,&r,DT_BOTTOM|DT_RIGHT|DT_SINGLELINE|DT_NOPREFIX);
+      }
+    }
+abort_thingy:
+    if (!(cfg_fs_flip&4)) g_lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN,0);
+		out=GetDC(g_hwnd);
+    if (out)
+    {
+      if (!g_windowed_dsize)
+      {
+#ifndef WA2_EMBED
+        BitBlt(out,inWharf?0:7,inWharf?0:15,g_w-g_noshoww,g_h,in2?in2:in1,0,0,SRCCOPY);
+#else
+        BitBlt(out,0,0,g_w-g_noshoww,g_h,in2?in2:in1,0,0,SRCCOPY);
+#endif
+      }
+      else
+      {
+#ifndef WA2_EMBED
+        StretchBlt(out,inWharf?0:7,inWharf?0:15,g_dsw,g_dsh,in2?in2:in1,0,0,g_w,g_h,SRCCOPY);
+#else
+        StretchBlt(out,0,0,g_dsw,g_dsh,in2?in2:in1,0,0,g_w,g_h,SRCCOPY);
+#endif
+      }
+  		ReleaseDC(g_hwnd,out);
+    }
+		g_lpRenderSurf[which]->ReleaseDC(in1);
+    if (in2)
+      g_lpRenderSurf[which^1]->ReleaseDC(in2);
+	}
+endfunc:
+  LeaveCriticalSection(&g_cs);
+}
+
+
+void DDraw_SetFullScreen(int fs, int w, int h, int dbl, int bpp)
+{
+  if (!fs) DD_CreateSurfaces(w, h, 0, 0, 0, 0, !!dbl, 0);
+  else
+  {
+    DD_CreateSurfaces(w, h, (min(max(1,cfg_fs_height),100)*h)/100, 1, bpp, cfg_fs_flip, !!dbl, cfg_fs_use_overlay);
+  }
+}
+
+int DDraw_IsFullScreen(void)
+{
+	return g_fs;
+}
+
+HRESULT WINAPI _cb(  
+				   LPDDSURFACEDESC lpDDSurfaceDesc,  LPVOID lpContext)
+{
+	HWND h=(HWND)lpContext;
+	if ((lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGB) &&
+		(lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==32 ||
+		lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==24 ||
+    lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==16 ||
+    lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==15))
+	{
+		char s[256];
+    wsprintf(s,"%dx%d@%dBPP",lpDDSurfaceDesc->dwWidth,lpDDSurfaceDesc->dwHeight,lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount);
+		SendMessage(h,CB_ADDSTRING,0,(long)s);
+	}
+
+	return DDENUMRET_OK;
+}
+
+
+void DDraw_EnumDispModes(HWND hwnd)
+{
+	if (g_lpDD)
+  	g_lpDD->EnumDisplayModes(0,NULL,hwnd,_cb);
+}
+
+static int g_st;
+
+HRESULT WINAPI _cb2(  
+				   LPDDSURFACEDESC lpDDSurfaceDesc,  LPVOID lpContext)
+{
+	DWORD *x=(DWORD *)lpContext;
+  if (x[0]==lpDDSurfaceDesc->dwWidth &&
+      x[1]==lpDDSurfaceDesc->dwHeight &&
+      x[2]==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount) 
+  {
+    g_st=1;
+    return DDENUMRET_CANCEL;
+  }
+
+	return DDENUMRET_OK;
+}
+
+int DDraw_IsMode(int w, int h, int bpp)
+{
+  int x[3]={w,h,bpp};
+  if (!x[0] || !x[1] || !x[2]) return 0;
+	if (!g_lpDD) return 0;
+  g_st=0;
+  g_lpDD->EnumDisplayModes(0,NULL,(LPVOID)x,_cb2);
+  return g_st;
+}
+
+HRESULT WINAPI _cb3(  
+				   LPDDSURFACEDESC lpDDSurfaceDesc,  LPVOID lpContext)
+{
+	if ((lpDDSurfaceDesc->ddpfPixelFormat.dwFlags & DDPF_RGB) &&
+		(lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==32 ||
+		lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==24 ||
+    lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==16 ||
+    lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount==15))
+  {  
+    int *(*x)=(int **)lpContext;
+    if (lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount > (DWORD)x[2][0] || 
+        lpDDSurfaceDesc->dwWidth < (DWORD)x[0][0] ||
+        lpDDSurfaceDesc->dwHeight < (DWORD)x[1][0])
+    {
+      x[0][0]=lpDDSurfaceDesc->dwWidth;
+      x[1][0]=lpDDSurfaceDesc->dwHeight;
+      x[2][0]=lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount;
+    }
+  }
+
+	return DDENUMRET_OK;
+}
+
+
+int DDraw_PickMode(int *w, int *h, int *bpp)
+{
+  int *(x[3])={w,h,bpp};
+  *w=0;
+  *h=0;
+  *bpp=0;
+  // return if mode found that is suitable
+  g_lpDD->EnumDisplayModes(0,NULL,(LPVOID)x,_cb3);
+  return *w && *h && *bpp;
+}
+
+double DDraw_translatePoint(POINT p, int isY)
+{
+  double v=0.0;
+  if(g_fs && g_overlay_init_ok && hwndOverlayWnd && IsWindow(hwndOverlayWnd)) 
+  {
+    RECT r;
+    ScreenToClient(hwndOverlayWnd,&p);
+    GetClientRect(hwndOverlayWnd,&r);
+    if (isY) 
+    {
+      if (r.bottom>0)
+        v=p.y/(double)(r.bottom*0.5) - 1.0;
+    }
+    else
+    {
+      if (r.right>0)
+        v=p.x/(double)(r.right*0.5) - 1.0;
+    }
+  }
+  else
+  {
+    ScreenToClient(g_hwnd,&p);
+ 
+    if (isY) 
+    {
+      if (g_dsh>0)
+        v=p.y/(double)(g_dsh*0.5) - 1.0;
+    }
+    else
+    {
+      if (g_dsw>0)
+        v=p.x/(double)(g_dsw*0.5) - 1.0;
+    }
+  }
+  //if (v > 1.0) v=1.0;
+  //if (v < -1.0) v=-1.0;
+  return v;
+}
\ No newline at end of file