path: root/Src/Plugins/Visualization/vis_milk2/pluginshell.cpp

/*
  LICENSE
  -------
Copyright 2005-2013 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.
*/

/*
    TO DO
    -----
    -done/v1.06:
        -(nothing yet)
        -
        -
    -to do/v1.06:
        -FFT: high freq. data kinda sucks because of the 8-bit samples we get in;
            look for justin to put 16-bit vis data into wa5.
        -make an 'advanced view' button on config panel; hide complicated stuff
            til they click that.
        -put an asterisk(*) next to the 'max framerate' values that
            are ideal (given the current windows display mode or selected FS dispmode).
        -or add checkbox: "smart sync"
            -> matches FPS limit to nearest integer divisor of refresh rate.
        -debug.txt/logging support!
        -audio: make it a DSP plugin? then we could get the complete, continuous waveform
            and overlap our waveform windows, so we'd never miss a brief high note.
        -bugs:
            -vms plugins sometimes freeze after a several-minute pause; I've seen it
                with most of them.  hard to repro, though.
            -running FS on monitor 2, hit ALT-TAB -> minimizes!!!
                -but only if you let go of TAB first.  Let go of ALT first and it's fine!
                -> means it's related to the keyup...
            -fix delayloadhelper leak; one for each launch to config panel/plugin.
            -also, delayload(d3d9.dll) still leaks, if plugin has error initializing and
                quits by returning false from PluginInitialize().
        -add config panel option to ignore fake-fullscreen tips
            -"tip" boxes in dxcontext.cpp
            -"notice" box on WM_ACTIVATEAPP?
        -desktop mode:
            -icon context menus: 'send to', 'cut', and 'copy' links do nothing.
                -http://netez.com/2xExplorer/shellFAQ/bas_context.html
            -create a 2nd texture to render all icon text labels into
                (they're the sole reason that desktop mode is slow)
            -in UpdateIconBitmaps, don't read the whole bitmap and THEN
                realize it's a dupe; try to compare icon filename+index or somethign?
            -DRAG AND DROP.  COMPLICATED; MANY DETAILS.
                -http://netez.com/2xExplorer/shellFAQ/adv_drag.html
                -http://www.codeproject.com/shell/explorerdragdrop.asp
                -hmm... you can't drag icons between the 2 desktops (ugh)
            -multiple delete/open/props/etc
            -delete + enter + arrow keys.
            -try to solve mysteries w/ShellExecuteEx() and desktop *shortcuts* (*.lnk).
            -(notice that when icons are selected, they get modulated by the
                highlight color, when they should be blended 50% with that color.)

    ---------------------------
    final touches:
        -Tests:
            -make sure desktop still functions/responds properly when winamp paused
            -desktop mode + multimon:
                -try desktop mode on all monitors
                -try moving taskbar around; make sure icons are in the
                    right place, that context menus (general & for
                    specific icons) pop up in the right place, and that
                    text-off-left-edge is ok.
                -try setting the 2 monitors to different/same resolutions
        -check tab order of config panel controls!
        -Clean All
        -build in release mode to include in the ZIP
        -leave only one file open in workspace: README.TXT.
        -TEMPORARILY "ATTRIB -R" ALL FILES BEFORE ZIPPING THEM!

    ---------------------------
    KEEP IN VIEW:
        -EMBEDWND:
            -kiv: on resize of embedwnd, it's out of our control; winamp
                resizes the child every time the mouse position changes,
                and we have to cleanup & reallocate everything, b/c we
                can't tell when the resize begins & ends.
                [justin said he'd fix in wa5, though]
            -kiv: with embedded windows of any type (plugin, playlist, etc.)
                you can't place the winamp main wnd over them.
            -kiv: embedded windows are child windows and don't get the
                WM_SETFOCUS or WM_KILLFOCUS messages when they get or lose
                the focus.  (For a workaround, see milkdrop & scroll lock key.)
            -kiv: tiny bug (IGNORE): when switching between embedwnd &
                no-embedding, the window gets scooted a tiny tiny bit.
        -kiv: fake fullscreen mode w/multiple monitors: there is no way
            to keep the taskbar from popping up [potentially overtop of
            the plugin] when you click on something besides the plugin.
            To get around this, use true fullscreen mode.
        -kiv: max_fps implementation assumptions:
            -that most computers support high-precision timer
            -that no computers [regularly] sleep for more than 1-2 ms
                when you call Sleep(1) after timeBeginPeriod(1).
        -reminder: if vms_desktop.dll's interface needs changed,
            it will have to be renamed!  (version # upgrades are ok
            as long as it won't break on an old version; if the
            new functionality is essential, rename the DLL.)

    ---------------------------
    REMEMBER:
        -GF2MX + GF4 have icon scooting probs in desktop mode
            (when taskbar is on upper or left edge of screen)
        -Radeon is the one w/super slow text probs @ 1280x1024.
            (it goes unstable after you show playlist AND helpscr; -> ~1 fps)
        -Mark's win98 machine has hidden cursor (in all modes),
            but no one else seems to have this problem.
        -links:
            -win2k-only-style desktop mode: (uses VirtualAllocEx, vs. DLL Injection)
                http://www.digiwar.com/scripts/renderpage.php?section=2&subsection=2
            -http://www.experts-exchange.com/Programming/Programming_Platforms/Win_Prog/Q_20096218.html
*/

#include "api__vis_milk2.h"
#include "pluginshell.h"
#include "utility.h"
#include "defines.h"
#include "shell_defines.h"
#include "resource.h"
#include "vis.h"
#include <multimon.h>
#include "../Winamp/wa_ipc.h"
#include "../nu/AutoCharFn.h"
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")    // for timeGetTime

// STATE VALUES & VERTEX FORMATS FOR HELP SCREEN TEXTURE:
#define TEXT_SURFACE_NOT_READY  0
#define TEXT_SURFACE_REQUESTED  1
#define TEXT_SURFACE_READY      2
#define TEXT_SURFACE_ERROR      3
typedef struct _HELPVERTEX
{
	float x, y;      // screen position
	float z;         // Z-buffer depth
	DWORD Diffuse;   // diffuse color. also acts as filler; aligns struct to 16 bytes (good for random access/indexed prims)
	float tu, tv;    // texture coordinates for texture #0
} HELPVERTEX, *LPHELPVERTEX;
#define HELP_VERTEX_FORMAT (D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1)
typedef struct _SIMPLEVERTEX
{
	float x, y;      // screen position
	float z;         // Z-buffer depth
	DWORD Diffuse;   // diffuse color. also acts as filler; aligns struct to 16 bytes (good for random access/indexed prims)
} SIMPLEVERTEX, *LPSIMPLEVERTEX;
#define SIMPLE_VERTEX_FORMAT (D3DFVF_XYZ | D3DFVF_DIFFUSE)

extern wchar_t* g_szHelp;
extern int g_szHelp_W;
extern winampVisModule mod1;

// resides in vms_desktop.dll/lib:
void getItemData(int x);


CPluginShell::CPluginShell()
{
	// this should remain empty!
}

CPluginShell::~CPluginShell()
{
	// this should remain empty!
}

eScrMode  CPluginShell::GetScreenMode()
{
	return m_screenmode;
}
int       CPluginShell::GetFrame()
{
	return m_frame;
}
float     CPluginShell::GetTime()
{
	return m_time;
}
float     CPluginShell::GetFps()
{
	return m_fps;
}
HWND      CPluginShell::GetPluginWindow()
{
	if (m_lpDX) return m_lpDX->GetHwnd();       else return NULL;
}
int       CPluginShell::GetWidth()
{
	if (m_lpDX) return m_lpDX->m_client_width;  else return 0;
}
int       CPluginShell::GetHeight()
{
	if (m_lpDX) return m_lpDX->m_client_height; else return 0;
}
int       CPluginShell::GetCanvasMarginX()
{
	if (m_lpDX && m_screenmode==WINDOWED) return (m_lpDX->m_client_width  - m_lpDX->m_REAL_client_width)/2; else return 0;
}
int       CPluginShell::GetCanvasMarginY()
{
	if (m_lpDX && m_screenmode==WINDOWED) return (m_lpDX->m_client_height - m_lpDX->m_REAL_client_height)/2; else return 0;
}
HWND      CPluginShell::GetWinampWindow()
{
	return m_hWndWinamp;
}
HINSTANCE CPluginShell::GetInstance()
{
	return m_hInstance;
}
wchar_t* CPluginShell::GetPluginsDirPath()
{
	return m_szPluginsDirPath;
}
wchar_t* CPluginShell::GetConfigIniFile()
{
	return m_szConfigIniFile;
}
char* CPluginShell::GetConfigIniFileA()
{
	return m_szConfigIniFileA;
}
int       CPluginShell::GetFontHeight(eFontIndex idx)
{
	if (idx >= 0 && idx < NUM_BASIC_FONTS + NUM_EXTRA_FONTS) return m_fontinfo[idx].nSize; else return 0;
}
int       CPluginShell::GetBitDepth()
{
	return m_lpDX->GetBitDepth();
}
LPDIRECT3DDEVICE9 CPluginShell::GetDevice()
{
	if (m_lpDX) return m_lpDX->m_lpDevice; else return NULL;
}
D3DCAPS9* CPluginShell::GetCaps()
{
	if (m_lpDX) return &(m_lpDX->m_caps);  else return NULL;
}
D3DFORMAT CPluginShell::GetBackBufFormat()
{
	if (m_lpDX) return m_lpDX->m_current_mode.display_mode.Format; else return D3DFMT_UNKNOWN;
}
D3DFORMAT CPluginShell::GetBackBufZFormat()
{
	if (m_lpDX) return m_lpDX->GetZFormat(); else return D3DFMT_UNKNOWN;
}
LPD3DXFONT CPluginShell::GetFont(eFontIndex idx)
{
	if (idx >= 0 && idx < NUM_BASIC_FONTS + NUM_EXTRA_FONTS) return m_d3dx_font[idx]; else return NULL;
}
char* CPluginShell::GetDriverFilename()
{
	if (m_lpDX) return m_lpDX->GetDriver(); else return NULL;
}
char* CPluginShell::GetDriverDescription()
{
	if (m_lpDX) return m_lpDX->GetDesc(); else return NULL;
}

int CPluginShell::InitNondx9Stuff()
{
	timeBeginPeriod(1);
	m_fftobj.Init(576, NUM_FREQUENCIES);
	if (!InitGDIStuff()) return false;
	return AllocateMyNonDx9Stuff();
}

void CPluginShell::CleanUpNondx9Stuff()
{
	timeEndPeriod(1);
	CleanUpMyNonDx9Stuff();
	CleanUpGDIStuff();
	m_fftobj.CleanUp();
}

int CPluginShell::InitGDIStuff()
{
	wchar_t title[64];
	// note: messagebox parent window should be NULL here, because lpDX is still NULL!
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
	{
		if (!(m_font[i] = CreateFontW(m_fontinfo[i].nSize, 0, 0, 0, m_fontinfo[i].bBold ? 900 : 400, m_fontinfo[i].bItalic, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, m_fontinfo[i].bAntiAliased ? ANTIALIASED_QUALITY : DEFAULT_QUALITY, DEFAULT_PITCH, m_fontinfo[i].szFace)))
		{
			MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_GDI_FONTS),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}
	}

	if (!(m_main_menu = WASABI_API_LOADMENU(IDR_WINDOWED_CONTEXT_MENU)))
	{
		MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_LOADING_MAIN_MENU),
				    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
				    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
		return false;
	}

	if (!(m_context_menu = GetSubMenu(m_main_menu, 0)))
	{
		MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_LOADING_CONTEXT_MENU),
				    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
				    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
		return false;
	}

	return true;
}

void CPluginShell::CleanUpGDIStuff()
{
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
	{
		if (m_font[i])
		{
			DeleteObject(m_font[i]);
			m_font[i] = NULL;
		}
	}

	/*if (m_context_menu)
	{
	    DestroyMenu(m_context_menu);
	    m_context_menu = NULL;
	}*/

	if (m_main_menu)
	{
		DestroyMenu(m_main_menu);
		m_main_menu = NULL;
	}

	//CleanUpMyGDIStuff();
}

int CPluginShell::InitVJStuff(RECT* pClientRect)
{
	wchar_t title[64];
	// Init VJ mode (second window for text):
	if (m_vj_mode)
	{
		DWORD dwStyle = WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU;
		POINT upper_left_corner;
		upper_left_corner.x = 0;
		upper_left_corner.y = 0;

		// Create direct 3d & get some infos
		if (!(m_vjd3d9 = Direct3DCreate9(D3D_SDK_VERSION)))
		{
			MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_DIRECT3D_DEVICE_FOR_VJ_MODE),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64), MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}

		// Get ordinal adapter # for the currently-selected Windowed Mode display adapter
		int ordinal_adapter = D3DADAPTER_DEFAULT;
		int nAdapters = m_vjd3d9->GetAdapterCount();
		for (int i=0; i<nAdapters; i++)
		{
			D3DADAPTER_IDENTIFIER9 temp;
			if ((m_vjd3d9->GetAdapterIdentifier(i, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &temp) == D3D_OK) &&
			    (memcmp(&temp.DeviceIdentifier, &m_adapter_guid_windowed, sizeof(GUID))==0))
			{
				ordinal_adapter = i;
				break;
			}
		}

		// Get current display mode for windowed-mode adapter:
		D3DDISPLAYMODE dm;
		if (D3D_OK != m_vjd3d9->GetAdapterDisplayMode(ordinal_adapter, &dm))
		{
			MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_VJ_MODE_INIT_ERROR),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}

		// And get the upper-left corner of the monitor for it:
		HMONITOR hMon = m_vjd3d9->GetAdapterMonitor(ordinal_adapter);
		if (hMon)
		{
			MONITORINFO mi;
			mi.cbSize = sizeof(mi);
			if (GetMonitorInfo(hMon, &mi))
			{
				upper_left_corner.x = mi.rcWork.left;
				upper_left_corner.y = mi.rcWork.top;
			}
		}

		// CREATE THE WINDOW

		RECT rect;
		if (pClientRect)
		{
			rect = *pClientRect;
			AdjustWindowRect(&rect, dwStyle, 0); // convert client->wnd
		}
		else
		{
			SetRect(&rect, 0, 0, 384, 384);
			AdjustWindowRect(&rect, dwStyle, 0); // convert client->wnd

			rect.right  -= rect.left;
			rect.left   = 0;
			rect.bottom -= rect.top;
			rect.top    = 0;

			rect.top    += upper_left_corner.y+32;
			rect.left   += upper_left_corner.x+32;
			rect.right  += upper_left_corner.x+32;
			rect.bottom += upper_left_corner.y+32;
		}

		WNDCLASS wc = {0};
		wc.lpfnWndProc = VJModeWndProc;				// our window procedure
		wc.hInstance = GetInstance();	// hInstance of DLL
		wc.hIcon = LoadIcon(GetInstance(), MAKEINTRESOURCE(IDI_PLUGIN_ICON));
		wc.lpszClassName = TEXT_WINDOW_CLASSNAME;			// our window class name
		wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; // CS_DBLCLKS lets the window receive WM_LBUTTONDBLCLK, for toggling fullscreen mode...
		wc.cbWndExtra = sizeof(DWORD);
		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
		wc.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);

		if (!RegisterClass(&wc))
		{
			MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_REGISTERING_WINDOW_CLASS_FOR_TEXT_WINDOW),
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}
		m_bTextWindowClassRegistered = true;

		//DWORD nThreadID;
		//CreateThread(NULL, 0, TextWindowThread, &rect, 0, &nThreadID);

		// Create the text window
		m_hTextWnd = CreateWindowEx(
		               0,
		               TEXT_WINDOW_CLASSNAME,				// our window class name
		               TEXT_WINDOW_CLASSNAME,				// use description for a window title
		               dwStyle,
		               rect.left, rect.top,								// screen position (read from config)
		               rect.right - rect.left, rect.bottom - rect.top,  // width & height of window (need to adjust client area later)
		               NULL,								// parent window (winamp main window)
		               NULL,								// no menu
		               GetInstance(),						// hInstance of DLL
		               NULL
		             ); // no window creation data

		if (!m_hTextWnd)
		{
			MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_VJ_WINDOW),
					   WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					   MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}

		SetWindowLongPtr(m_hTextWnd, GWLP_USERDATA, (LONG_PTR)this);

		GetClientRect(m_hTextWnd, &rect);
		m_nTextWndWidth  = rect.right-rect.left;
		m_nTextWndHeight = rect.bottom-rect.top;


		// Create the device
		D3DPRESENT_PARAMETERS pres_param;
		ZeroMemory(&pres_param,sizeof(pres_param));
		pres_param.BackBufferCount = 0;
		pres_param.BackBufferFormat = dm.Format;
		pres_param.BackBufferWidth  = rect.right - rect.left;
		pres_param.BackBufferHeight = rect.bottom - rect.top;
		pres_param.hDeviceWindow = m_hTextWnd;
		pres_param.AutoDepthStencilFormat = D3DFMT_D16;
		pres_param.EnableAutoDepthStencil = FALSE;
		pres_param.SwapEffect = D3DSWAPEFFECT_DISCARD;
		pres_param.MultiSampleType = D3DMULTISAMPLE_NONE;
		pres_param.Flags = 0;
		pres_param.FullScreen_RefreshRateInHz = 0;
		pres_param.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_ONE;//D3DPRESENT_INTERVAL_IMMEDIATE;//m_current_mode.allow_page_tearing ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;//D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_ONE;
		//pres_param.FullScreen_PresentationInterval = 0;
		pres_param.Windowed = TRUE;

		HRESULT hr;
		if (D3D_OK != (hr = m_vjd3d9->CreateDevice(ordinal_adapter,//D3DADAPTER_DEFAULT,
		                    D3DDEVTYPE_HAL,
		                    m_hTextWnd,
		                    D3DCREATE_SOFTWARE_VERTEXPROCESSING,
		                    &pres_param,
		                    &m_vjd3d9_device)))
		{
			m_vjd3d9_device = NULL;
			MessageBoxW(m_lpDX->GetHwnd(), WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_D3D_DEVICE_FOR_VJ_MODE),
					   WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					   MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}

		if (!AllocateFonts(m_vjd3d9_device))
			return false;

		if (m_fix_slow_text)    // note that when not doing vj mode, m_lpDDSText is allocated in AllocateDX9Stuff
			AllocateTextSurface();

		m_text.Finish();
		m_text.Init(m_vjd3d9_device, m_lpDDSText, 0);

		m_bClearVJWindow = true;
	}

	return true;
}

void CPluginShell::CleanUpVJStuff()
{
	// ALWAYS set the textures to NULL before releasing textures,
	// otherwise they might still have a hanging reference!
	if (m_lpDX && m_lpDX->m_lpDevice)
	{
		for (int i=0; i<16; i++)
			m_lpDX->m_lpDevice->SetTexture(i, NULL);
	}

	if (m_vjd3d9_device)
	{
		for (int i=0; i<16; i++)
			m_vjd3d9_device->SetTexture(i, NULL);
	}

	if (!m_vj_mode)
		return;

	// clean up VJ mode
	{
		CleanUpFonts();
		SafeRelease(m_lpDDSText);

		SafeRelease(m_vjd3d9_device);
		SafeRelease(m_vjd3d9);

		if (m_hTextWnd)
		{
			//dumpmsg("Finish: destroying text window");
			DestroyWindow(m_hTextWnd);
			m_hTextWnd = NULL;
			//dumpmsg("Finish: text window destroyed");
		}

		if (m_bTextWindowClassRegistered)
		{
			//dumpmsg("Finish: unregistering text window class");
			UnregisterClass(TEXT_WINDOW_CLASSNAME,GetInstance()); // unregister window class
			m_bTextWindowClassRegistered = false;
			//dumpmsg("Finish: text window class unregistered");
		}
	}
}

int CPluginShell::AllocateFonts(IDirect3DDevice9* pDevice)
{
	// Create D3DX system font:
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
		if (pCreateFontW(pDevice,  //m_font[i],
		                   m_fontinfo[i].nSize,
		                   m_fontinfo[i].nSize*4/10,
		                   m_fontinfo[i].bBold ? 900 : 400,
		                   1,  // mip levels
		                   m_fontinfo[i].bItalic,
		                   DEFAULT_CHARSET,
		                   OUT_DEFAULT_PRECIS,
		                   m_fontinfo[i].bAntiAliased ? ANTIALIASED_QUALITY : DEFAULT_QUALITY,
		                   DEFAULT_PITCH,
		                   m_fontinfo[i].szFace,
		                   &m_d3dx_font[i]
		                  ) != D3D_OK)
		{
			wchar_t title[64];
			MessageBoxW(m_lpDX ? m_lpDX->GetHwnd() : NULL, WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_D3DX_FONTS), 
					    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
					    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
			return false;
		}

	// get actual font heights
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
	{
		RECT r;
		SetRect(&r, 0, 0, 1024, 1024);
		int h = m_d3dx_font[i]->DrawText(NULL, "M", -1, &r, DT_CALCRECT, 0xFFFFFFFF);
		if (h>0) m_fontinfo[i].nSize = h;
	}

	return true;
}

void CPluginShell::CleanUpFonts()
{
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
		SafeRelease(m_d3dx_font[i]);
}

void CPluginShell::AllocateTextSurface()
{
	IDirect3DDevice9 *pDevice = m_vjd3d9_device ? m_vjd3d9_device : GetDevice();
	int w = m_vjd3d9_device ? m_nTextWndWidth  : GetWidth() ;
	int h = m_vjd3d9_device ? m_nTextWndHeight : GetHeight();

	if (D3D_OK != pCreateTexture(pDevice, w, h, 1, D3DUSAGE_RENDERTARGET, GetBackBufFormat(), D3DPOOL_DEFAULT, &m_lpDDSText))
		m_lpDDSText = NULL; // OK if there's not enough mem for it!
	else
	{
		// if m_lpDDSText doesn't cover enough of screen, cancel it.
		D3DSURFACE_DESC desc;
		if (D3D_OK == m_lpDDSText->GetLevelDesc(0, &desc))
		{
			if ((desc.Width  < 256 && w >= 256)  ||
			    (desc.Height < 256 && h >= 256)  ||
			    (desc.Width /(float)w < 0.74f) ||
			    (desc.Height/(float)h < 0.74f)
			   )
			{
				m_lpDDSText->Release();
				m_lpDDSText = NULL;
			}
		}
	}
}

int CPluginShell::AllocateDX9Stuff()
{
	if (!m_vj_mode)
	{
		AllocateFonts(m_lpDX->m_lpDevice);
		if (m_fix_slow_text)    // note that when not doing vj mode, m_lpDDSText is allocated in AllocateDX9Stuff
			AllocateTextSurface();
	}

	/*
	// Create D3DX system font:
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
	    if (pCreateFontW(m_lpDX->m_lpDevice,
					   m_fontinfo[i].nSize,
					   m_fontinfo[i].nSize*4/10,
	                       m_fontinfo[i].bBold ? 900 : 400,
		               0,  // mip levels
					   m_fontinfo[i].bItalic,
					   DEFAULT_CHARSET,
					   OUT_DEFAULT_PRECIS,
					   m_fontinfo[i].bAntiAliased ? ANTIALIASED_QUALITY : DEFAULT_QUALITY,
					   DEFAULT_PITCH,
					   m_fontinfo[i].szFace,
					   &m_d3dx_font[i]
					   ) != D3D_OK)
	    {
	        MessageBox(m_lpDX->GetHwnd(), "Error creating D3DX fonts", "ERROR", MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
	        return false;
	    }

	// get actual font heights
	for (i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
	{
	    RECT r;
	    SetRect(&r, 0, 0, 1024, 1024);
	    int h = m_d3dx_font[i]->DrawText(NULL, "M", -1, &r, DT_CALCRECT, 0xFFFFFFFF);
	    if (h>0) m_fontinfo[i].nSize = h;
	}
	*/

	if (m_screenmode == DESKTOP)
		if (!InitDesktopMode())
			return false;

	int ret = AllocateMyDX9Stuff();

	// invalidate various 'caches' here:
	m_playlist_top_idx = -1;    // invalidating playlist cache forces recompute of playlist width
	//m_icon_list.clear();      // clear desktop mode icon list, so it has to read the bitmaps back in

	if (!m_vj_mode)
	{
		m_text.Finish();
		m_text.Init(GetDevice(), m_lpDDSText, 1);
	}

	return ret;
}

void CPluginShell::CleanUpDX9Stuff(int final_cleanup)
{
	// ALWAYS unbind the textures before releasing textures,
	// otherwise they might still have a hanging reference!
	if (m_lpDX && m_lpDX->m_lpDevice)
	{
		for (int i=0; i<16; i++)
			m_lpDX->m_lpDevice->SetTexture(i, NULL);
	}

	if (m_screenmode == DESKTOP)
		CleanUpDesktopMode();

	if (!m_vj_mode)
	{
		for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
			SafeRelease(m_d3dx_font[i]);
		SafeRelease(m_lpDDSText);
	}

	CleanUpMyDX9Stuff(final_cleanup);
}

void CPluginShell::OnUserResizeTextWindow()
{
	// Update window properties
	RECT w, c;
	GetWindowRect(m_hTextWnd, &w);
	GetClientRect(m_hTextWnd, &c);

	WINDOWPLACEMENT wp;
	ZeroMemory(&wp, sizeof(wp));
	wp.length = sizeof(wp);
	GetWindowPlacement(m_hTextWnd, &wp);

	// convert client rect from client coords to screen coords:
	// (window rect is already in screen coords...)
	POINT p;
	p.x = c.left;
	p.y = c.top;
	if (ClientToScreen(m_hTextWnd, &p))
	{
		c.left += p.x;
		c.right += p.x;
		c.top += p.y;
		c.bottom += p.y;
	}

	if (wp.showCmd != SW_SHOWMINIMIZED)
	{
		if (m_nTextWndWidth  != c.right-c.left ||
		    m_nTextWndHeight != c.bottom-c.top)
		{
			CleanUpVJStuff();
			if (!InitVJStuff(&c))
			{
				SuggestHowToFreeSomeMem();
				m_lpDX->m_ready = false;   // flag to exit
				return;
			}
		}

		// save the new window position:
		//if (wp.showCmd==SW_SHOWNORMAL)
		//    SaveTextWindowPos();
	}
}

void CPluginShell::OnUserResizeWindow()
{
	// Update window properties
	RECT w, c;
	GetWindowRect(m_lpDX->GetHwnd(), &w);
	GetClientRect(m_lpDX->GetHwnd(), &c);

	WINDOWPLACEMENT wp;
	ZeroMemory(&wp, sizeof(wp));
	wp.length = sizeof(wp);
	GetWindowPlacement(m_lpDX->GetHwnd(), &wp);

	// convert client rect from client coords to screen coords:
	// (window rect is already in screen coords...)
	POINT p;
	p.x = c.left;
	p.y = c.top;
	if (ClientToScreen(m_lpDX->GetHwnd(), &p))
	{
		c.left += p.x;
		c.right += p.x;
		c.top += p.y;
		c.bottom += p.y;
	}

	if (wp.showCmd != SW_SHOWMINIMIZED)
	{
		int new_REAL_client_w = c.right-c.left;
		int new_REAL_client_h = c.bottom-c.top;

		// kiv: could we just resize when the *snapped* w/h changes?  slightly more ideal...
		if (m_lpDX->m_REAL_client_width  != new_REAL_client_w ||
		    m_lpDX->m_REAL_client_height != new_REAL_client_h)
		{
			//CleanUpVJStuff();
			CleanUpDX9Stuff(0);
			if (!m_lpDX->OnUserResizeWindow(&w, &c))
			{
				// note: a basic warning messagebox will have already been given.
				// now suggest specific advice on how to regain more video memory:
				SuggestHowToFreeSomeMem();
				return;
			}
			if (!AllocateDX9Stuff())
			{
				m_lpDX->m_ready = false;   // flag to exit
				return;
			}
			/*if (!InitVJStuff())
			{
			    m_lpDX->m_ready = false;   // flag to exit
			    return;
			}*/
		}

		// save the new window position:
		if (wp.showCmd==SW_SHOWNORMAL)
			m_lpDX->SaveWindow();
	}
}

void CPluginShell::StuffParams(DXCONTEXT_PARAMS *pParams)
{
	pParams->screenmode   = m_screenmode;
	pParams->display_mode = m_disp_mode_fs;
	pParams->nbackbuf     = 1;
	pParams->m_dualhead_horz = m_dualhead_horz;
	pParams->m_dualhead_vert = m_dualhead_vert;
	pParams->m_skin = (m_screenmode==WINDOWED) ? m_skin : 0;
	switch (m_screenmode)
	{
	case WINDOWED:
		pParams->allow_page_tearing = m_allow_page_tearing_w;
		pParams->adapter_guid       = m_adapter_guid_windowed;
		pParams->multisamp          = m_multisample_windowed;
		strcpy(pParams->adapter_devicename, m_adapter_devicename_windowed);
		break;
	case FULLSCREEN:
	case FAKE_FULLSCREEN:
		pParams->allow_page_tearing = m_allow_page_tearing_fs;
		pParams->adapter_guid       = m_adapter_guid_fullscreen;
		pParams->multisamp          = m_multisample_fullscreen;
		strcpy(pParams->adapter_devicename, m_adapter_devicename_fullscreen);
		break;
	case DESKTOP:
		pParams->allow_page_tearing = m_allow_page_tearing_dm;
		pParams->adapter_guid       = m_adapter_guid_desktop;
		pParams->multisamp          = m_multisample_desktop;
		strcpy(pParams->adapter_devicename, m_adapter_devicename_desktop);
		break;
	}
	pParams->parent_window = (m_screenmode==DESKTOP) ? m_hWndDesktopListView : NULL;
}

void CPluginShell::ToggleDesktop()
{
	CleanUpDX9Stuff(0);

	switch (m_screenmode)
	{
	case WINDOWED:
	case FULLSCREEN:
	case FAKE_FULLSCREEN:
		m_screenmode = DESKTOP;
		break;
	case DESKTOP:
		m_screenmode = WINDOWED;
		break;
	}

	DXCONTEXT_PARAMS params;
	StuffParams(&params);

	if (!m_lpDX->StartOrRestartDevice(&params))
	{
		// note: a basic warning messagebox will have already been given.
		if (m_lpDX->m_lastErr == DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY)
			SuggestHowToFreeSomeMem();
		return;
	}

	if (!AllocateDX9Stuff())
	{
		m_lpDX->m_ready = false;   // flag to exit
		return;
	}

	SetForegroundWindow(m_lpDX->GetHwnd());
	SetActiveWindow(m_lpDX->GetHwnd());
	SetFocus(m_lpDX->GetHwnd());
}

#define IPC_IS_PLAYING_VIDEO 501 // from wa_ipc.h
#define IPC_SET_VIS_FS_FLAG 631 // a vis should send this message with 1/as param to notify winamp that it has gone to or has come back from fullscreen mode

void CPluginShell::ToggleFullScreen()
{
	CleanUpDX9Stuff(0);

	switch (m_screenmode)
	{
	case DESKTOP:
	case WINDOWED:
		m_screenmode = m_fake_fullscreen_mode ? FAKE_FULLSCREEN : FULLSCREEN;
		if (m_screenmode == FULLSCREEN && SendMessage(GetWinampWindow(), WM_WA_IPC, 0, IPC_IS_PLAYING_VIDEO) > 1)
		{
			m_screenmode = FAKE_FULLSCREEN;
		}
		SendMessage(GetWinampWindow(), WM_WA_IPC, 1, IPC_SET_VIS_FS_FLAG);
		break;
	case FULLSCREEN:
	case FAKE_FULLSCREEN:
		m_screenmode = WINDOWED;
		SendMessage(GetWinampWindow(), WM_WA_IPC, 0, IPC_SET_VIS_FS_FLAG);
		break;
	}

	DXCONTEXT_PARAMS params;
	StuffParams(&params);

	if (!m_lpDX->StartOrRestartDevice(&params))
	{
		// note: a basic warning messagebox will have already been given.
		if (m_lpDX->m_lastErr == DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY)
			SuggestHowToFreeSomeMem();
		return;
	}

	if (!AllocateDX9Stuff())
	{
		m_lpDX->m_ready = false;   // flag to exit
		return;
	}

	SetForegroundWindow(m_lpDX->GetHwnd());
	SetActiveWindow(m_lpDX->GetHwnd());
	SetFocus(m_lpDX->GetHwnd());
}

void CPluginShell::ToggleHelp()
{
	m_show_help = 1-m_show_help;
	int ret = CheckMenuItem(m_context_menu, ID_SHOWHELP, MF_BYCOMMAND | (m_show_help ? MF_CHECKED : MF_UNCHECKED));
}

void CPluginShell::TogglePlaylist()
{
	m_show_playlist = 1-m_show_playlist;
	m_playlist_top_idx = -1;    // <- invalidates playlist cache
	int ret = CheckMenuItem(m_context_menu, ID_SHOWPLAYLIST, MF_BYCOMMAND | (m_show_playlist ? MF_CHECKED : MF_UNCHECKED));
}

int CPluginShell::InitDirectX()
{
	m_lpDX = new DXContext(m_hWndWinamp,m_hInstance,CLASSNAME,WINDOWCAPTION,CPluginShell::WindowProc,(LONG_PTR)this, m_minimize_winamp, m_szConfigIniFile);

	if (!m_lpDX)
	{
		wchar_t title[64];
		MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_UNABLE_TO_INIT_DXCONTEXT),
				    WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
				    MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
		return FALSE;
	}

	if (m_lpDX->m_lastErr != S_OK)
	{
		// warning messagebox will have already been given
		delete m_lpDX;
		return FALSE;
	}

	// initialize graphics
	DXCONTEXT_PARAMS params;
	StuffParams(&params);

	if (!m_lpDX->StartOrRestartDevice(&params))
	{
		// note: a basic warning messagebox will have already been given.

		if (m_lpDX->m_lastErr == DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY)
		{
			// suggest specific advice on how to regain more video memory:
			SuggestHowToFreeSomeMem();
		}

		delete m_lpDX;
		m_lpDX = NULL;
		return FALSE;
	}

	return TRUE;
}

void CPluginShell::CleanUpDirectX()
{
	SafeDelete(m_lpDX);
}

int CPluginShell::PluginPreInitialize(HWND hWinampWnd, HINSTANCE hWinampInstance)
{
	// PROTECTED CONFIG PANEL SETTINGS (also see 'private' settings, below)
	m_start_fullscreen      = 0;
	m_start_desktop         = 0;
	m_fake_fullscreen_mode  = 0;
	m_max_fps_fs            = 30;
	m_max_fps_dm            = 30;
	m_max_fps_w             = 30;
	m_show_press_f1_msg     = 1;
	m_allow_page_tearing_w  = 1;
	m_allow_page_tearing_fs = 0;
	m_allow_page_tearing_dm = 0;
	m_minimize_winamp       = 1;
	m_desktop_show_icons    = 1;
	m_desktop_textlabel_boxes = 1;
	m_desktop_manual_icon_scoot = 0;
	m_desktop_555_fix       = 2;
	m_dualhead_horz         = 2;
	m_dualhead_vert         = 1;
	m_save_cpu              = 1;
	m_skin                  = 1;
	m_fix_slow_text         = 0;

	// initialize font settings:
	wcscpy(m_fontinfo[SIMPLE_FONT    ].szFace,        SIMPLE_FONT_DEFAULT_FACE);
	m_fontinfo[SIMPLE_FONT    ].nSize        = SIMPLE_FONT_DEFAULT_SIZE ;
	m_fontinfo[SIMPLE_FONT    ].bBold        = SIMPLE_FONT_DEFAULT_BOLD ;
	m_fontinfo[SIMPLE_FONT    ].bItalic      = SIMPLE_FONT_DEFAULT_ITAL ;
	m_fontinfo[SIMPLE_FONT    ].bAntiAliased = SIMPLE_FONT_DEFAULT_AA   ;
	wcscpy(m_fontinfo[DECORATIVE_FONT].szFace,        DECORATIVE_FONT_DEFAULT_FACE);
	m_fontinfo[DECORATIVE_FONT].nSize        = DECORATIVE_FONT_DEFAULT_SIZE;
	m_fontinfo[DECORATIVE_FONT].bBold        = DECORATIVE_FONT_DEFAULT_BOLD;
	m_fontinfo[DECORATIVE_FONT].bItalic      = DECORATIVE_FONT_DEFAULT_ITAL;
	m_fontinfo[DECORATIVE_FONT].bAntiAliased = DECORATIVE_FONT_DEFAULT_AA  ;
	wcscpy(m_fontinfo[HELPSCREEN_FONT].szFace,        HELPSCREEN_FONT_DEFAULT_FACE);
	m_fontinfo[HELPSCREEN_FONT].nSize        = HELPSCREEN_FONT_DEFAULT_SIZE;
	m_fontinfo[HELPSCREEN_FONT].bBold        = HELPSCREEN_FONT_DEFAULT_BOLD;
	m_fontinfo[HELPSCREEN_FONT].bItalic      = HELPSCREEN_FONT_DEFAULT_ITAL;
	m_fontinfo[HELPSCREEN_FONT].bAntiAliased = HELPSCREEN_FONT_DEFAULT_AA  ;
	wcscpy(m_fontinfo[PLAYLIST_FONT  ].szFace,        PLAYLIST_FONT_DEFAULT_FACE);
	m_fontinfo[PLAYLIST_FONT  ].nSize        = PLAYLIST_FONT_DEFAULT_SIZE;
	m_fontinfo[PLAYLIST_FONT  ].bBold        = PLAYLIST_FONT_DEFAULT_BOLD;
	m_fontinfo[PLAYLIST_FONT  ].bItalic      = PLAYLIST_FONT_DEFAULT_ITAL;
	m_fontinfo[PLAYLIST_FONT  ].bAntiAliased = PLAYLIST_FONT_DEFAULT_AA  ;

#if (NUM_EXTRA_FONTS >= 1)
	wcscpy(m_fontinfo[NUM_BASIC_FONTS + 0].szFace,        EXTRA_FONT_1_DEFAULT_FACE);
	m_fontinfo[NUM_BASIC_FONTS + 0].nSize        = EXTRA_FONT_1_DEFAULT_SIZE;
	m_fontinfo[NUM_BASIC_FONTS + 0].bBold        = EXTRA_FONT_1_DEFAULT_BOLD;
	m_fontinfo[NUM_BASIC_FONTS + 0].bItalic      = EXTRA_FONT_1_DEFAULT_ITAL;
	m_fontinfo[NUM_BASIC_FONTS + 0].bAntiAliased = EXTRA_FONT_1_DEFAULT_AA;
#endif
#if (NUM_EXTRA_FONTS >= 2)
	wcscpy(m_fontinfo[NUM_BASIC_FONTS + 1].szFace,        EXTRA_FONT_2_DEFAULT_FACE);
	m_fontinfo[NUM_BASIC_FONTS + 1].nSize        = EXTRA_FONT_2_DEFAULT_SIZE;
	m_fontinfo[NUM_BASIC_FONTS + 1].bBold        = EXTRA_FONT_2_DEFAULT_BOLD;
	m_fontinfo[NUM_BASIC_FONTS + 1].bItalic      = EXTRA_FONT_2_DEFAULT_ITAL;
	m_fontinfo[NUM_BASIC_FONTS + 1].bAntiAliased = EXTRA_FONT_2_DEFAULT_AA;
#endif
#if (NUM_EXTRA_FONTS >= 3)
	strcpy(m_fontinfo[NUM_BASIC_FONTS + 2].szFace,        EXTRA_FONT_3_DEFAULT_FACE);
	m_fontinfo[NUM_BASIC_FONTS + 2].nSize        = EXTRA_FONT_3_DEFAULT_SIZE;
	m_fontinfo[NUM_BASIC_FONTS + 2].bBold        = EXTRA_FONT_3_DEFAULT_BOLD;
	m_fontinfo[NUM_BASIC_FONTS + 2].bItalic      = EXTRA_FONT_3_DEFAULT_ITAL;
	m_fontinfo[NUM_BASIC_FONTS + 2].bAntiAliased = EXTRA_FONT_3_DEFAULT_AA;
#endif
#if (NUM_EXTRA_FONTS >= 4)
	strcpy(m_fontinfo[NUM_BASIC_FONTS + 3].szFace,        EXTRA_FONT_4_DEFAULT_FACE);
	m_fontinfo[NUM_BASIC_FONTS + 3].nSize        = EXTRA_FONT_4_DEFAULT_SIZE;
	m_fontinfo[NUM_BASIC_FONTS + 3].bBold        = EXTRA_FONT_4_DEFAULT_BOLD;
	m_fontinfo[NUM_BASIC_FONTS + 3].bItalic      = EXTRA_FONT_4_DEFAULT_ITAL;
	m_fontinfo[NUM_BASIC_FONTS + 3].bAntiAliased = EXTRA_FONT_4_DEFAULT_AA;
#endif
#if (NUM_EXTRA_FONTS >= 5)
	strcpy(m_fontinfo[NUM_BASIC_FONTS + 4].szFace,        EXTRA_FONT_5_DEFAULT_FACE);
	m_fontinfo[NUM_BASIC_FONTS + 4].nSize        = EXTRA_FONT_5_DEFAULT_SIZE;
	m_fontinfo[NUM_BASIC_FONTS + 4].bBold        = EXTRA_FONT_5_DEFAULT_BOLD;
	m_fontinfo[NUM_BASIC_FONTS + 4].bItalic      = EXTRA_FONT_5_DEFAULT_ITAL;
	m_fontinfo[NUM_BASIC_FONTS + 4].bAntiAliased = EXTRA_FONT_5_DEFAULT_AA;
#endif

	m_disp_mode_fs.Width = DEFAULT_FULLSCREEN_WIDTH;
	m_disp_mode_fs.Height = DEFAULT_FULLSCREEN_HEIGHT;
	m_disp_mode_fs.Format = D3DFMT_UNKNOWN;
	m_disp_mode_fs.RefreshRate = 60;
	// better yet - in case there is no config INI file saved yet, use the current display mode (if detectable) as the default fullscreen res:
	DEVMODE dm;
	dm.dmSize = sizeof(dm);
	dm.dmDriverExtra = 0;
	if (EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &dm))
	{
		m_disp_mode_fs.Width  = dm.dmPelsWidth;
		m_disp_mode_fs.Height = dm.dmPelsHeight;
		m_disp_mode_fs.RefreshRate = dm.dmDisplayFrequency;
		m_disp_mode_fs.Format = (dm.dmBitsPerPel==16) ? D3DFMT_R5G6B5 : D3DFMT_X8R8G8B8;
	}

	// PROTECTED STRUCTURES/POINTERS
	int i = 0;
	for (int i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
		m_d3dx_font[i] = NULL;
	m_d3dx_desktop_font = NULL;
	m_lpDDSText = NULL;
	ZeroMemory(&m_sound, sizeof(td_soundinfo));
	for (int ch=0; ch<2; ch++)
		for (i=0; i<3; i++)
		{
			m_sound.infinite_avg[ch][i] = m_sound.avg[ch][i] = m_sound.med_avg[ch][i] = m_sound.long_avg[ch][i] = 1.0f;
		}

	// GENERAL PRIVATE STUFF
	//m_screenmode: set at end (derived setting)
	m_frame = 0;
	m_time = 0;
	m_fps = 30;
	m_hWndWinamp = hWinampWnd;
	m_hInstance = hWinampInstance;
	m_lpDX = NULL;
	m_szPluginsDirPath[0] = 0;  // will be set further down
	m_szConfigIniFile[0] = 0;  // will be set further down
	// m_szPluginsDirPath:

	wchar_t *p;

	if (hWinampWnd
	    && (p = (wchar_t *)SendMessage(hWinampWnd, WM_WA_IPC, 0, IPC_GETPLUGINDIRECTORYW))
	    && p != (wchar_t *)1)
	{
		swprintf(m_szPluginsDirPath, L"%s\\", p);
	}
	else
	{
		// get path to INI file & read in prefs/settings right away, so DumpMsg works!
		GetModuleFileNameW(m_hInstance, m_szPluginsDirPath, MAX_PATH);
		wchar_t *p = m_szPluginsDirPath + wcslen(m_szPluginsDirPath);
		while (p >= m_szPluginsDirPath && *p != L'\\') p--;
		if (++p >= m_szPluginsDirPath) *p = 0;
	}

	if (hWinampWnd
	    && (p = (wchar_t *)SendMessage(hWinampWnd, WM_WA_IPC, 0, IPC_GETINIDIRECTORYW))
	    && p != (wchar_t *)1)
	{
		// load settings as well as coping with moving old settings to a contained folder
		wchar_t m_szOldConfigIniFile[MAX_PATH] = {0}, temp[MAX_PATH] = {0}, temp2[MAX_PATH] = {0};
		swprintf(m_szOldConfigIniFile, L"%s\\Plugins\\%s", p, INIFILE);
		swprintf(m_szConfigIniFile, L"%s\\Plugins\\%s%s", p, SUBDIR, INIFILE);
		swprintf(temp, L"%s\\Plugins\\%s", p, SUBDIR);
		swprintf(temp2, L"%s\\Plugins\\", p);
		CreateDirectoryW(temp, NULL);

		if (PathFileExistsW(m_szOldConfigIniFile) && !PathFileExistsW(m_szConfigIniFile))
		{
			MoveFileW(m_szOldConfigIniFile, m_szConfigIniFile);

			wchar_t m_szMsgIniFile[MAX_PATH] = {0}, m_szNewMsgIniFile[MAX_PATH] = {0},
					m_szImgIniFile[MAX_PATH] = {0}, m_szNewImgIniFile[MAX_PATH] = {0},
					m_szAdaptersFile[MAX_PATH] = {0}, m_szNewAdaptersFile[MAX_PATH] = {0};
   			swprintf(m_szMsgIniFile, L"%s%s", temp2, MSG_INIFILE);
			swprintf(m_szNewMsgIniFile, L"%s%s", temp, MSG_INIFILE);
			swprintf(m_szImgIniFile, L"%s%s", temp2, IMG_INIFILE);
			swprintf(m_szNewImgIniFile, L"%s%s", temp, IMG_INIFILE);
			swprintf(m_szAdaptersFile, L"%s%s", temp2, ADAPTERSFILE);
			swprintf(m_szNewAdaptersFile, L"%s%s", temp, ADAPTERSFILE);

			MoveFileW(m_szImgIniFile, m_szNewImgIniFile);
			MoveFileW(m_szMsgIniFile, m_szNewMsgIniFile);
			MoveFileW(m_szAdaptersFile, m_szNewAdaptersFile);
		}
	}
	else
	{
		swprintf(m_szConfigIniFile, L"%s%s", m_szPluginsDirPath, INIFILE);
	}
	lstrcpyn(m_szConfigIniFileA,AutoCharFn(m_szConfigIniFile),MAX_PATH);

	// PRIVATE CONFIG PANEL SETTINGS
	m_multisample_fullscreen = D3DMULTISAMPLE_NONE;
	m_multisample_desktop = D3DMULTISAMPLE_NONE;
	m_multisample_windowed = D3DMULTISAMPLE_NONE;
	ZeroMemory(&m_adapter_guid_fullscreen, sizeof(GUID));
	ZeroMemory(&m_adapter_guid_desktop , sizeof(GUID));
	ZeroMemory(&m_adapter_guid_windowed , sizeof(GUID));
	m_adapter_devicename_windowed[0]   = 0;
	m_adapter_devicename_fullscreen[0] = 0;
	m_adapter_devicename_desktop[0]    = 0;


	// PRIVATE RUNTIME SETTINGS
	m_lost_focus = 0;
	m_hidden     = 0;
	m_resizing   = 0;
	m_show_help  = 0;
	m_show_playlist = 0;
	m_playlist_pos = 0;
	m_playlist_pageups = 0;
	m_playlist_top_idx = -1;
	m_playlist_btm_idx = -1;
	// m_playlist_width_pixels will be considered invalid whenever 'm_playlist_top_idx' is -1.
	// m_playlist[256][256] will be considered invalid whenever 'm_playlist_top_idx' is -1.
	m_exiting    = 0;
	m_upper_left_corner_y = 0;
	m_lower_left_corner_y = 0;
	m_upper_right_corner_y = 0;
	m_lower_right_corner_y = 0;
	m_left_edge = 0;
	m_right_edge = 0;
	m_force_accept_WM_WINDOWPOSCHANGING = 0;

	// PRIVATE - GDI STUFF
	m_main_menu     = NULL;
	m_context_menu  = NULL;
	for (i=0; i<NUM_BASIC_FONTS + NUM_EXTRA_FONTS; i++)
		m_font[i] = NULL;
	m_font_desktop = NULL;

	// PRIVATE - DESKTOP MODE STUFF
	m_icon_list.clear();
	for (i=0; i<MAX_ICON_TEXTURES; i++)
		m_desktop_icons_texture[i] = NULL;
	FindDesktopWindows(&m_hWndProgMan, &m_hWndDesktop, &m_hWndDesktopListView);
	GetDesktopFolder(m_szDesktopFolder);
	m_desktop_icon_size       = 32;
	m_desktop_dragging        = 0;   // '1' when user is dragging icons around
	m_desktop_box             = 0;   // '1' when user is drawing a box
	m_desktop_wc_registered   = 0;
	m_desktop_bk_color        = 0xFF000000 | BGR2RGB(::GetSysColor(COLOR_BACKGROUND));
	m_desktop_text_color      = 0xFF000000 | BGR2RGB(SendMessage(m_hWndDesktopListView, LVM_GETTEXTCOLOR, 0, 0));
	m_desktop_sel_color       = 0xFF000000 | BGR2RGB(::GetSysColor(COLOR_HIGHLIGHT));
	m_desktop_sel_text_color  = 0xFF000000 | BGR2RGB(::GetSysColor(COLOR_HIGHLIGHTTEXT));
	m_desktop_icon_state      = 0;
	m_desktop_icon_count      = 0;
	m_desktop_icon_update_frame = 0;
	m_desktop_icons_disabled  = 0;
	m_vms_desktop_loaded      = 0;
	m_desktop_hook_set        = 0;

	// PRIVATE - MORE TIMEKEEPING
	m_last_raw_time = 0;
	memset(m_time_hist, 0, sizeof(m_time_hist));
	m_time_hist_pos = 0;
	if (!QueryPerformanceFrequency(&m_high_perf_timer_freq))
		m_high_perf_timer_freq.QuadPart = 0;
	m_prev_end_of_frame.QuadPart = 0;

	// PRIVATE AUDIO PROCESSING DATA
	//(m_fftobj needs no init)
	memset(m_oldwave[0], 0, sizeof(float)*576);
	memset(m_oldwave[1], 0, sizeof(float)*576);
	m_prev_align_offset[0] = 0;
	m_prev_align_offset[1] = 0;
	m_align_weights_ready = 0;

	// SEPARATE TEXT WINDOW (FOR VJ MODE)
	m_vj_mode       = 0;
	m_hidden_textwnd = 0;
	m_resizing_textwnd = 0;
	m_hTextWnd		= NULL;
	m_nTextWndWidth = 0;
	m_nTextWndHeight = 0;
	m_bTextWindowClassRegistered = false;
	m_vjd3d9        = NULL;
	m_vjd3d9_device = NULL;

	//-----

	m_screenmode = NOT_YET_KNOWN;

	OverrideDefaults();
	ReadConfig();

	if (m_start_fullscreen)
	{
		m_screenmode = m_fake_fullscreen_mode ? FAKE_FULLSCREEN : FULLSCREEN;
		if (m_screenmode == FULLSCREEN && SendMessage(GetWinampWindow(), WM_WA_IPC, 0, IPC_IS_PLAYING_VIDEO) > 1)
		{
			m_screenmode = FAKE_FULLSCREEN;
		}
	}
	else if (m_start_desktop)
		m_screenmode = DESKTOP;
	else
		m_screenmode = WINDOWED;

	MyPreInitialize();
	MyReadConfig();

	//-----

	return TRUE;
}

int CPluginShell::PluginInitialize()
{
	// note: initialize GDI before DirectX.  Also separate them because
	// when we change windowed<->fullscreen, or lose the device and restore it,
	// we don't want to mess with any (persistent) GDI stuff.

	if (!InitDirectX())        return FALSE;  // gives its own error messages
	if (!InitNondx9Stuff())    return FALSE;  // gives its own error messages
	if (!AllocateDX9Stuff())   return FALSE;  // gives its own error messages
	if (!InitVJStuff())        return FALSE;

	return TRUE;
}

void CPluginShell::PluginQuit()
{
	CleanUpVJStuff();
	CleanUpDX9Stuff(1);
	CleanUpNondx9Stuff();
	CleanUpDirectX();

	SetFocus(m_hWndWinamp);
	SetActiveWindow(m_hWndWinamp);
	SetForegroundWindow(m_hWndWinamp);
}

wchar_t* BuildSettingName(wchar_t* name, int number){
static wchar_t temp[64];
	swprintf(temp, L"%s%d", name, number);
	return temp;
}

void CPluginShell::READ_FONT(int n){
	GetPrivateProfileStringW(L"settings",BuildSettingName(L"szFontFace",n),m_fontinfo[n].szFace,m_fontinfo[n].szFace,sizeof(m_fontinfo[n].szFace), m_szConfigIniFile);
	m_fontinfo[n].nSize   = GetPrivateProfileIntW(L"settings",BuildSettingName(L"nFontSize",n),m_fontinfo[n].nSize  ,m_szConfigIniFile);
	m_fontinfo[n].bBold   = GetPrivateProfileIntW(L"settings",BuildSettingName(L"bFontBold",n),m_fontinfo[n].bBold  ,m_szConfigIniFile);
	m_fontinfo[n].bItalic = GetPrivateProfileIntW(L"settings",BuildSettingName(L"bFontItalic",n),m_fontinfo[n].bItalic,m_szConfigIniFile);
	m_fontinfo[n].bAntiAliased = GetPrivateProfileIntW(L"settings",BuildSettingName(L"bFontAA",n),m_fontinfo[n].bItalic,m_szConfigIniFile);
}

void CPluginShell::ReadConfig()
{
	int old_ver    = GetPrivateProfileIntW(L"settings",L"version"   ,-1,m_szConfigIniFile);
	int old_subver = GetPrivateProfileIntW(L"settings",L"subversion",-1,m_szConfigIniFile);

	// nuke old settings from prev. version:
	if (old_ver < INT_VERSION)
		return;
	else if (old_subver < INT_SUBVERSION)
		return;

	//D3DMULTISAMPLE_TYPE m_multisample_fullscreen;
	//D3DMULTISAMPLE_TYPE m_multisample_desktop;
	//D3DMULTISAMPLE_TYPE m_multisample_windowed;
	m_multisample_fullscreen      = (D3DMULTISAMPLE_TYPE)GetPrivateProfileIntW(L"settings",L"multisample_fullscreen",m_multisample_fullscreen,m_szConfigIniFile);
	m_multisample_desktop         = (D3DMULTISAMPLE_TYPE)GetPrivateProfileIntW(L"settings",L"multisample_desktop",m_multisample_desktop,m_szConfigIniFile);
	m_multisample_windowed        = (D3DMULTISAMPLE_TYPE)GetPrivateProfileIntW(L"settings",L"multisample_windowed"  ,m_multisample_windowed  ,m_szConfigIniFile);

	//GUID m_adapter_guid_fullscreen
	//GUID m_adapter_guid_desktop
	//GUID m_adapter_guid_windowed
	char str[256];
	GetPrivateProfileString("settings","adapter_guid_fullscreen","",str,sizeof(str)-1,m_szConfigIniFileA);
	TextToGuid(str, &m_adapter_guid_fullscreen);
	GetPrivateProfileString("settings","adapter_guid_desktop","",str,sizeof(str)-1,m_szConfigIniFileA);
	TextToGuid(str, &m_adapter_guid_desktop);
	GetPrivateProfileString("settings","adapter_guid_windowed","",str,sizeof(str)-1,m_szConfigIniFileA);
	TextToGuid(str, &m_adapter_guid_windowed);
	GetPrivateProfileString("settings","adapter_devicename_fullscreen","",m_adapter_devicename_fullscreen,sizeof(m_adapter_devicename_fullscreen)-1,m_szConfigIniFileA);
	GetPrivateProfileString("settings","adapter_devicename_desktop",   "",m_adapter_devicename_desktop   ,sizeof(m_adapter_devicename_desktop)-1,m_szConfigIniFileA);
	GetPrivateProfileString("settings","adapter_devicename_windowed",  "",m_adapter_devicename_windowed  ,sizeof(m_adapter_devicename_windowed)-1,m_szConfigIniFileA);

	// FONTS
	READ_FONT(0);
	READ_FONT(1);
	READ_FONT(2);
	READ_FONT(3);
#if (NUM_EXTRA_FONTS >= 1)
	READ_FONT(4);
#endif
#if (NUM_EXTRA_FONTS >= 2)
	READ_FONT(5);
#endif
#if (NUM_EXTRA_FONTS >= 3)
	READ_FONT(6);
#endif
#if (NUM_EXTRA_FONTS >= 4)
	READ_FONT(7);
#endif
#if (NUM_EXTRA_FONTS >= 5)
	READ_FONT(8);
#endif

	m_start_fullscreen     = GetPrivateProfileIntW(L"settings",L"start_fullscreen",m_start_fullscreen,m_szConfigIniFile);
	m_start_desktop        = GetPrivateProfileIntW(L"settings",L"start_desktop"   ,m_start_desktop   ,m_szConfigIniFile);
	m_fake_fullscreen_mode = GetPrivateProfileIntW(L"settings",L"fake_fullscreen_mode",m_fake_fullscreen_mode,m_szConfigIniFile);
	m_max_fps_fs           = GetPrivateProfileIntW(L"settings",L"max_fps_fs",m_max_fps_fs,m_szConfigIniFile);
	m_max_fps_dm           = GetPrivateProfileIntW(L"settings",L"max_fps_dm",m_max_fps_dm,m_szConfigIniFile);
	m_max_fps_w            = GetPrivateProfileIntW(L"settings",L"max_fps_w" ,m_max_fps_w ,m_szConfigIniFile);
	m_show_press_f1_msg    = GetPrivateProfileIntW(L"settings",L"show_press_f1_msg",m_show_press_f1_msg,m_szConfigIniFile);
	m_allow_page_tearing_w = GetPrivateProfileIntW(L"settings",L"allow_page_tearing_w",m_allow_page_tearing_w,m_szConfigIniFile);
	m_allow_page_tearing_fs= GetPrivateProfileIntW(L"settings",L"allow_page_tearing_fs",m_allow_page_tearing_fs,m_szConfigIniFile);
	m_allow_page_tearing_dm= GetPrivateProfileIntW(L"settings",L"allow_page_tearing_dm",m_allow_page_tearing_dm,m_szConfigIniFile);
	m_minimize_winamp      = GetPrivateProfileIntW(L"settings",L"minimize_winamp",m_minimize_winamp,m_szConfigIniFile);
	m_desktop_show_icons   = GetPrivateProfileIntW(L"settings",L"desktop_show_icons",m_desktop_show_icons,m_szConfigIniFile);
	m_desktop_textlabel_boxes = GetPrivateProfileIntW(L"settings",L"desktop_textlabel_boxes",m_desktop_textlabel_boxes,m_szConfigIniFile);
	m_desktop_manual_icon_scoot = GetPrivateProfileIntW(L"settings",L"desktop_manual_icon_scoot",m_desktop_manual_icon_scoot,m_szConfigIniFile);
	m_desktop_555_fix      = GetPrivateProfileIntW(L"settings",L"desktop_555_fix",m_desktop_555_fix,m_szConfigIniFile);
	m_dualhead_horz        = GetPrivateProfileIntW(L"settings",L"dualhead_horz",m_dualhead_horz,m_szConfigIniFile);
	m_dualhead_vert        = GetPrivateProfileIntW(L"settings",L"dualhead_vert",m_dualhead_vert,m_szConfigIniFile);
	m_save_cpu             = GetPrivateProfileIntW(L"settings",L"save_cpu",m_save_cpu,m_szConfigIniFile);
	m_skin                 = GetPrivateProfileIntW(L"settings",L"skin",m_skin,m_szConfigIniFile);
	m_fix_slow_text        = GetPrivateProfileIntW(L"settings",L"fix_slow_text",m_fix_slow_text,m_szConfigIniFile);
	m_vj_mode              = GetPrivateProfileBoolW(L"settings",L"vj_mode",m_vj_mode,m_szConfigIniFile);

	//D3DDISPLAYMODE m_fs_disp_mode
	m_disp_mode_fs.Width           = GetPrivateProfileIntW(L"settings",L"disp_mode_fs_w", m_disp_mode_fs.Width           ,m_szConfigIniFile);
	m_disp_mode_fs.Height           = GetPrivateProfileIntW(L"settings",L"disp_mode_fs_h",m_disp_mode_fs.Height          ,m_szConfigIniFile);
	m_disp_mode_fs.RefreshRate = GetPrivateProfileIntW(L"settings",L"disp_mode_fs_r",m_disp_mode_fs.RefreshRate,m_szConfigIniFile);
	m_disp_mode_fs.Format      = (D3DFORMAT)GetPrivateProfileIntW(L"settings",L"disp_mode_fs_f",m_disp_mode_fs.Format     ,m_szConfigIniFile);

	// note: we don't call MyReadConfig() yet, because we
	// want to completely finish CPluginShell's preinit (and ReadConfig)
	// before calling CPlugin's preinit and ReadConfig.
}

void CPluginShell::WRITE_FONT(int n){
	WritePrivateProfileStringW(L"settings",BuildSettingName(L"szFontFace",n),m_fontinfo[n].szFace,m_szConfigIniFile);
	WritePrivateProfileIntW(m_fontinfo[n].bBold,  BuildSettingName(L"bFontBold",n),   m_szConfigIniFile, L"settings");
	WritePrivateProfileIntW(m_fontinfo[n].bItalic,BuildSettingName(L"bFontItalic",n), m_szConfigIniFile, L"settings");
	WritePrivateProfileIntW(m_fontinfo[n].nSize,  BuildSettingName(L"nFontSize",n),   m_szConfigIniFile, L"settings");
	WritePrivateProfileIntW(m_fontinfo[n].bAntiAliased, BuildSettingName(L"bFontAA",n),m_szConfigIniFile, L"settings");
}

void CPluginShell::WriteConfig()
{
	//D3DMULTISAMPLE_TYPE m_multisample_fullscreen;
	//D3DMULTISAMPLE_TYPE m_multisample_desktop;
	//D3DMULTISAMPLE_TYPE m_multisample_windowed;
	WritePrivateProfileIntW((int)m_multisample_fullscreen,L"multisample_fullscreen",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW((int)m_multisample_desktop   ,L"multisample_desktop"   ,m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW((int)m_multisample_windowed  ,L"multisample_windowed"  ,m_szConfigIniFile,L"settings");

	//GUID m_adapter_guid_fullscreen
	//GUID m_adapter_guid_desktop
	//GUID m_adapter_guid_windowed
	char str[256];
	GuidToText(&m_adapter_guid_fullscreen, str, sizeof(str));
	WritePrivateProfileString("settings","adapter_guid_fullscreen",str,m_szConfigIniFileA);
	GuidToText(&m_adapter_guid_desktop, str, sizeof(str));
	WritePrivateProfileString("settings","adapter_guid_desktop",str,m_szConfigIniFileA);
	GuidToText(&m_adapter_guid_windowed,   str, sizeof(str));
	WritePrivateProfileString("settings","adapter_guid_windowed"  ,str,m_szConfigIniFileA);
	WritePrivateProfileString("settings","adapter_devicename_fullscreen",m_adapter_devicename_fullscreen,m_szConfigIniFileA);
	WritePrivateProfileString("settings","adapter_devicename_desktop"   ,m_adapter_devicename_desktop   ,m_szConfigIniFileA);
	WritePrivateProfileString("settings","adapter_devicename_windowed"  ,m_adapter_devicename_windowed  ,m_szConfigIniFileA);

	// FONTS
	WRITE_FONT(0);
	WRITE_FONT(1);
	WRITE_FONT(2);
	WRITE_FONT(3);
#if (NUM_EXTRA_FONTS >= 1)
	WRITE_FONT(4);
#endif
#if (NUM_EXTRA_FONTS >= 2)
	WRITE_FONT(5);
#endif
#if (NUM_EXTRA_FONTS >= 3)
	WRITE_FONT(6);
#endif
#if (NUM_EXTRA_FONTS >= 4)
	WRITE_FONT(7);
#endif
#if (NUM_EXTRA_FONTS >= 5)
	WRITE_FONT(8);
#endif

	WritePrivateProfileIntW(m_start_fullscreen,L"start_fullscreen",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_start_desktop   ,L"start_desktop"   ,m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_fake_fullscreen_mode,L"fake_fullscreen_mode",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_max_fps_fs,L"max_fps_fs",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_max_fps_dm,L"max_fps_dm",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_max_fps_w ,L"max_fps_w" ,m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_show_press_f1_msg,L"show_press_f1_msg",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_allow_page_tearing_w,L"allow_page_tearing_w",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_allow_page_tearing_fs,L"allow_page_tearing_fs",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_allow_page_tearing_dm,L"allow_page_tearing_dm",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_minimize_winamp,L"minimize_winamp",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_desktop_show_icons,L"desktop_show_icons",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_desktop_textlabel_boxes,L"desktop_textlabel_boxes",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_desktop_manual_icon_scoot,L"desktop_manual_icon_scoot",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_desktop_555_fix,L"desktop_555_fix",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_dualhead_horz,L"dualhead_horz",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_dualhead_vert,L"dualhead_vert",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_save_cpu,L"save_cpu",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_skin,L"skin",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_fix_slow_text,L"fix_slow_text",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_vj_mode,L"vj_mode",m_szConfigIniFile,L"settings");

	//D3DDISPLAYMODE m_fs_disp_mode
	WritePrivateProfileIntW(m_disp_mode_fs.Width          ,L"disp_mode_fs_w",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_disp_mode_fs.Height          ,L"disp_mode_fs_h",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_disp_mode_fs.RefreshRate,L"disp_mode_fs_r",m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(m_disp_mode_fs.Format     ,L"disp_mode_fs_f",m_szConfigIniFile,L"settings");

	WritePrivateProfileIntW(INT_VERSION            ,L"version"    ,m_szConfigIniFile,L"settings");
	WritePrivateProfileIntW(INT_SUBVERSION         ,L"subversion" ,m_szConfigIniFile,L"settings");

	// finally, save the plugin's unique settings:
	MyWriteConfig();
}

//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

int CPluginShell::PluginRender(unsigned char *pWaveL, unsigned char *pWaveR)//, unsigned char *pSpecL, unsigned char *pSpecR)
{
	// return FALSE here to tell Winamp to terminate the plugin

	if (!m_lpDX || !m_lpDX->m_ready)
	{
		// note: 'm_ready' will go false when a device reset fatally fails
		//       (for example, when user resizes window, or toggles fullscreen.)
		m_exiting = 1;
		return false;   // EXIT THE PLUGIN
	}

	if (m_hTextWnd)
		m_lost_focus = ((GetFocus() != GetPluginWindow()) && (GetFocus() != m_hTextWnd));
	else
		m_lost_focus = (GetFocus() != GetPluginWindow());

	if ((m_screenmode==WINDOWED   && m_hidden) ||
	    (m_screenmode==FULLSCREEN && m_lost_focus) ||
	    (m_screenmode==WINDOWED   && m_resizing)
	   )
	{
		Sleep(30);
		return true;
	}

	// test for lost device
	// (this happens when device is fullscreen & user alt-tabs away,
	//  or when monitor power-saving kicks in)
	HRESULT hr = m_lpDX->m_lpDevice->TestCooperativeLevel();
	if (hr == D3DERR_DEVICENOTRESET)
	{
		// device WAS lost, and is now ready to be reset (and come back online):
		CleanUpDX9Stuff(0);
		if (m_lpDX->m_lpDevice->Reset(&m_lpDX->m_d3dpp) != D3D_OK)
		{
			// note: a basic warning messagebox will have already been given.
			// now suggest specific advice on how to regain more video memory:
			if (m_lpDX->m_lastErr == DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY)
				SuggestHowToFreeSomeMem();
			return false;  // EXIT THE PLUGIN
		}
		if (!AllocateDX9Stuff())
			return false;  // EXIT THE PLUGIN
	}
	else if (hr != D3D_OK)
	{
		// device is lost, and not yet ready to come back; sleep.
		Sleep(30);
		return true;
	}

	if (m_vjd3d9_device)
	{
		HRESULT hr = m_vjd3d9_device->TestCooperativeLevel();
		if (hr == D3DERR_DEVICENOTRESET)
		{
			RECT c;
			GetClientRect(m_hTextWnd, &c);

			POINT p;
			p.x = c.left;
			p.y = c.top;
			if (ClientToScreen(m_hTextWnd, &p))
			{
				c.left += p.x;
				c.right += p.x;
				c.top += p.y;
				c.bottom += p.y;
			}

			CleanUpVJStuff();
			if (!InitVJStuff(&c))
				return false;  // EXIT THE PLUGIN
		}
	}

	if (m_screenmode==DESKTOP)
	{
		PushWindowToJustBeforeDesktop(GetPluginWindow());
	}

	DoTime();
	AnalyzeNewSound(pWaveL, pWaveR);
	AlignWaves();

	DrawAndDisplay(0);

	EnforceMaxFPS();

	m_frame++;

	return true;
}

void CPluginShell::PushWindowToJustBeforeDesktop(HWND h)
{
	// if our window isn't already at the bottom of the Z order,
	// freshly send it to HWND_BOTTOM.

	// this usually gives us the Program Manager window:
	HWND hWndBottom = GetWindow(h, GW_HWNDLAST);

	// then, bottommost 'normal' window is usually the one just in front of it:
	if (hWndBottom == m_hWndProgMan)
		hWndBottom = GetWindow(hWndBottom, GW_HWNDPREV);

	if (hWndBottom != h)
	{
		m_force_accept_WM_WINDOWPOSCHANGING = 1;
		SetWindowPos(h, HWND_BOTTOM, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
		m_force_accept_WM_WINDOWPOSCHANGING = 0;
	}

	/*
	HWND hDesktopBkgWnd = FindWindow("SHELLDLL_DefView", "");
	if (hDesktopBkgWnd)
	{
	    HWND hWndInFrontOfIcons = GetWindow(h, GW_HWNDPREV);
	    if (hWndInFrontOfIcons != h)
	    {
	        m_force_accept_WM_WINDOWPOSCHANGING = 1;
	        SetWindowPos(hDesktopBkgWnd, h, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
	        m_force_accept_WM_WINDOWPOSCHANGING = 0;
	    }
	}
	*/


}

void CPluginShell::DrawAndDisplay(int redraw)
{
	int cx = m_vjd3d9_device ? m_nTextWndWidth  : m_lpDX->m_client_width;
	int cy = m_vjd3d9_device ? m_nTextWndHeight : m_lpDX->m_client_height;
	if (m_lpDDSText)
	{
		D3DSURFACE_DESC desc;
		if (D3D_OK == m_lpDDSText->GetLevelDesc(0, &desc))
		{
			cx = min(cx, (int)desc.Width);
			cy = min(cy, (int)desc.Height);
		}
	}
	m_upper_left_corner_y  = TEXT_MARGIN + GetCanvasMarginY();
	m_upper_right_corner_y = TEXT_MARGIN + GetCanvasMarginY();
	m_lower_left_corner_y  = cy - TEXT_MARGIN - GetCanvasMarginY();
	m_lower_right_corner_y = cy - TEXT_MARGIN - GetCanvasMarginY();
	m_left_edge            = TEXT_MARGIN + GetCanvasMarginX();
	m_right_edge           = cx - TEXT_MARGIN - GetCanvasMarginX();

	/*if (m_screenmode == DESKTOP || m_screenmode == FAKE_FULLSCREEN)
	{
	    // check if taskbar is above plugin window;
	    // if so, scoot text & icons out of the way.
	    //     [...should always be true for Desktop Mode,
	    //         but it's like this for code simplicity.]
	    int taskbar_is_above_plugin_window = 1;
	    HWND h = FindWindow("Shell_TrayWnd", NULL);
	    while (h) //(..shouldn't be very many windows to iterate through here)
	    {
	        h = GetWindow(h, GW_HWNDPREV);
	        if (h == GetPluginWindow())
	        {
	            taskbar_is_above_plugin_window = 0;
	            break;
	        }
	    }

	    if (taskbar_is_above_plugin_window)
	    {
	        // respect the taskbar area; make sure the text, desktop icons, etc.
	        // don't appear underneath it.
	        //m_upper_left_corner_y  += m_lpDX->m_monitor_work_rect.top - m_lpDX->m_monitor_rect.top;
	        //m_upper_right_corner_y += m_lpDX->m_monitor_work_rect.top - m_lpDX->m_monitor_rect.top;
	        //m_lower_left_corner_y  -= m_lpDX->m_monitor_rect.bottom - m_lpDX->m_monitor_work_rect.bottom;
	        //m_lower_right_corner_y -= m_lpDX->m_monitor_rect.bottom - m_lpDX->m_monitor_work_rect.bottom;
	        //m_left_edge  += m_lpDX->m_monitor_work_rect.left - m_lpDX->m_monitor_rect.left;
	        //m_right_edge -= m_lpDX->m_monitor_rect.right - m_lpDX->m_monitor_work_rect.right;
	        m_lpDX->UpdateMonitorWorkRect();
	        m_upper_left_corner_y  = max(m_upper_left_corner_y , m_lpDX->m_monitor_work_rect.top - m_lpDX->m_monitor_rect.top + TEXT_MARGIN + GetCanvasMarginY());
	        m_upper_right_corner_y = max(m_upper_right_corner_y, m_lpDX->m_monitor_work_rect.top - m_lpDX->m_monitor_rect.top + TEXT_MARGIN + GetCanvasMarginY());
	        m_lower_left_corner_y  = min(m_lower_left_corner_y , m_lpDX->m_client_height - (m_lpDX->m_monitor_rect.bottom - m_lpDX->m_monitor_work_rect.bottom) - TEXT_MARGIN - GetCanvasMarginY());
	        m_lower_right_corner_y = min(m_lower_right_corner_y, m_lpDX->m_client_height - (m_lpDX->m_monitor_rect.bottom - m_lpDX->m_monitor_work_rect.bottom) - TEXT_MARGIN - GetCanvasMarginY());
	        m_left_edge  = max(m_left_edge , m_lpDX->m_monitor_work_rect.left - m_lpDX->m_monitor_rect.left + TEXT_MARGIN + GetCanvasMarginX() );
	        m_right_edge = min(m_right_edge, m_lpDX->m_client_width - (m_lpDX->m_monitor_rect.right - m_lpDX->m_monitor_work_rect.right) - TEXT_MARGIN + GetCanvasMarginX());
	    }
	}*/

	if (D3D_OK==m_lpDX->m_lpDevice->BeginScene())
	{
		MyRenderFn(redraw);

		PrepareFor2DDrawing_B(GetDevice(), GetWidth(), GetHeight());

		RenderDesktop();
		if (!m_vjd3d9_device)   // in VJ mode, this renders to different context, so do it after BeginScene() on 2nd device.
			RenderBuiltInTextMsgs();    // to m_lpDDSText?
		MyRenderUI(&m_upper_left_corner_y, &m_upper_right_corner_y, &m_lower_left_corner_y, &m_lower_right_corner_y, m_left_edge, m_right_edge);
		RenderPlaylist();

		if (!m_vjd3d9_device)
			m_text.DrawNow();

		m_lpDX->m_lpDevice->EndScene();
	}

	// VJ Mode:
	if (m_vj_mode && m_vjd3d9_device && !m_hidden_textwnd && D3D_OK==m_vjd3d9_device->BeginScene())
	{
		if (!m_lpDDSText || m_bClearVJWindow)
			m_vjd3d9_device->Clear(0, 0, D3DCLEAR_TARGET, 0xFF000000, 1.0f, 0);
		m_bClearVJWindow = false;
		// note: when using debug DX runtime, textwnd will flash red/green after frame 4, if no text is drawn on a frame!

		RenderBuiltInTextMsgs();

		PrepareFor2DDrawing_B(m_vjd3d9_device, m_nTextWndWidth, m_nTextWndHeight);

		m_text.DrawNow();

		m_vjd3d9_device->EndScene();
	}

	if (m_screenmode == DESKTOP)
	{
		// window is hidden after creation, until 1st frame is ready to go;
		// now that it's ready, we show it.
		// see dxcontext::Internal_Init()'s call to SetWindowPos() for the DESKTOP case.
		if (!IsWindowVisible(GetPluginWindow()))
			ShowWindow(GetPluginWindow(), SW_SHOWNORMAL);
	}

	if (m_screenmode == WINDOWED && (m_lpDX->m_client_width != m_lpDX->m_REAL_client_width || m_lpDX->m_client_height != m_lpDX->m_REAL_client_height))
	{
		int real_w = m_lpDX->m_REAL_client_width;   // real client size, in pixels
		int real_h = m_lpDX->m_REAL_client_height;
		int fat_w = m_lpDX->m_client_width;         // oversized VS canvas size, in pixels
		int fat_h = m_lpDX->m_client_height;
		int extra_w = fat_w - real_w;
		int extra_h = fat_h - real_h;
		RECT src, dst;
		SetRect(&src, extra_w/2, extra_h/2, extra_w/2 + real_w, extra_h/2 + real_h);
		SetRect(&dst, 0, 0, real_w, real_h);
		m_lpDX->m_lpDevice->Present(&src, &dst,NULL,NULL);
	}
	else
		m_lpDX->m_lpDevice->Present(NULL,NULL,NULL,NULL);

	if (m_vjd3d9_device && !m_hidden_textwnd)
		m_vjd3d9_device->Present(NULL,NULL,NULL,NULL);
}

void CPluginShell::EnforceMaxFPS()
{
	int max_fps;
	switch (m_screenmode)
	{
	case WINDOWED:        max_fps = m_max_fps_w;  break;
	case FULLSCREEN:      max_fps = m_max_fps_fs; break;
	case FAKE_FULLSCREEN: max_fps = m_max_fps_fs; break;
	case DESKTOP:         max_fps = m_max_fps_dm; break;
	}

	if (max_fps <= 0)
		return;

	float fps_lo = (float)max_fps;
	float fps_hi = (float)max_fps;

	if (m_save_cpu)
	{
		// Find the optimal lo/hi bounds for the fps
		// that will result in a maximum difference,
		// in the time for a single frame, of 0.003 seconds -
		// the assumed granularity for Sleep(1) -

		// Using this range of acceptable fps
		// will allow us to do (sloppy) fps limiting
		// using only Sleep(1), and never the
		// second half of it: Sleep(0) in a tight loop,
		// which sucks up the CPU (whereas Sleep(1)
		// leaves it idle).

		// The original equation:
		//   1/(max_fps*t1) = 1/(max*fps/t1) - 0.003
		// where:
		//   t1 > 0
		//   max_fps*t1 is the upper range for fps
		//   max_fps/t1 is the lower range for fps

		float a = 1;
		float b = -0.003f * max_fps;
		float c = -1.0f;
		float det = b*b - 4*a*c;
		if (det>0)
		{
			float t1 = (-b + sqrtf(det)) / (2*a);
			//float t2 = (-b - sqrtf(det)) / (2*a);

			if (t1 > 1.0f)
			{
				fps_lo = max_fps / t1;
				fps_hi = max_fps * t1;
				// verify: now [1.0f/fps_lo - 1.0f/fps_hi] should equal 0.003 seconds.
				// note: allowing tolerance to go beyond these values for
				// fps_lo and fps_hi would gain nothing.
			}
		}
	}

	if (m_high_perf_timer_freq.QuadPart > 0)
	{
		LARGE_INTEGER t;
		QueryPerformanceCounter(&t);

		if (m_prev_end_of_frame.QuadPart != 0)
		{
			int ticks_to_wait_lo = (int)((float)m_high_perf_timer_freq.QuadPart / (float)fps_hi);
			int ticks_to_wait_hi = (int)((float)m_high_perf_timer_freq.QuadPart / (float)fps_lo);
			int done = 0;
			int loops = 0;
			do
			{
				QueryPerformanceCounter(&t);

				__int64 t2 = t.QuadPart - m_prev_end_of_frame.QuadPart;
				if (t2 > 2147483000)
					done = 1;
				if (t.QuadPart < m_prev_end_of_frame.QuadPart)    // time wrap
					done = 1;

				// this is sloppy - if your freq. is high, this can overflow (to a (-) int) in just a few minutes
				// but it's ok, we have protection for that above.
				int ticks_passed = (int)(t.QuadPart - m_prev_end_of_frame.QuadPart);
				if (ticks_passed >= ticks_to_wait_lo)
					done = 1;

				if (!done)
				{
					// if > 0.01s left, do Sleep(1), which will actually sleep some
					//   steady amount of up to 3 ms (depending on the OS),
					//   and do so in a nice way (cpu meter drops; laptop battery spared).
					// otherwise, do a few Sleep(0)'s, which just give up the timeslice,
					//   but don't really save cpu or battery, but do pass a tiny
					//   amount of time.

					//if (ticks_left > (int)m_high_perf_timer_freq.QuadPart/500)
					if (ticks_to_wait_hi - ticks_passed > (int)m_high_perf_timer_freq.QuadPart/100)
						Sleep(5);
					else if (ticks_to_wait_hi - ticks_passed > (int)m_high_perf_timer_freq.QuadPart/1000)
						Sleep(1);
					else
						for (int i=0; i<10; i++)
							Sleep(0);  // causes thread to give up its timeslice
				}
			}
			while (!done);
		}

		m_prev_end_of_frame = t;
	}
	else
	{
		Sleep(1000/max_fps);
	}
}

void CPluginShell::DoTime()
{
	if (m_frame==0)
	{
		m_fps = 30;
		m_time = 0;
		m_time_hist_pos = 0;
	}

	double new_raw_time;
	float elapsed;

	if (m_high_perf_timer_freq.QuadPart != 0)
	{
		// get high-precision time
		// precision: usually from 1..6 us (MICROseconds), depending on the cpu speed.
		// (higher cpu speeds tend to have better precision here)
		LARGE_INTEGER t;
		if (!QueryPerformanceCounter(&t))
		{
			m_high_perf_timer_freq.QuadPart = 0;   // something went wrong (exception thrown) -> revert to crappy timer
		}
		else
		{
			new_raw_time = (double)t.QuadPart;
			elapsed = (float)((new_raw_time - m_last_raw_time)/(double)m_high_perf_timer_freq.QuadPart);
		}
	}

	if (m_high_perf_timer_freq.QuadPart == 0)
	{
		// get low-precision time
		// precision: usually 1 ms (MILLIsecond) for win98, and 10 ms for win2k.
		new_raw_time = (double)(timeGetTime()*0.001);
		elapsed = (float)(new_raw_time - m_last_raw_time);
	}

	m_last_raw_time = new_raw_time;
	int slots_to_look_back = (m_high_perf_timer_freq.QuadPart==0) ? TIME_HIST_SLOTS : TIME_HIST_SLOTS/2;

	m_time += 1.0f/m_fps;

	// timekeeping goals:
	//    1. keep 'm_time' increasing SMOOTHLY: (smooth animation depends on it)
	//          m_time += 1.0f/m_fps;     // where m_fps is a bit damped
	//    2. keep m_time_hist[] 100% accurate (except for filtering out pauses),
	//       so that when we look take the difference between two entries,
	//       we get the real amount of time that passed between those 2 frames.
	//          m_time_hist[i] = m_last_raw_time + elapsed_corrected;

	if (m_frame > TIME_HIST_SLOTS)
	{
		if (m_fps < 60.0f)
			slots_to_look_back = (int)(slots_to_look_back*(0.1f + 0.9f*(m_fps/60.0f)));

		if (elapsed > 5.0f/m_fps || elapsed > 1.0f || elapsed < 0)
			elapsed = 1.0f / 30.0f;

		float old_hist_time = m_time_hist[(m_time_hist_pos - slots_to_look_back + TIME_HIST_SLOTS) % TIME_HIST_SLOTS];
		float new_hist_time = m_time_hist[(m_time_hist_pos - 1 + TIME_HIST_SLOTS) % TIME_HIST_SLOTS]
		                      + elapsed;

		m_time_hist[m_time_hist_pos] = new_hist_time;
		m_time_hist_pos = (m_time_hist_pos+1) % TIME_HIST_SLOTS;

		float new_fps = slots_to_look_back / (float)(new_hist_time - old_hist_time);
		float damping = (m_high_perf_timer_freq.QuadPart==0) ? 0.93f : 0.87f;

		// damp heavily, so that crappy timer precision doesn't make animation jerky
		if (fabsf(m_fps - new_fps) > 3.0f)
			m_fps = new_fps;
		else
			m_fps = damping*m_fps + (1-damping)*new_fps;
	}
	else
	{
		float damping = (m_high_perf_timer_freq.QuadPart==0) ? 0.8f : 0.6f;

		if (m_frame < 2)
			elapsed = 1.0f / 30.0f;
		else if (elapsed > 1.0f || elapsed < 0)
			elapsed = 1.0f / m_fps;

		float old_hist_time = m_time_hist[0];
		float new_hist_time = m_time_hist[(m_time_hist_pos - 1 + TIME_HIST_SLOTS) % TIME_HIST_SLOTS]
		                      + elapsed;

		m_time_hist[m_time_hist_pos] = new_hist_time;
		m_time_hist_pos = (m_time_hist_pos+1) % TIME_HIST_SLOTS;

		if (m_frame > 0)
		{
			float new_fps = (m_frame) / (new_hist_time - old_hist_time);
			m_fps = damping*m_fps + (1-damping)*new_fps;
		}
	}

	// Synchronize the audio and video by telling Winamp how many milliseconds we want the audio data,
	// before it's actually audible.  If we set this to the amount of time it takes to display 1 frame
	// (1/fps), the video and audio should be perfectly synchronized.
	if (m_fps < 2.0f)
		mod1.latencyMs = 500;
	else if (m_fps > 125.0f)
		mod1.latencyMs = 8;
	else
		mod1.latencyMs = (int)(1000.0f/m_fps*m_lpDX->m_frame_delay + 0.5f);
}

void CPluginShell::AnalyzeNewSound(unsigned char *pWaveL, unsigned char *pWaveR)
{
	// we get 576 samples in from winamp.
	// the output of the fft has 'num_frequencies' samples,
	//   and represents the frequency range 0 hz - 22,050 hz.
	// usually, plugins only use half of this output (the range 0 hz - 11,025 hz),
	//   since >10 khz doesn't usually contribute much.

	int i;

	float temp_wave[2][576];

	int old_i = 0;
	for (i=0; i<576; i++)
	{
		m_sound.fWaveform[0][i] = (float)((pWaveL[i] ^ 128) - 128);
		m_sound.fWaveform[1][i] = (float)((pWaveR[i] ^ 128) - 128);

		// simulating single frequencies from 200 to 11,025 Hz:
		//float freq = 1.0f + 11050*(GetFrame() % 100)*0.01f;
		//m_sound.fWaveform[0][i] = 10*sinf(i*freq*6.28f/44100.0f);

		// damp the input into the FFT a bit, to reduce high-frequency noise:
		temp_wave[0][i] = 0.5f*(m_sound.fWaveform[0][i] + m_sound.fWaveform[0][old_i]);
		temp_wave[1][i] = 0.5f*(m_sound.fWaveform[1][i] + m_sound.fWaveform[1][old_i]);
		old_i = i;
	}

	m_fftobj.time_to_frequency_domain(temp_wave[0], m_sound.fSpectrum[0]);
	m_fftobj.time_to_frequency_domain(temp_wave[1], m_sound.fSpectrum[1]);

	// sum (left channel) spectrum up into 3 bands
	// [note: the new ranges do it so that the 3 bands are equally spaced, pitch-wise]
	float min_freq = 200.0f;
	float max_freq = 11025.0f;
	float net_octaves = (logf(max_freq/min_freq) / logf(2.0f));     // 5.7846348455575205777914165223593
	float octaves_per_band = net_octaves / 3.0f;                    // 1.9282116151858401925971388407864
	float mult = powf(2.0f, octaves_per_band); // each band's highest freq. divided by its lowest freq.; 3.805831305510122517035102576162
	// [to verify: min_freq * mult * mult * mult should equal max_freq.]
	for (int ch=0; ch<2; ch++)
	{
		for (i=0; i<3; i++)
		{
			// old guesswork code for this:
			//   float exp = 2.1f;
			//   int start = (int)(NUM_FREQUENCIES*0.5f*powf(i/3.0f, exp));
			//   int end   = (int)(NUM_FREQUENCIES*0.5f*powf((i+1)/3.0f, exp));
			// results:
			//          old range:      new range (ideal):
			//   bass:  0-1097          200-761
			//   mids:  1097-4705       761-2897
			//   treb:  4705-11025      2897-11025
			int start = (int)(NUM_FREQUENCIES * min_freq*powf(mult, (float)i)/11025.0f);
			int end   = (int)(NUM_FREQUENCIES * min_freq*powf(mult, (float)(i+1))/11025.0f);
			if (start < 0) start = 0;
			if (end > NUM_FREQUENCIES) end = NUM_FREQUENCIES;

			m_sound.imm[ch][i] = 0;
			for (int j=start; j<end; j++)
				m_sound.imm[ch][i] += m_sound.fSpectrum[ch][j];
			m_sound.imm[ch][i] /= (float)(end-start);
		}
	}

	// some code to find empirical long-term averages for imm[0..2]:
	/*{
	    static float sum[3];
	    static int count = 0;

	    #define FRAMES_PER_SONG 300     // should be at least 200!

	    if (m_frame < FRAMES_PER_SONG)
	    {
	        sum[0] = sum[1] = sum[2] = 0;
	        count = 0;
	    }
	    else
	    {
	        if (m_frame%FRAMES_PER_SONG == 0)
	        {
	            char buf[256];
	            sprintf(buf, "%.4f, %.4f, %.4f     (%d samples / ~%d songs)\n",
	                sum[0]/(float)(count),
	                sum[1]/(float)(count),
	                sum[2]/(float)(count),
	                count,
	                count/(FRAMES_PER_SONG-10)
	            );
	            OutputDebugString(buf);

	            // skip to next song
	            PostMessage(m_hWndWinamp,WM_COMMAND,40048,0);
	        }
	        else if (m_frame%FRAMES_PER_SONG == 5)
	        {
	            // then advance to 0-2 minutes into the song:
	            PostMessage(m_hWndWinamp,WM_USER,(20 + (warand()%65) + (rand()%65))*1000,106);
	        }
	        else if (m_frame%FRAMES_PER_SONG >= 10)
	        {
	            sum[0] += m_sound.imm[0];
	            sum[1] += m_sound.imm[1];
	            sum[2] += m_sound.imm[2];
	            count++;
	        }
	    }
	}*/

	// multiply by long-term, empirically-determined inverse averages:
	// (for a trial of 244 songs, 10 seconds each, somewhere in the 2nd or 3rd minute,
	//  the average levels were: 0.326781557	0.38087377	0.199888934
	for (int ch=0; ch<2; ch++)
	{
		m_sound.imm[ch][0] /= 0.326781557f;//0.270f;
		m_sound.imm[ch][1] /= 0.380873770f;//0.343f;
		m_sound.imm[ch][2] /= 0.199888934f;//0.295f;
	}

	// do temporal blending to create attenuated and super-attenuated versions
	for (int ch=0; ch<2; ch++)
	{
		for (i=0; i<3; i++)
		{
			// m_sound.avg[i]
			{
				float avg_mix;
				if (m_sound.imm[ch][i] > m_sound.avg[ch][i])
					avg_mix = AdjustRateToFPS(0.2f, 14.0f, m_fps);
				else
					avg_mix = AdjustRateToFPS(0.5f, 14.0f, m_fps);
				m_sound.avg[ch][i] = m_sound.avg[ch][i]*avg_mix + m_sound.imm[ch][i]*(1-avg_mix);
			}

			// m_sound.med_avg[i]
			// m_sound.long_avg[i]
			{
				float med_mix  = 0.91f;//0.800f + 0.11f*powf(t, 0.4f);    // primarily used for velocity_damping
				float long_mix = 0.96f;//0.800f + 0.16f*powf(t, 0.2f);    // primarily used for smoke plumes
				med_mix  = AdjustRateToFPS(med_mix, 14.0f, m_fps);
				long_mix = AdjustRateToFPS(long_mix, 14.0f, m_fps);
				m_sound.med_avg[ch][i]  =  m_sound.med_avg[ch][i]*(med_mix) + m_sound.imm[ch][i]*(1-med_mix);
				m_sound.long_avg[ch][i] = m_sound.long_avg[ch][i]*(long_mix) + m_sound.imm[ch][i]*(1-long_mix);
			}
		}
	}
}

void CPluginShell::PrepareFor2DDrawing_B(IDirect3DDevice9 *pDevice, int w, int h)
{
	// New 2D drawing area will have x,y coords in the range <-1,-1> .. <1,1>
	//         +--------+ Y=-1
	//         |        |
	//         | screen |             Z=0: front of scene
	//         |        |             Z=1: back of scene
	//         +--------+ Y=1
	//       X=-1      X=1
	// NOTE: After calling this, be sure to then call (at least):
	//  1. SetVertexShader()
	//  2. SetTexture(), if you need it
	// before rendering primitives!
	// Also, be sure your sprites have a z coordinate of 0.

	pDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
	pDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
	pDevice->SetRenderState(D3DRS_ZFUNC,     D3DCMP_LESSEQUAL);
	pDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
	pDevice->SetRenderState(D3DRS_FILLMODE,  D3DFILL_SOLID);
	pDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
	pDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	pDevice->SetRenderState(D3DRS_CLIPPING, TRUE);
	pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
	pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	pDevice->SetRenderState(D3DRS_LOCALVIEWER, FALSE);
	pDevice->SetRenderState(D3DRS_COLORVERTEX, TRUE);

	pDevice->SetTexture(0, NULL);
	pDevice->SetTexture(1, NULL);
	pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);//D3DTEXF_LINEAR);
	pDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_POINT);//D3DTEXF_LINEAR);
	pDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
	pDevice->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
	pDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
	pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	pDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
	pDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);

	pDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
	pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
	pDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);

	pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

	// set up for 2D drawing:
	{
		D3DXMATRIX Ortho2D;
		D3DXMATRIX Identity;

		pMatrixOrthoLH(&Ortho2D, (float)w, (float)h, 0.0f, 1.0f);
		D3DXMatrixIdentity(&Identity);

		pDevice->SetTransform(D3DTS_PROJECTION, &Ortho2D);
		pDevice->SetTransform(D3DTS_WORLD, &Identity);
		pDevice->SetTransform(D3DTS_VIEW, &Identity);
	}
}

void CPluginShell::DrawDarkTranslucentBox(RECT* pr)
{
	// 'pr' is the rectangle that some text will occupy;
	// a black box will be drawn around it, plus a bit of extra margin space.

	if (m_vjd3d9_device)
		return;

	m_lpDX->m_lpDevice->SetVertexShader(NULL);
	m_lpDX->m_lpDevice->SetPixelShader(NULL);
	m_lpDX->m_lpDevice->SetFVF(SIMPLE_VERTEX_FORMAT);
	m_lpDX->m_lpDevice->SetTexture(0, NULL);

	m_lpDX->m_lpDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	m_lpDX->m_lpDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	m_lpDX->m_lpDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

	m_lpDX->m_lpDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
	m_lpDX->m_lpDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
	m_lpDX->m_lpDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
	m_lpDX->m_lpDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
	m_lpDX->m_lpDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);

	// set up a quad
	SIMPLEVERTEX verts[4];
	for (int i=0; i<4; i++)
	{
		verts[i].x = (i%2==0) ? (float)(-m_lpDX->m_client_width /2  + pr->left)  :
		             (float)(-m_lpDX->m_client_width /2  + pr->right);
		verts[i].y = (i/2==0) ? (float)-(-m_lpDX->m_client_height/2 + pr->bottom)  :
		             (float)-(-m_lpDX->m_client_height/2 + pr->top);
		verts[i].z = 0;
		verts[i].Diffuse = (m_screenmode==DESKTOP) ? 0xE0000000 : 0xD0000000;
	}

	m_lpDX->m_lpDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, verts, sizeof(SIMPLEVERTEX));

	// undo unusual state changes:
	m_lpDX->m_lpDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
	m_lpDX->m_lpDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
}

void CPluginShell::RenderBuiltInTextMsgs()
{
	int _show_press_f1_NOW = (m_show_press_f1_msg && m_time < PRESS_F1_DUR);

	{
		RECT r;

		if (m_show_help)
		{
			int y = m_upper_left_corner_y;

			SetRect(&r, 0, 0, GetWidth(), GetHeight());
			if(!g_szHelp_W)
				m_d3dx_font[HELPSCREEN_FONT]->DrawTextA(NULL, (char*)g_szHelp, -1, &r, DT_CALCRECT, 0xFFFFFFFF);
			else
				m_d3dx_font[HELPSCREEN_FONT]->DrawTextW(NULL, g_szHelp, -1, &r, DT_CALCRECT, 0xFFFFFFFF);

			r.top += m_upper_left_corner_y;
			r.left += m_left_edge;
			r.right += m_left_edge + PLAYLIST_INNER_MARGIN*2;
			r.bottom += m_upper_left_corner_y + PLAYLIST_INNER_MARGIN*2;
			DrawDarkTranslucentBox(&r);

			r.top += PLAYLIST_INNER_MARGIN;
			r.left += PLAYLIST_INNER_MARGIN;
			r.right -= PLAYLIST_INNER_MARGIN;
			r.bottom -= PLAYLIST_INNER_MARGIN;
			if(!g_szHelp_W)
				m_d3dx_font[HELPSCREEN_FONT]->DrawTextA(NULL, (char*)g_szHelp, -1, &r, 0, 0xFFFFFFFF);
			else
				m_d3dx_font[HELPSCREEN_FONT]->DrawTextW(NULL, g_szHelp, -1, &r, 0, 0xFFFFFFFF);

			m_upper_left_corner_y += r.bottom-r.top + PLAYLIST_INNER_MARGIN*3;
		}

		// render 'Press F1 for Help' message in lower-right corner:
		if (_show_press_f1_NOW)
		{
			int dx = (int)(160.0f * powf(m_time/(float)(PRESS_F1_DUR), (float)(PRESS_F1_EXP)));
			SetRect(&r, m_left_edge, m_lower_right_corner_y - GetFontHeight(DECORATIVE_FONT), m_right_edge + dx, m_lower_right_corner_y);
			m_lower_right_corner_y -= m_d3dx_font[DECORATIVE_FONT]->DrawTextW(NULL, WASABI_API_LNGSTRINGW(IDS_PRESS_F1_MSG), -1, &r, DT_RIGHT, 0xFFFFFFFF);
		}
	}
}

void CPluginShell::RenderPlaylist()
{
	// draw playlist:
	if (m_show_playlist)
	{
		RECT r;
		int nSongs = SendMessage(m_hWndWinamp,WM_USER, 0, 124);
		int now_playing = SendMessage(m_hWndWinamp,WM_USER, 0, 125);

		if (nSongs <= 0)
		{
			m_show_playlist = 0;
		}
		else
		{
			int playlist_vert_pixels = m_lower_left_corner_y - m_upper_left_corner_y;
			int disp_lines  = min(MAX_SONGS_PER_PAGE, (playlist_vert_pixels - PLAYLIST_INNER_MARGIN*2) / GetFontHeight(PLAYLIST_FONT));
			int total_pages = (nSongs) / disp_lines;

			if (disp_lines<=0)
				return;

			// apply PgUp/PgDn keypresses since last time
			m_playlist_pos -= m_playlist_pageups * disp_lines;
			m_playlist_pageups = 0;

			if (m_playlist_pos < 0)
				m_playlist_pos = 0;
			if (m_playlist_pos >= nSongs)
				m_playlist_pos = nSongs-1;

			// NOTE: 'dwFlags' is used for both DDRAW and DX9
			DWORD dwFlags   = DT_SINGLELINE;// | DT_NOPREFIX | DT_WORD_ELLIPSIS;
			DWORD color;

			int cur_page    = (m_playlist_pos) / disp_lines;
			int cur_line    = (m_playlist_pos + disp_lines - 1) % disp_lines;
			int new_top_idx = cur_page * disp_lines;
			int new_btm_idx = new_top_idx + disp_lines;
			wchar_t buf[1024] = {0};

			// ask winamp for the song names, but DO IT BEFORE getting the DC,
			// otherwise vaio will crash (~DDRAW port).
			if (m_playlist_top_idx != new_top_idx ||
			    m_playlist_btm_idx != new_btm_idx)
			{
				for (int i=0; i<disp_lines; i++)
				{
					int j = new_top_idx + i;
					if (j < nSongs)
					{
						// clip max len. of song name to 240 chars, to prevent overflows
						lstrcpynW(buf, (wchar_t*)SendMessage(m_hWndWinamp, WM_USER, j, IPC_GETPLAYLISTTITLEW), 240);
						wsprintfW(m_playlist[i], L"%d. %s ", j+1, buf);  // leave an extra space @ end, so italicized fonts don't get clipped
					}
				}
			}

			// update playlist cache, if necessary:
			if (m_playlist_top_idx != new_top_idx ||
			    m_playlist_btm_idx != new_btm_idx)
			{
				m_playlist_top_idx = new_top_idx;
				m_playlist_btm_idx = new_btm_idx;
				m_playlist_width_pixels = 0;

				int max_w = min(m_right_edge - m_left_edge, m_lpDX->m_client_width - TEXT_MARGIN*2 - PLAYLIST_INNER_MARGIN*2);

				for (int i=0; i<disp_lines; i++)
				{
					int j = new_top_idx + i;
					if (j < nSongs)
					{
						// clip max len. of song name to 240 chars, to prevent overflows
						//strcpy(buf, (char*)SendMessage(m_hWndWinamp, WM_USER, j, 212));
						//buf[240] = 0;
						//sprintf(m_playlist[i], "%d. %s ", j+1, buf);  // leave an extra space @ end, so italicized fonts don't get clipped

						SetRect(&r, 0, 0, max_w, 1024);
						m_d3dx_font[PLAYLIST_FONT]->DrawTextW(NULL, m_playlist[i], -1, &r, dwFlags | DT_CALCRECT, 0xFFFFFFFF);
						int w = r.right-r.left;
						if (w>0)
							m_playlist_width_pixels = max(m_playlist_width_pixels, w);
					}
					else
					{
						m_playlist[i][0] = 0;
					}
				}

				if (m_playlist_width_pixels == 0 ||
				    m_playlist_width_pixels > max_w)
					m_playlist_width_pixels = max_w;
			}

			int start = max(0, (cur_page)*disp_lines);
			int end   = min(nSongs, (cur_page+1)*disp_lines);

			// draw dark box around where the playlist will go:

			RECT r;
			r.top    = m_upper_left_corner_y;
			r.left   = m_left_edge;
			r.right  = m_left_edge + m_playlist_width_pixels + PLAYLIST_INNER_MARGIN*2;
			r.bottom = m_upper_left_corner_y + (end-start)*GetFontHeight(PLAYLIST_FONT) + PLAYLIST_INNER_MARGIN*2;
			DrawDarkTranslucentBox(&r);

			//m_d3dx_font[PLAYLIST_FONT]->Begin();

			// draw playlist text
			int y = m_upper_left_corner_y + PLAYLIST_INNER_MARGIN;
			for (int i=start; i<end; i++)
			{
				SetRect(&r, m_left_edge + PLAYLIST_INNER_MARGIN, y, m_left_edge + PLAYLIST_INNER_MARGIN + m_playlist_width_pixels, y + GetFontHeight(PLAYLIST_FONT));

				if (m_lpDX->GetBitDepth() == 8)
					color = (i==m_playlist_pos) ?
					        (i==now_playing ? 0xFFFFFFFF : 0xFFFFFFFF) :
							        (i==now_playing ? 0xFFFFFFFF : 0xFF707070);
				else
					color = (i==m_playlist_pos) ?
					        (i==now_playing ? PLAYLIST_COLOR_BOTH : PLAYLIST_COLOR_HILITE_TRACK) :
							        (i==now_playing ? PLAYLIST_COLOR_PLAYING_TRACK : PLAYLIST_COLOR_NORMAL);

				y += m_d3dx_font[PLAYLIST_FONT]->DrawTextW(NULL, m_playlist[i-start], -1, &r, dwFlags, color);
			}

			//m_d3dx_font[PLAYLIST_FONT]->End();
		}
	}
}

void CPluginShell::SuggestHowToFreeSomeMem()
{
	// This function is called when the plugin runs out of video memory;
	//   it lets you show a messagebox to the user so you can (intelligently)
	//   suggest how to free up some video memory, based on what settings
	//   they've chosen.

	wchar_t str[1024];

	if (m_lpDX->m_current_mode.multisamp != D3DMULTISAMPLE_NONE)
	{
		if (m_lpDX->m_current_mode.screenmode == WINDOWED)
			WASABI_API_LNGSTRINGW_BUF(IDS_TO_FREE_UP_SOME_MEMORY_RESTART_WINAMP_THEN_GO_TO_CONFIG, str, 2048);
		else if (m_lpDX->m_current_mode.screenmode == FAKE_FULLSCREEN)
			WASABI_API_LNGSTRINGW_BUF(IDS_TO_FREE_UP_SOME_MEMORY_RESTART_WINAMP_THEN_GO_TO_CONFIG_2, str, 2048);
		else
			WASABI_API_LNGSTRINGW_BUF(IDS_TO_FREE_UP_SOME_MEMORY_RESTART_WINAMP_THEN_GO_TO_CONFIG_3, str, 2048);
	}
	else
		if (m_lpDX->m_current_mode.screenmode == FULLSCREEN)  // true fullscreen
			WASABI_API_LNGSTRINGW_BUF(IDS_TO_FREE_UP_VIDEO_MEMORY, str, 2048);
		else    // windowed, desktop mode, or fake fullscreen
			WASABI_API_LNGSTRINGW_BUF(IDS_TO_FREE_UP_VIDEO_MEMORY, str, 2048);

	MessageBoxW(m_lpDX->GetHwnd(), str, WASABI_API_LNGSTRINGW(IDS_MILKDROP_SUGGESTION), MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
}

LRESULT CALLBACK CPluginShell::WindowProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
	//if (uMsg==WM_GETDLGCODE)
	//    return DLGC_WANTALLKEYS|DLGC_WANTCHARS|DLGC_WANTMESSAGE;    // this tells the embedwnd that we want keypresses to flow through to our client wnd.

	if (uMsg == WM_CREATE)
	{
		CREATESTRUCT *create = (CREATESTRUCT *)lParam;
		SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)create->lpCreateParams);
	}

	CPluginShell* p = (CPluginShell*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
	if (p)
		return p->PluginShellWindowProc(hWnd, uMsg, wParam, lParam);
	else
		return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}

LRESULT CPluginShell::PluginShellWindowProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
	USHORT mask = 1 << (sizeof(SHORT)*8 - 1);
	//bool bShiftHeldDown = (GetKeyState(VK_SHIFT) & mask) != 0;
	bool bCtrlHeldDown  = (GetKeyState(VK_CONTROL) & mask) != 0;
	//bool bAltHeldDown: most keys come in under WM_SYSKEYDOWN when ALT is depressed.

	int i;
#ifdef _DEBUG
	char caption[256] = "WndProc: frame 0, ";
	if (m_frame > 0)
	{
		float time = m_time;
		int hours = (int)(time/3600);
		time -= hours*3600;
		int minutes = (int)(time/60);
		time -= minutes*60;
		int seconds = (int)time;
		time -= seconds;
		int dsec = (int)(time*100);
		sprintf(caption, "WndProc: frame %d, t=%dh:%02dm:%02d.%02ds, ", m_frame, hours, minutes, seconds, dsec);
	}

	if (uMsg != WM_MOUSEMOVE &&
	    uMsg != WM_NCHITTEST &&
	    uMsg != WM_SETCURSOR &&
	    uMsg != WM_COPYDATA &&
	    uMsg != WM_USER)
		OutputDebugMessage(caption, hWnd, uMsg, wParam, lParam);
#endif

	switch (uMsg)
	{
	case WM_USER:
		if (m_screenmode == DESKTOP)
		{
			// this function resides in vms_desktop.dll;
			// its response will come later, via the WM_COPYDATA
			// message (See below).
			//KIV: **THIS CALL CRASHES EXPLORER IN VISTA**
			getItemData(wParam);
			return 0;
		}
		break;

	case WM_COPYDATA:
		if (m_screenmode == DESKTOP)
		{
			// this message is vms_desktop.dll's response to
			// our call to getItemData().
			PCOPYDATASTRUCT c = (PCOPYDATASTRUCT)lParam;
			if (c && (c->cbData % sizeof(icon_t) == 0))
			{
				icon_t *pNewIcons = (icon_t*)c->lpData;

				EnterCriticalSection(&m_desktop_cs);

				if (m_desktop_icon_state == 1 && (c->dwData & 0x80000000))  // if doing a total refresh...
				{
					// ...we build the list from zero
					int len = c->dwData & 0xFFFF;
					for (int i=0; i<len; i++)
						m_icon_list.push_back(pNewIcons[i]);
				}
				else if (m_desktop_icon_state == 3 && !(c->dwData & 0x80000000))
				{
					// otherwise, we alter existing things in the list:
					IconList::iterator p;
					int start = c->dwData & 0xFFFF;
					int len   = c->dwData >> 16;

					int i = 0;
					for (p = m_icon_list.begin(); p != m_icon_list.end() && i<start; p++)
						i++;
					for (; p != m_icon_list.end() && i<start+len; p++)
					{
						p->x = pNewIcons[i-start].x;
						p->y = pNewIcons[i-start].y;
						memcpy(p->name, pNewIcons[i-start].name, sizeof(p->name));
						memcpy(p->pidl, pNewIcons[i-start].pidl, sizeof(p->pidl));
						i++;
					}

					m_desktop_icon_state = 2;
					m_desktop_icon_update_frame = GetFrame();
				}

				LeaveCriticalSection(&m_desktop_cs);
			}

			return 0;
		}
		break;

	case WM_ERASEBKGND:
		// Repaint window when song is paused and image needs to be repainted:
		if (SendMessage(m_hWndWinamp,WM_USER,0,104)!=1 && m_lpDX && m_lpDX->m_lpDevice && GetFrame() > 0)    // WM_USER/104 return codes: 1=playing, 3=paused, other=stopped
		{
			m_lpDX->m_lpDevice->Present(NULL,NULL,NULL,NULL);
			return 0;
		}
		break;

	case WM_WINDOWPOSCHANGING:
		if (
		  m_screenmode == DESKTOP
		  && (!m_force_accept_WM_WINDOWPOSCHANGING)
		  && m_lpDX && m_lpDX->m_ready
		)
		{
			// unless we requested it ourselves or it's init time,
			// prevent the fake desktop window from moving around
			// in the Z order!  (i.e., keep it on the bottom)

			// without this code, when you click on the 'real' desktop
			// in a multimon setup, any windows that are overtop of the
			// 'fake' desktop will flash, since they'll be covered
			// up by the fake desktop window (but then shown again on
			// the next frame, when we detect that the fake desktop
			// window isn't on bottom & send it back to the bottom).

			LPWINDOWPOS pwp = (LPWINDOWPOS)lParam;
			if (pwp)
				pwp->flags |= SWP_NOOWNERZORDER | SWP_NOZORDER;
		}
		if (m_screenmode==WINDOWED && m_lpDX && m_lpDX->m_ready && m_lpDX->m_current_mode.m_skin)
			m_lpDX->SaveWindow();
		break;
	case WM_NCACTIVATE:
		// *Very Important Handler!*
		//    -Without this code, the app would not work properly when running in true
		//     fullscreen mode on multiple monitors; it would auto-minimize whenever the
		//     user clicked on a window in another display.
		if (wParam == 0 &&
		    m_screenmode == FULLSCREEN &&
		    m_frame > 0 &&
		    !m_exiting &&
		    m_lpDX &&
		    m_lpDX->m_ready
		    && m_lpDX->m_lpD3D &&
		    m_lpDX->m_lpD3D->GetAdapterCount() > 1
		   )
		{
			return 0;
		}
		break;

	case WM_DESTROY:
		// note: don't post quit message here if the window is being destroyed
		// and re-created on a switch between windowed & FAKE fullscreen modes.
		if (!m_lpDX->TempIgnoreDestroyMessages())
		{
			// this is a final exit, and not just destroy-then-recreate-the-window.
			// so, flag DXContext so it knows that someone else
			// will take care of destroying the window!
			m_lpDX->OnTrulyExiting();
			PostQuitMessage(0);
		}
		return FALSE;
		break;
		// benski> a little hack to get the window size correct. it seems to work
	case WM_USER+555:
		if (m_lpDX && m_lpDX->m_ready && m_screenmode==WINDOWED && !m_resizing)
		{
			OnUserResizeWindow();
			m_lpDX->SaveWindow();
		}
		break;
	case WM_MOVE:
		m_lpDX->SaveWindow();
		break;
	case WM_SIZE:
		// clear or set activity flag to reflect focus
		if (m_lpDX && m_lpDX->m_ready && m_screenmode==WINDOWED && !m_resizing)
		{
			m_hidden = (SIZE_MAXHIDE==wParam || SIZE_MINIMIZED==wParam) ? TRUE : FALSE;

			if (SIZE_MAXIMIZED==wParam || SIZE_RESTORED==wParam) // the window has been maximized or restored
				OnUserResizeWindow();
		}
		break;

	case WM_ENTERSIZEMOVE:
		m_resizing = 1;
		break;

	case WM_EXITSIZEMOVE:
		if (m_lpDX && m_lpDX->m_ready && m_screenmode==WINDOWED)
			OnUserResizeWindow();
		m_lpDX->SaveWindow();
		m_resizing = 0;
		break;

	case WM_GETMINMAXINFO:
	{
		// don't let the window get too small
		MINMAXINFO* p = (MINMAXINFO*)lParam;
		if (p->ptMinTrackSize.x < 64)
			p->ptMinTrackSize.x = 64;
		p->ptMinTrackSize.y = p->ptMinTrackSize.x*3/4;
	}
	return 0;

	case WM_MOUSEMOVE:
		if (m_screenmode==DESKTOP && (m_desktop_dragging==1 || m_desktop_box==1))
		{
			m_desktop_drag_curpos.x = LOWORD(lParam);
			m_desktop_drag_curpos.y = HIWORD(lParam);
			if (m_desktop_box==1)
			{
				// update selection based on box coords
				RECT box, temp;
				box.left   = min(m_desktop_drag_curpos.x, m_desktop_drag_startpos.x);
				box.right  = max(m_desktop_drag_curpos.x, m_desktop_drag_startpos.x);
				box.top    = min(m_desktop_drag_curpos.y, m_desktop_drag_startpos.y);
				box.bottom = max(m_desktop_drag_curpos.y, m_desktop_drag_startpos.y);

				IconList::iterator p;
				for (p = m_icon_list.begin(); p != m_icon_list.end(); p++)
				{
					p->selected = 0;

					if (IntersectRect(&temp, &box, &p->label_rect))
						p->selected = 1;
					else if (IntersectRect(&temp, &box, &p->icon_rect))
						p->selected = 1;
				}
			}

			// repaint window manually, if winamp is paused
			if (SendMessage(m_hWndWinamp,WM_USER,0,104) != 1)
			{
				PushWindowToJustBeforeDesktop(GetPluginWindow());
				DrawAndDisplay(1);
			}

			//return 0;
		}
		m_lpDX->SaveWindow();
		break;

	case WM_LBUTTONUP:
		if (m_screenmode==DESKTOP)
		{
			if (m_desktop_dragging)
			{
				m_desktop_dragging = 0;

				// move selected item(s) to new cursor position
				int dx = LOWORD(lParam) - m_desktop_drag_startpos.x;
				int dy = HIWORD(lParam) - m_desktop_drag_startpos.y;

				if (dx!=0 || dy!=0)
				{
					int idx=0;
					IconList::iterator p;
					for (p = m_icon_list.begin(); p != m_icon_list.end(); p++)
					{
						if (p->selected)
						{
							SendMessage(m_hWndDesktopListView, LVM_SETITEMPOSITION, idx, MAKELPARAM(p->x + dx, p->y + dy));
							p->x += dx;
							p->y += dy;
						}
						idx++;
					}
				}

				// repaint window manually, if winamp is paused
				if (SendMessage(m_hWndWinamp,WM_USER,0,104) != 1)
				{
					PushWindowToJustBeforeDesktop(GetPluginWindow());
					DrawAndDisplay(1);
				}
			}

			if (m_desktop_box)
			{
				m_desktop_box = 0;

				// repaint window manually, if winamp is paused
				if (SendMessage(m_hWndWinamp,WM_USER,0,104) != 1)
				{
					PushWindowToJustBeforeDesktop(GetPluginWindow());
					DrawAndDisplay(1);
				}
			}

			//return 0;
		}
		break;

	case WM_USER + 1666:
		if (wParam == 1 && lParam == 15)
		{
			if (m_screenmode == FULLSCREEN || m_screenmode == FAKE_FULLSCREEN)
				ToggleFullScreen();
		}
		return 0;
	case WM_LBUTTONDOWN:
	case WM_LBUTTONDBLCLK:
	case WM_RBUTTONDOWN:
	case WM_RBUTTONUP:
		// Toggle between Fullscreen and Windowed modes on double-click
		// note: this requires the 'CS_DBLCLKS' windowclass style!
		if (m_screenmode != DESKTOP)
		{
			SetFocus(hWnd);
			if (uMsg==WM_LBUTTONDBLCLK && m_frame>0)
			{
				ToggleFullScreen();
				return 0;
			}
		}
		else
		{
			POINT pt;
			pt.x = LOWORD(lParam);
			pt.y = HIWORD(lParam);

			int done = 0;

			for (int pass=0; pass<2 && !done; pass++)
			{
				IconList::iterator p;
				for (p = m_icon_list.begin(); p != m_icon_list.end(); p++)
				{
					RECT *pr = (pass==0) ? &p->icon_rect : &p->label_rect;
					int bottom_extend = (pass==0) ? 3 : 0; // accepts clicks in the 3-pixel gap between the icon and the text label.
					if (pt.x >= pr->left &&
					    pt.x <= pr->right &&
					    pt.y >= pr->top &&
					    pt.y <= pr->bottom + bottom_extend)
					{
						switch (uMsg)
						{
						case WM_RBUTTONUP:
							//pt.x += m_lpDX->m_monitor_rect.left;
							//pt.y += m_lpDX->m_monitor_rect.top;
							DoExplorerMenu(GetPluginWindow(), (LPITEMIDLIST)p->pidl, pt);
							break;
						case WM_LBUTTONDBLCLK:
						{
							char buf[MAX_PATH];
							sprintf(buf, "%s\\%s", m_szDesktopFolder, p->name);
							ExecutePidl((LPITEMIDLIST)p->pidl, buf, m_szDesktopFolder, GetPluginWindow());
						}
						break;
						case WM_LBUTTONDOWN:
							m_desktop_dragging = 1;
							memcpy(m_desktop_drag_pidl, p->pidl, sizeof(m_desktop_drag_pidl));
							m_desktop_drag_startpos.x = LOWORD(lParam);
							m_desktop_drag_startpos.y = HIWORD(lParam);
							m_desktop_drag_curpos.x = LOWORD(lParam);
							m_desktop_drag_curpos.y = HIWORD(lParam);
							if (!(wParam & MK_CONTROL)) // if CTRL not held down
							{
								if (!p->selected)
								{
									DeselectDesktop();
									p->selected = 1;
								}
							}
							else
							{
								p->selected = 1-p->selected;
							}
							break;
						case WM_RBUTTONDOWN:
							DeselectDesktop();
							p->selected = 1;
							break;
						}

						done = 1;
						break;
					}
				}
			}

			if (!done)
			{
				// deselect all, unless they're CTRL+clicking and missed an icon.
				if (uMsg!=WM_LBUTTONDOWN || !(wParam & MK_CONTROL))
					DeselectDesktop();

				if (uMsg==WM_RBUTTONUP)// || uMsg==WM_RBUTTONDOWN)
				{
					// note: can't use GetMenu and TrackPopupMenu here because the hwnd param to TrackPopupMenu must belong to current application.

					// (before sending coords to desktop window, xform them into its client coords:)
					POINT pt;
					pt.x = LOWORD(lParam);
					pt.y = HIWORD(lParam);
					ScreenToClient(m_hWndDesktopListView, &pt);
					lParam = MAKELPARAM(pt.x + m_lpDX->m_monitor_rect.left, pt.y + m_lpDX->m_monitor_rect.top);

					PostMessage(m_hWndDesktopListView, uMsg, wParam, lParam);
					//PostMessage(m_hWndDesktopListView, WM_CONTEXTMENU, (WPARAM)m_hWndDesktopListView, lParam);
				}
				else if (uMsg==WM_LBUTTONDOWN)
				{
					m_desktop_box = 1;
					m_desktop_drag_startpos.x = LOWORD(lParam);
					m_desktop_drag_startpos.y = HIWORD(lParam);
					m_desktop_drag_curpos.x = LOWORD(lParam);
					m_desktop_drag_curpos.y = HIWORD(lParam);
				}
			}

			// repaint window manually, if winamp is paused
			if (SendMessage(m_hWndWinamp,WM_USER,0,104) != 1)
			{
				PushWindowToJustBeforeDesktop(GetPluginWindow());
				DrawAndDisplay(1);
			}

			//return 0;
		}
		break;

	case WM_SETFOCUS:
		// note: this msg never comes in when embedwnd is used, but that's ok, because that's only
		// in Windowed mode, and m_lost_focus only makes us sleep when fullscreen.
		m_lost_focus = 0;
		break;

	case WM_KILLFOCUS:
		// note: this msg never comes in when embedwnd is used, but that's ok, because that's only
		// in Windowed mode, and m_lost_focus only makes us sleep when fullscreen.
		m_lost_focus = 1;
		break;

	case WM_SETCURSOR:
		if (
		  (m_screenmode == FULLSCREEN) ||
		  (m_screenmode == FAKE_FULLSCREEN && m_lpDX->m_fake_fs_covers_all)
		)
		{
			// hide the cursor
			SetCursor(NULL);
			return TRUE; // prevent Windows from setting cursor to window class cursor
		}
		break;

	case WM_NCHITTEST:
		// Prevent the user from selecting the menu in fullscreen mode
		if (m_screenmode != WINDOWED)
			return HTCLIENT;
		break;

	case WM_SYSCOMMAND:
		// Prevent *moving/sizing* and *entering standby mode* when in fullscreen mode
		switch (wParam)
		{
		case SC_MOVE:
		case SC_SIZE:
		case SC_MAXIMIZE:
		case SC_KEYMENU:
			if (m_screenmode != WINDOWED)
				return 1;
			break;
		case SC_MONITORPOWER:
			if (m_screenmode == FULLSCREEN || m_screenmode == FAKE_FULLSCREEN)
				return 1;
			break;
		}
		break;

	case WM_CONTEXTMENU:
		// launch popup context menu.  see handler for WM_COMMAND also.
		if (m_screenmode == DESKTOP)
		{
			// note: execution should never reach this point,
			// because we don't pass WM_RBUTTONUP to DefWindowProc
			// when in desktop mode!
			return 0;
		}
		else if (m_screenmode == WINDOWED)    // context menus only allowed in ~windowed modes
		{
			TrackPopupMenuEx(m_context_menu, TPM_VERTICAL, LOWORD(lParam), HIWORD(lParam), hWnd, NULL);
			return 0;
		}
		break;

	case WM_COMMAND:
		// handle clicks on items on context menu.
		if (m_screenmode == WINDOWED)
		{
			switch (LOWORD(wParam))
			{
			case ID_QUIT:
				m_exiting = 1;
				PostMessage(hWnd, WM_CLOSE, 0, 0);
				return 0;
			case ID_GO_FS:
				if (m_frame > 0)
					ToggleFullScreen();
				return 0;
			case ID_DESKTOP_MODE:
				if (m_frame > 0)
					ToggleDesktop();
				return 0;
			case ID_SHOWHELP:
				ToggleHelp();
				return 0;
			case ID_SHOWPLAYLIST:
				TogglePlaylist();
				return 0;
			}
			// then allow the plugin to override any command:
			if (MyWindowProc(hWnd, uMsg, wParam, lParam) == 0)
				return 0;
		}
		break;

		/*
		KEY HANDLING: the basic idea:
		    -in all cases, handle or capture:
		        -ZXCVBRS, zxcvbrs
		            -also make sure it's case-insensitive!  (lowercase come through only as WM_CHAR; uppercase come in as both)
		        -(ALT+ENTER)
		        -(F1, ESC, UP, DN, Left, Right, SHIFT+l/r)
		        -(P for playlist)
		            -when playlist showing: steal J, HOME, END, PGUP, PGDN, UP, DOWN, ESC
		        -(BLOCK J, L)
		    -when integrated with winamp (using embedwnd), also handle these keys:
		        -j, l, L, CTRL+L [windowed mode only!]
		        -CTRL+P, CTRL+D
		        -CTRL+TAB
		        -ALT-E
		        -ALT+F (main menu)
		        -ALT+3 (id3)
		*/

	case WM_SYSKEYDOWN:
		if (wParam==VK_RETURN && m_frame > 0)
		{
			ToggleFullScreen();
			return 0;
		}
		// if in embedded mode (using winamp skin), pass ALT+ keys on to winamp
		// ex: ALT+E, ALT+F, ALT+3...
		if (m_screenmode==WINDOWED && m_lpDX->m_current_mode.m_skin)
			return PostMessage(m_hWndWinamp, uMsg, wParam, lParam); // force-pass to winamp; required for embedwnd
		break;

	case WM_SYSKEYUP:
		if (m_screenmode==WINDOWED && m_lpDX->m_current_mode.m_skin)
			return PostMessage(m_hWndWinamp, uMsg, wParam, lParam); // force-pass to winamp; required for embedwnd
		break;

	case WM_SYSCHAR:
		if ((wParam=='k' || wParam=='K'))
		{
			OnAltK();
			return 0;
		}
		if ((wParam=='d' || wParam=='D') && m_frame > 0)
		{
			ToggleDesktop();
			return 0;
		}
		break;

	case WM_CHAR:
		// if playlist is showing, steal p/j keys from the plugin:
		if (m_show_playlist)
		{
			switch (wParam)
			{
			case 'j':
			case 'J':
				m_playlist_pos = SendMessage(m_hWndWinamp,WM_USER, 0, 125);
				return 0;
			default:
			{
				int nSongs = SendMessage(m_hWndWinamp,WM_USER, 0, 124);
				int found = 0;
				int orig_pos = m_playlist_pos;
				int inc = (wParam>='A' && wParam<='Z') ? -1 : 1;
				while (1)
				{
					if (inc==1 && m_playlist_pos >= nSongs-1)
						break;
					if (inc==-1 && m_playlist_pos <= 0)
						break;

					m_playlist_pos += inc;

					char buf[32];
					strncpy(buf, (char*)SendMessage(m_hWndWinamp, WM_USER, m_playlist_pos, 212), 31);
					buf[31] = 0;

					// remove song # and period from beginning
					char *p = buf;
					while (*p >= '0' && *p <= '9') p++;
					if (*p == '.' && *(p+1) == ' ')
					{
						p += 2;
						int pos = 0;
						while (*p != 0)
						{
							buf[pos++] = *p;
							p++;
						}
						buf[pos++] = 0;
					}

					int wParam2 = (wParam>='A' && wParam<='Z') ? (wParam + 'a'-'A') : (wParam + 'A'-'a');
					if (buf[0]==wParam || buf[0]==wParam2)
					{
						found = 1;
						break;
					}
				}

				if (!found)
					m_playlist_pos = orig_pos;
			}
			return 0;
			}
		}

		// then allow the plugin to override any keys:
		if (MyWindowProc(hWnd, uMsg, wParam, lParam) == 0)
			return 0;

		// finally, default key actions:
		if (wParam == keyMappings[5] || wParam == keyMappings[6])	// 'z' or 'Z'
		{
			PostMessage(m_hWndWinamp,WM_COMMAND,40044,0);
			return 0;
		}
		else
			{
			switch (wParam)
			{
				// WINAMP PLAYBACK CONTROL KEYS:
			case 'x':
			case 'X':
				PostMessage(m_hWndWinamp,WM_COMMAND,40045,0);
				return 0;
			case 'c':
			case 'C':
				PostMessage(m_hWndWinamp,WM_COMMAND,40046,0);
				return 0;
			case 'v':
			case 'V':
				PostMessage(m_hWndWinamp,WM_COMMAND,40047,0);
				return 0;
			case 'b':
			case 'B':
				PostMessage(m_hWndWinamp,WM_COMMAND,40048,0);
				return 0;
			case 's':
			case 'S':
				//if (SendMessage(m_hWndWinamp,WM_USER,0,250))
				//    sprintf(m_szUserMessage, "shuffle is now OFF");    // shuffle was on
				//else
				//    sprintf(m_szUserMessage, "shuffle is now ON");    // shuffle was off

				// toggle shuffle
				PostMessage(m_hWndWinamp,WM_COMMAND,40023,0);
				return 0;
			case 'r':
			case 'R':
				// toggle repeat
				PostMessage(m_hWndWinamp,WM_COMMAND,40022,0);
				return 0;
			case 'p':
			case 'P':
				TogglePlaylist();
				return 0;
			case 'l':
				// note that this is actually correct; when you hit 'l' from the
				// MAIN winamp window, you get an "open files" dialog; when you hit
				// 'l' from the playlist editor, you get an "add files to playlist" dialog.
				// (that sends IDC_PLAYLIST_ADDMP3==1032 to the playlist, which we can't
				//  do from here.)
				PostMessage(m_hWndWinamp,WM_COMMAND,40029,0);
				return 0;
			case 'L':
				PostMessage(m_hWndWinamp,WM_COMMAND,40187,0);
				return 0;
			case 'j':
				PostMessage(m_hWndWinamp,WM_COMMAND,40194,0);
				return 0;
			}

			return 0;//DefWindowProc(hWnd,uMsg,wParam,lParam);
		}
		break;  // end case WM_CHAR

	case WM_KEYUP:

		// allow the plugin to override any keys:
		if (MyWindowProc(hWnd, uMsg, wParam, lParam) == 0)
			return 0;

		/*
		switch(wParam)
		{
		case VK_SOMETHING:
		    ...
		    break;
		}
		*/

		return 0;
		break;

	case WM_KEYDOWN:
		if (m_show_playlist)
		{
			switch (wParam)
			{
			case VK_ESCAPE:
				if(m_show_playlist)
					TogglePlaylist();
				//m_show_playlist = 0;
				return 0;

			case VK_UP:
			{
				int nRepeat = lParam & 0xFFFF;
				if (GetKeyState(VK_SHIFT) & mask)
					m_playlist_pos -= 10*nRepeat;
				else
					m_playlist_pos -= nRepeat;
			}
			return 0;

			case VK_DOWN:
			{
				int nRepeat = lParam & 0xFFFF;
				if (GetKeyState(VK_SHIFT) & mask)
					m_playlist_pos += 10*nRepeat;
				else
					m_playlist_pos += nRepeat;
			}
			return 0;

			case VK_HOME:
				m_playlist_pos = 0;
				return 0;

			case VK_END:
				m_playlist_pos = SendMessage(m_hWndWinamp,WM_USER, 0, 124) - 1;
				return 0;

			case VK_PRIOR:
				if (GetKeyState(VK_SHIFT) & mask)
					m_playlist_pageups += 10;
				else
					m_playlist_pageups++;
				return 0;

			case VK_NEXT:
				if (GetKeyState(VK_SHIFT) & mask)
					m_playlist_pageups -= 10;
				else
					m_playlist_pageups--;
				return 0;

			case VK_RETURN:
				SendMessage(m_hWndWinamp,WM_USER, m_playlist_pos, 121);	// set sel
				SendMessage(m_hWndWinamp,WM_COMMAND, 40045, 0);	// play it
				return 0;
			}
		}

		// allow the plugin to override any keys:
		if (MyWindowProc(hWnd, uMsg, wParam, lParam) == 0)
			return 0;

		switch (wParam)
		{
		case VK_F1:
			m_show_press_f1_msg = 0;
			ToggleHelp();
			return 0;

		case VK_ESCAPE:
			if (m_show_help)
				ToggleHelp();
			else
			{
				if (m_screenmode == FAKE_FULLSCREEN || m_screenmode == FULLSCREEN)
				{
					ToggleFullScreen();
				}
				else if (m_screenmode == DESKTOP)
				{
					ToggleDesktop();
				}
				// exit the program on escape
				//m_exiting = 1;
				//PostMessage(hWnd, WM_CLOSE, 0, 0);
			}
			return 0;

		case VK_UP:
			// increase volume
		{
			int nRepeat = lParam & 0xFFFF;
			for (i=0; i<nRepeat*2; i++) PostMessage(m_hWndWinamp,WM_COMMAND,40058,0);
		}
		return 0;

		case VK_DOWN:
			// decrease volume
		{
			int nRepeat = lParam & 0xFFFF;
			for (i=0; i<nRepeat*2; i++) PostMessage(m_hWndWinamp,WM_COMMAND,40059,0);
		}
		return 0;

		case VK_LEFT:
		case VK_RIGHT:
		{
			bool bShiftHeldDown = (GetKeyState(VK_SHIFT) & mask) != 0;
			int cmd = (wParam == VK_LEFT) ? 40144 : 40148;
			int nRepeat = lParam & 0xFFFF;
			int reps = (bShiftHeldDown) ? 6*nRepeat : 1*nRepeat;

			for (int i=0; i<reps; i++)
				PostMessage(m_hWndWinamp,WM_COMMAND,cmd,0);
		}
		return 0;
		default:
			// pass CTRL+A thru CTRL+Z, and also CTRL+TAB, to winamp, *if we're in windowed mode* and using an embedded window.
			// be careful though; uppercase chars come both here AND to WM_CHAR handler,
			//   so we have to eat some of them here, to avoid them from acting twice.
			if (m_screenmode==WINDOWED && m_lpDX && m_lpDX->m_current_mode.m_skin)
			{
				if (bCtrlHeldDown && ((wParam >= 'A' && wParam <= 'Z') || wParam==VK_TAB))
				{
					PostMessage(m_hWndWinamp, uMsg, wParam, lParam);
					return 0;
				}
			}
			return 0;
		}

		return 0;
		break;
	}

	return MyWindowProc(hWnd, uMsg, wParam, lParam);//DefWindowProc(hWnd, uMsg, wParam, lParam);
	//return 0L;
}

LRESULT CALLBACK CPluginShell::DesktopWndProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
    CPluginShell* p = (CPluginShell*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
	if (p)
		return p->PluginShellDesktopWndProc(hWnd, uMsg, wParam, lParam);
	else
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

LRESULT CPluginShell::PluginShellDesktopWndProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
	//#ifdef _DEBUG
	//    OutputDebugMessage("kbfocus", hWnd, uMsg, wParam, lParam);
	//#endif

	switch (uMsg)
	{
	case WM_KEYDOWN:
	case WM_KEYUP:
	case WM_CHAR:
	case WM_SYSCHAR:
	case WM_SYSKEYDOWN:
	case WM_SYSKEYUP:
		//PostMessage(GetPluginWindow(), uMsg, wParam, lParam);
		PluginShellWindowProc(GetPluginWindow(), uMsg, wParam, lParam);
		return 0;
		break;
	}

	return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

void CPluginShell::AlignWaves()
{
	// align waves, using recursive (mipmap-style) least-error matching
	// note: NUM_WAVEFORM_SAMPLES must be between 32 and 576.

	int align_offset[2] = { 0, 0 };

#if (NUM_WAVEFORM_SAMPLES < 576) // [don't let this code bloat our DLL size if it's not going to be used]

	int nSamples = NUM_WAVEFORM_SAMPLES;

#define MAX_OCTAVES 10

	int octaves = (int)floorf(logf((float)(576-nSamples))/logf(2.0f));
	if (octaves < 4)
		return;
	if (octaves > MAX_OCTAVES)
		octaves = MAX_OCTAVES;

	for (int ch=0; ch<2; ch++)
	{
		// only worry about matching the lower 'nSamples' samples
		float temp_new[MAX_OCTAVES][576];
		float temp_old[MAX_OCTAVES][576];
		static float temp_weight[MAX_OCTAVES][576];
		static int   first_nonzero_weight[MAX_OCTAVES];
		static int   last_nonzero_weight[MAX_OCTAVES];
		int spls[MAX_OCTAVES];
		int space[MAX_OCTAVES];

		memcpy(temp_new[0], m_sound.fWaveform[ch], sizeof(float)*576);
		memcpy(temp_old[0], &m_oldwave[ch][m_prev_align_offset[ch]], sizeof(float)*nSamples);
		spls[0] = 576;
		space[0] = 576 - nSamples;

		// potential optimization: could reuse (instead of recompute) mip levels for m_oldwave[2][]?
		int octave = 0;
		for (octave=1; octave<octaves; octave++)
		{
			spls[octave] = spls[octave-1]/2;
			space[octave] = space[octave-1]/2;
			for (int n=0; n<spls[octave]; n++)
			{
				temp_new[octave][n] = 0.5f*(temp_new[octave-1][n*2] + temp_new[octave-1][n*2+1]);
				temp_old[octave][n] = 0.5f*(temp_old[octave-1][n*2] + temp_old[octave-1][n*2+1]);
			}
		}

		if (!m_align_weights_ready)
		{
			m_align_weights_ready = 1;
			for (octave=0; octave<octaves; octave++)
			{
				int compare_samples = spls[octave] - space[octave];
				int n = 0;
				for (n=0; n<compare_samples; n++)
				{
					// start with pyramid-shaped pdf, from 0..1..0
					if (n < compare_samples/2)
						temp_weight[octave][n] = n*2/(float)compare_samples;
					else
						temp_weight[octave][n] = (compare_samples-1 - n)*2/(float)compare_samples;

					// TWEAK how much the center matters, vs. the edges:
					temp_weight[octave][n] = (temp_weight[octave][n] - 0.8f)*5.0f + 0.8f;

					// clip:
					if (temp_weight[octave][n]>1) temp_weight[octave][n] = 1;
					if (temp_weight[octave][n]<0) temp_weight[octave][n] = 0;
				}

				n = 0;
				while (temp_weight[octave][n] == 0 && n < compare_samples)
					n++;
				first_nonzero_weight[octave] = n;

				n = compare_samples-1;
				while (temp_weight[octave][n] == 0 && n >= 0)
					n--;
				last_nonzero_weight[octave] = n;
			}
		}

		int n1 = 0;
		int n2 = space[octaves-1];
		for (octave = octaves-1; octave>=0; octave--)
		{
			// for example:
			//  space[octave] == 4
			//  spls[octave] == 36
			//  (so we test 32 samples, w/4 offsets)
			int compare_samples = spls[octave]-space[octave];

			int lowest_err_offset = -1;
			float lowest_err_amount = 0;
			for (int n=n1; n<n2; n++)
			{
				float err_sum = 0;
				//for (int i=0; i<compare_samples; i++)
				for (int i=first_nonzero_weight[octave]; i<=last_nonzero_weight[octave]; i++)
				{
					float x = (temp_new[octave][i+n] - temp_old[octave][i]) * temp_weight[octave][i];
					if (x>0)
						err_sum += x;
					else
						err_sum -= x;
				}

				if (lowest_err_offset == -1 || err_sum < lowest_err_amount)
				{
					lowest_err_offset = n;
					lowest_err_amount = err_sum;
				}
			}

			// now use 'lowest_err_offset' to guide bounds of search in next octave:
			//  space[octave] == 8
			//  spls[octave] == 72
			//     -say 'lowest_err_offset' was 2
			//     -that corresponds to samples 4 & 5 of the next octave
			//     -also, expand about this by 2 samples?  YES.
			//  (so we'd test 64 samples, w/8->4 offsets)
			if (octave > 0)
			{
				n1 = lowest_err_offset*2  -1;
				n2 = lowest_err_offset*2+2+1;
				if (n1 < 0) n1=0;
				if (n2 > space[octave-1]) n2 = space[octave-1];
			}
			else
				align_offset[ch] = lowest_err_offset;
		}
	}
#endif
	memcpy(m_oldwave[0], m_sound.fWaveform[0], sizeof(float)*576);
	memcpy(m_oldwave[1], m_sound.fWaveform[1], sizeof(float)*576);
	m_prev_align_offset[0] = align_offset[0];
	m_prev_align_offset[1] = align_offset[1];

	// finally, apply the results: modify m_sound.fWaveform[2][0..576]
	// by scooting the aligned samples so that they start at m_sound.fWaveform[2][0].
	for (int ch=0; ch<2; ch++)
		if (align_offset[ch]>0)
		{
			for (int i=0; i<nSamples; i++)
				m_sound.fWaveform[ch][i] = m_sound.fWaveform[ch][i+align_offset[ch]];
			// zero the rest out, so it's visually evident that these samples are now bogus:
			memset(&m_sound.fWaveform[ch][nSamples], 0, (576-nSamples)*sizeof(float));
		}
}

LRESULT CALLBACK CPluginShell::VJModeWndProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
  CPluginShell* p = (CPluginShell*)GetWindowLongPtr(hWnd,GWLP_USERDATA);
	if (p)
		return p->PluginShellVJModeWndProc(hWnd, uMsg, wParam, lParam);
	else
		return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

LRESULT CPluginShell::PluginShellVJModeWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
#ifdef _DEBUG
	if (message != WM_MOUSEMOVE &&
	    message != WM_NCHITTEST &&
	    message != WM_SETCURSOR &&
	    message != WM_COPYDATA &&
	    message != WM_USER)
	{
		char caption[256] = "VJWndProc: frame 0, ";
		if (m_frame > 0)
		{
			float time = m_time;
			int hours = (int)(time/3600);
			time -= hours*3600;
			int minutes = (int)(time/60);
			time -= minutes*60;
			int seconds = (int)time;
			time -= seconds;
			int dsec = (int)(time*100);
			sprintf(caption, "VJWndProc: frame %d, t=%dh:%02dm:%02d.%02ds, ", m_frame, hours, minutes, seconds, dsec);
		}
		OutputDebugMessage(caption, hwnd, message, wParam, lParam);
	}
#endif

	switch (message)
	{
	case WM_KEYDOWN:
	case WM_KEYUP:
	case WM_CHAR:
	case WM_SYSKEYDOWN:
	case WM_SYSKEYUP:
	case WM_SYSCHAR:
		// pass keystrokes on to plugin!
		return PluginShellWindowProc(GetPluginWindow(),message,wParam,lParam);

	case WM_ERASEBKGND:
		// Repaint window when song is paused and image needs to be repainted:
		if (SendMessage(m_hWndWinamp,WM_USER,0,104)!=1 && m_vjd3d9_device && GetFrame() > 0)    // WM_USER/104 return codes: 1=playing, 3=paused, other=stopped
		{
			m_vjd3d9_device->Present(NULL,NULL,NULL,NULL);
			return 0;
		}
		break;

		/*
		case WM_WINDOWPOSCHANGING:
		if (m_screenmode == DESKTOP)
		{
		    LPWINDOWPOS pwp = (LPWINDOWPOS)lParam;
		    if (pwp)
		        pwp->flags |= SWP_NOOWNERZORDER | SWP_NOZORDER;
		}
		break;

		case WM_ACTIVATEAPP:
		// *Very Important Handler!*
		//    -Without this code, the app would not work properly when running in true
		//     fullscreen mode on multiple monitors; it would auto-minimize whenever the
		//     user clicked on a window in another display.
		if (wParam == 1 &&
		    m_screenmode == DESKTOP &&
		    m_frame > 0 &&
		    !m_exiting
		   )
		{
		    return 0;
		}
		break;

		/*
		case WM_NCACTIVATE:
		// *Very Important Handler!*
		//    -Without this code, the app would not work properly when running in true
		//     fullscreen mode on multiple monitors; it would auto-minimize whenever the
		//     user clicked on a window in another display.
		// (NOTE: main window also handles this message this way)
		if (wParam == 0 &&
		    m_screenmode == FULLSCREEN &&
		    m_frame > 0 &&
		    !m_exiting &&
		    m_lpDX &&
		    m_lpDX->m_ready
		    && m_lpDX->m_lpD3D &&
		    m_lpDX->m_lpD3D->GetAdapterCount() > 1
		    )
		{
		    return 0;
		}
		break;
		*/

		/*
		case WM_ACTIVATEAPP:
		if (wParam == 1 &&
		    m_screenmode == DESKTOP &&
		    m_frame > 0 &&
		    !m_exiting &&
		    m_vjd3d9_device
		   )
		{
		    return 0;
		}
		break;
		*/

		/*
		case WM_WINDOWPOSCHANGING:
		if (
		    m_screenmode == DESKTOP
		    && (!m_force_accept_WM_WINDOWPOSCHANGING)
		    && m_lpDX && m_lpDX->m_ready
		   )
		{
		    // unless we requested it ourselves or it's init time,
		    // prevent the fake desktop window from moving around
		    // in the Z order!  (i.e., keep it on the bottom)
		    
		    // without this code, when you click on the 'real' desktop
		    // in a multimon setup, any windows that are overtop of the
		    // 'fake' desktop will flash, since they'll be covered
		    // up by the fake desktop window (but then shown again on
		    // the next frame, when we detect that the fake desktop
		    // window isn't on bottom & send it back to the bottom).

		    LPWINDOWPOS pwp = (LPWINDOWPOS)lParam;
		    if (pwp)
		        pwp->flags |= SWP_NOOWNERZORDER | SWP_NOZORDER;
		}
		break;
		*/

	case WM_CLOSE:
		// if they close the VJ window (by some means other than ESC key),
		// this will make the graphics window close, too.
		m_exiting = 1;
		if (GetPluginWindow())
			PostMessage(GetPluginWindow(), WM_CLOSE, 0, 0);
		break;

	case WM_GETMINMAXINFO:
	{
		// don't let the window get too small
		MINMAXINFO* p = (MINMAXINFO*)lParam;
		if (p->ptMinTrackSize.x < 64)
			p->ptMinTrackSize.x = 64;
		p->ptMinTrackSize.y = p->ptMinTrackSize.x*3/4;
	}
	return 0;

	case WM_SIZE:
		// clear or set activity flag to reflect focus
		if (m_vjd3d9_device && !m_resizing_textwnd)
		{
			m_hidden_textwnd = (SIZE_MAXHIDE==wParam || SIZE_MINIMIZED==wParam) ? TRUE : FALSE;

			if (SIZE_MAXIMIZED==wParam || SIZE_RESTORED==wParam) // the window has been maximized or restored
				OnUserResizeTextWindow();
		}
		break;

	case WM_ENTERSIZEMOVE:
		m_resizing_textwnd = 1;
		break;

	case WM_EXITSIZEMOVE:
		if (m_vjd3d9_device)
			OnUserResizeTextWindow();
		m_resizing_textwnd = 0;
		break;
	}

	return DefWindowProc(hwnd, message, wParam, lParam);
}