Merge pull request #5 from WinampDesktop/community

Merge to main

1 files changed, 5804 insertions, 0 deletions

diff --git a/Src/Plugins/DSP/dsp_sc/main.cpp b/Src/Plugins/DSP/dsp_sc/main.cpp
new file mode 100644
index 00000000..8a3236c1
--- /dev/null
+++ b/Src/Plugins/DSP/dsp_sc/main.cpp
@@ -0,0 +1,5804 @@
+// These are disabled for now they have unknown issues.
+//#define USE_OGG
+//#define CAPTURE_TESTING
+
+// TODO / BE NICE FOR FUTURE VERSIONS
+// 1) Fix capture issues on Vista / Windows 7
+// 2) Allow metadata to be specified from file
+// 3) Move over to using enc_lame (and ui changes for it) [partial]
+
+#define APP_Name "Shoutcast Source"
+#define APP_Version "2.4.2"
+#define APP_VersionW L"2.4.2"
+#define APP_Build "449"
+
+#include <windows.h>
+#include <commctrl.h>
+#include <stdio.h>
+#include <shlobj.h>
+#include <shellapi.h>
+#include <shlwapi.h>
+#include <commdlg.h>
+#include <math.h>
+#include <mmdeviceapi.h>
+#include <audioclient.h>
+#include <endpointvolume.h>
+#include <functiondiscoverykeys.h>
+#ifdef CAPTURE_TESTING
+#include "Wasapi/WASAPICapture.h"
+#endif
+#include "resource/resource.h"
+#include "sc2srclib/include/shoutcast_output.h"
+#include "sc2srclib/encoders/c_encoder_mp3dll.h"
+#include "sc2srclib/encoders/c_encoder_nsv.h"
+#include "sc2srclib/encoders/c_encoder_fhgaac.h"
+#include "sc2srclib/encoders/c_encoder_aacp.h"
+#ifdef USE_OGG
+#include "sc2srclib/Encoders/c_encoder_ogg.h"
+#endif
+// allows us to compile with the Wasabi sdk without having to change things
+//#define __WASABI_TYPES_H
+//#define _GUID_H
+//typedef unsigned long ARGB32;
+//static const GUID INVALID_GUID = { 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0} };
+#include "api.h"
+#include "include/c_wavein.h"
+#include "crossfader/c_crossfader.h"
+#include <winamp/wa_ipc.h>
+#include <winamp/dsp.h>
+#include "nu/servicebuilder.h"
+#include "utils.h"
+#ifdef CAPTURE_TESTING
+#include "wasapi/player.h"
+#endif
+#include <strsafe.h>
+
+#define NUM_OUTPUTS		5
+#define NUM_ENCODERS	NUM_OUTPUTS
+#define NUM_BUFFERS		3
+#define MAX_TABWNDS		4
+#define MAX_COLS		6
+#define MAX_CELLS		12
+#define MAX_INWNDS		2
+#define MAX_OUTWNDS		6
+#define SYSTRAY_BASE_ICON	1024
+#define SYSTRAY_ICY_ICON	1
+#define SYSTRAY_BASE_MSG	WM_USER
+#define SYSTRAY_MAXIMIZE_MSG	27
+#define DEFAULT_INPUTDEVICE	0 // winamp
+
+#define DOWNLOAD_URL L"http://www.shoutcast.com/BroadcastNow"
+// 404, change to one of these?
+// #define DOWNLOAD_URL L"http://wiki.shoutcast.com/wiki/Source_DSP_Plug-in"
+// #define DOWNLOAD_URL L"http://www.shoutcast.com"
+
+char sourceVersion[64] = {APP_Version "." APP_Build};
+static char szDescription[256];
+static char szDescription2[256];
+static wchar_t szDescription2W[256];
+
+#ifdef CAPTURE_TESTING
+static Player *pPlayer = NULL;
+
+//
+// The Player object calls the methods in this class to
+// notify the application when certain audio events occur.
+//
+class CPlayerCallbacks : public PlayerCallbacks
+{
+    // Notification callback for volume change. Typically, the user
+    // adjusts the volume through the SndVol.exe application.
+    void VolumeChangeCallback(float volume, BOOL mute)
+    {
+        /*EnableWindowDlgItem(g_hDlg, IDC_SLIDER_VOLUME, TRUE);
+        SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_MUTE),
+                      (mute == TRUE) ? L"Mute" : L"");
+        PostMessage(GetDlgItem(g_hDlg, IDC_SLIDER_VOLUME),
+                    TBM_SETPOS, TRUE, LPARAM(volume*MAX_VOLUME_LEVEL));*/
+    };
+
+    // Notification callback for when stream stops playing unexpectedly
+    // (typically, because the player reached the end of a wave file).
+    void PlayerStopCallback(void)
+    {
+        /*SetActiveWindow(g_hDlg);
+        PostMessage(GetDlgItem(g_hDlg, IDC_BUTTON_STOP), BM_CLICK, 0, 0);*/
+    };
+
+    // Notification callback for when the endpoint capture device is
+    // disconnected (for example, the user pulls out the microphone plug).
+    void CaptureDisconnectCallback(void)
+    {
+        /*SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_LASTACTION),
+                      L"Capture device disconnected!");
+        SendMessage(GetDlgItem(g_hDlg, IDC_COMBO_CAPTUREDEVICE), CB_RESETCONTENT, 0, 0);*/
+    };
+
+    // Notification callback for when the endpoint rendering device is
+    // disconnected (for example, the user pulls out the headphones plug).
+    void RenderDisconnectCallback(void)
+    {
+        /*SetWindowText(GetDlgItem(g_hDlg, IDC_STATIC_LASTACTION),
+                      L"Playback device disconnected!");
+        EnableWindowDlgItem(g_hDlg, IDC_SLIDER_VOLUME, FALSE);
+        SetWindowTextW(GetDlgItem(g_hDlg, IDC_STATIC_MUTE), L"Disconnected");
+        SendMessage(GetDlgItem(g_hDlg, IDC_COMBO_RENDERDEVICE), CB_RESETCONTENT, 0, 0);
+        SendMessage(GetDlgItem(g_hDlg, IDC_SLIDER_VOLUME), TBM_SETPOS, TRUE, 0);*/
+    };
+};
+
+
+static CPlayerCallbacks *pCallbacks = NULL;
+#endif
+
+// this is used to help determine if we're running on an older
+// version of Winamp where jnetlib has issues with the re-use
+// of connection handles when the connection previously failed
+int iscompatibility = 0;
+// used for the about page link so we don't cause win2k issues
+int isthemethere = 0;
+// Wasabi based services for localisation support
+api_service *WASABI_API_SVC = 0;
+api_config *AGAVE_API_CONFIG = 0;
+api_language *WASABI_API_LNG = 0;
+api_queue *WASABI_API_QUEUEMGR = 0;
+api_albumart *AGAVE_API_ALBUMART = 0;
+api_memmgr *WASABI_API_MEMMGR = 0;
+api_explorerfindfile* WASABI_API_EXPLORERFINDFILE = 0;
+api_downloadManager *WAC_API_DOWNLOADMANAGER = 0;
+
+// these two must be declared as they're used by the language api's
+// when the system is comparing/loading the different resources
+HINSTANCE WASABI_API_LNG_HINST = 0,
+		  WASABI_API_ORIG_HINST = 0;
+HFONT boldFont = 0, normalFont = 0;
+HICON icy = 0, wa_icy = 0;
+static HHOOK nowPlayingHook,
+			 nowPlayingHook2;
+static LPARAM nowPlayingID = -1;
+// just using these to track the paused and playing states
+int was_paused = 0,
+	was_playing = 0;
+DWORD play_duration = 0,
+	  play_diff = 0;
+int isplaying = -1, ptt_load = 0;
+static wchar_t lastFile[MAX_PATH];
+int lastFilterIndex = 4;
+static int lastSec[NUM_OUTPUTS],
+		   lastMode[NUM_OUTPUTS] = {-1, -1, -1, -1, -1},
+		   lastEnable[NUM_OUTPUTS];
+
+static HWND buttonWnd[ NUM_OUTPUTS ];
+static HWND tabWnd;
+static HWND outTabWnd;
+static HWND updateWnd;
+
+static ARGB32 *playingImage;
+static ARGB32 *streamImage[NUM_OUTPUTS] = {(ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1, (ARGB32 *)-1};
+static int playingImage_w, playingImage_h, playingLength, playingType;
+static int streamLength[NUM_OUTPUTS];
+static bool secChanged[NUM_OUTPUTS];
+void Config(struct winampDSPModule *this_mod);
+int Init(struct winampDSPModule *this_mod);
+int ModifySamples(struct winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate);
+void Quit(struct winampDSPModule *this_mod);
+int secureFunc(int key){
+	int res = key * (unsigned long)1103515245;
+	res += (unsigned long)13293;
+	res &= (unsigned long)0x7FFFFFFF;
+	res ^= key;
+	return res;
+}
+winampDSPModule *getModule(int which);
+winampDSPModule module = {
+	"nullsoft(dsp_sc.dll)",
+	NULL,
+	NULL,
+	Config,
+	Init,
+	ModifySamples,
+	Quit,
+	NULL
+};
+
+winampDSPHeader header = {
+	DSP_HDRVER+1,
+	"Nullsoft " APP_Name " DSP " APP_Version,
+	getModule,
+	secureFunc
+};
+
+
+static ARGB32 * writeImg(const ARGB32 *data, int w, int h, int *length, const wchar_t *ext) {
+	if (!ext || ext && !*ext) return NULL;
+	if (*ext == L'.') ext++;
+	FOURCC imgwrite = svc_imageWriter::getServiceType();
+	int n = WASABI_API_SVC->service_getNumServices(imgwrite);
+	for (int i=0; i<n; i++) {
+		waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgwrite,i);
+		if (sf) {
+			svc_imageWriter * l = (svc_imageWriter*)sf->getInterface();
+			if (l) {
+				if (wcsstr(l->getExtensions(),ext)) {
+					void* ret = l->convert(data, 32, w, h, length);
+					sf->releaseInterface(l);
+					return (ARGB32 *)ret;
+				}
+				sf->releaseInterface(l);
+			}
+		}
+	}
+	return NULL;
+}
+
+HICON GetICYIcon(bool winamp = false) {
+	if (!winamp) {
+		if (!icy) {
+			icy = (HICON)LoadImage(WASABI_API_ORIG_HINST?WASABI_API_ORIG_HINST:module.hDllInstance,
+								   MAKEINTRESOURCE(IDI_ICY), IMAGE_ICON, 0, 0,
+								   LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION);
+		}
+		return icy;
+	} else {
+		if (!wa_icy) {
+			wa_icy = (HICON)LoadImage(GetModuleHandle("winamp.exe"),
+									  MAKEINTRESOURCE(102), IMAGE_ICON, 0, 0,
+									  LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION);
+		}
+		return (wa_icy ? wa_icy : icy);
+	}
+}
+
+BOOL InitLocalisation(HWND winamp) {
+	// if this is valid then we should be running on Winamp 5.5+ so try to get the localisation api
+	if (IsWindow(winamp)) {
+		iscompatibility = 1; ////// SendMessage( winamp, WM_WA_IPC, 0, IPC_IS_COMPATIBILITY_ENABLED );
+		isthemethere = !SendMessage(winamp, WM_WA_IPC, IPC_ISWINTHEMEPRESENT, IPC_USE_UXTHEME_FUNC);
+		if (!WASABI_API_LNG_HINST) {
+			// loader so that we can get the localisation service api for use
+			WASABI_API_SVC = (api_service*)SendMessage(winamp, WM_WA_IPC, 0, IPC_GET_API_SERVICE);
+			if (WASABI_API_SVC == (api_service*)1) {
+				WASABI_API_SVC = NULL;
+				return FALSE;
+			}
+
+			// initialise all of the wasabi based services
+			ServiceBuild(WASABI_API_SVC, AGAVE_API_CONFIG, AgaveConfigGUID);
+			ServiceBuild(WASABI_API_SVC, WASABI_API_LNG, languageApiGUID);
+			ServiceBuild(WASABI_API_SVC, WASABI_API_MEMMGR, memMgrApiServiceGuid);
+			ServiceBuild(WASABI_API_SVC, AGAVE_API_ALBUMART, albumArtGUID);
+			ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
+			ServiceBuild(WASABI_API_SVC, WASABI_API_EXPLORERFINDFILE, ExplorerFindFileApiGUID);
+			ServiceBuild(WASABI_API_SVC, WAC_API_DOWNLOADMANAGER, DownloadManagerGUID);
+
+			// need to have this initialised before we try to do anything with localisation features
+			WASABI_API_START_LANG(GetMyInstance(), DspShoutcastLangGUID);
+
+			// do this here so if there is no localisation support then the module names go to defaults
+			if (!szDescription[0]) {
+				StringCchPrintfA(szDescription, ARRAYSIZE(szDescription), LocalisedStringA(IDS_PLUGIN_NAME, NULL, 0), APP_Version);
+				header.description = szDescription;
+			}
+
+			if (!szDescription2[0]) {
+				module.description = LocalisedStringA(IDS_MODULE_NAME, szDescription2, 256);
+				LocalisedString(IDS_MODULE_NAME, szDescription2W, 256);
+			}
+		}
+		return TRUE;
+	}
+	return FALSE;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	__declspec(dllexport) winampDSPHeader *winampDSPGetHeader2(HWND hwndParent) {
+		if (InitLocalisation(hwndParent)) {
+			return &header;
+		}
+		MessageBoxA(module.hwndParent,
+					"You are attempting to use the " APP_Name " plug-in in an\n"
+					"unsupported version of Winamp or in a non-Winamp install or via a\n"
+					"DSP stacker which does not implement the Winamp 5.5+ DSP api.\n\n"
+					"To work this plug-in requires Winamp 5.5 and higher (the most current\n"
+					"release is recommended) or for the non-Winamp install or DSP stacker\n"
+					"to be updated to support the required Winamp api's the plug-in uses.",
+					"Nullsoft " APP_Name, MB_ICONEXCLAMATION|MB_APPLMODAL);
+		return 0;
+	}
+
+	__declspec(dllexport) int winampUninstallPlugin(HINSTANCE hDllInst, HWND hwndDlg, int param) {
+		// this isn't ideal but it ensures that we show a localised version of the message
+		// if not it'll make sure that we're using the plug-in dll's internal resources
+		// though for ease of code handling we have to fill in some of the dsp structures
+		// as the plug-in has effectively been unloaded at this stage for the uninstall.
+		HWND winamp = GetWinampHWND(0);
+		module.hDllInstance = hDllInst;
+		module.hwndParent = winamp;
+		InitLocalisation(winamp);
+
+		wchar_t title[256] = {0};
+		StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_Version);
+
+		// prompt to remove the settings files (defaults to no just incase)
+		if (MessageBoxW(hwndDlg, LocalisedString(IDS_PLUGIN_UNINSTALL, NULL, 0), title, MB_YESNO|MB_DEFBUTTON2) == IDYES) {
+			DeleteFile(GetSCIniFile(winamp));
+		}
+		return DSP_PLUGIN_UNINSTALL_NOW;
+	}
+
+#ifdef __cplusplus
+}
+#endif
+
+winampDSPModule *getModule(int which) {
+	if (which == 0) return &module;
+	return NULL;
+}
+// Client's proprietary event-context GUID
+//extern GUID g_guidMyContext;
+
+// Maximum volume level on trackbar
+#define MAX_VOL  100
+
+#define SAFE_RELEASE(what)  \
+	if ((what) != NULL)  \
+{ (what)->Release(); (what) = NULL; }
+
+//GUID g_guidMyContext = GUID_NULL;
+
+static IAudioStreamVolume *g_pStreamVol = NULL;
+static IAudioEndpointVolume *g_pEndptVol = NULL;
+static IAudioClient *g_pAudioClient = NULL;
+static IAudioCaptureClient *g_pCaptureClient = NULL;
+
+/*#define EXIT_ON_ERROR(hr)  \
+	if (FAILED(hr)) { goto Exit; }
+#define ERROR_CANCEL(hr)  \
+	if (FAILED(hr)) {  \
+	MessageBox(hDlg, TEXT("The program will exit."),  \
+	TEXT("Fatal error"), MB_OK);  \
+	EndDialog(hDlg, TRUE); return TRUE; }*/
+
+HANDLE cf_mutex = NULL;
+C_CROSSFADER *Crossfader = NULL;
+int CrossfadeLen = 5000;
+unsigned int Input_Device_ID=0;
+int Restore_PTT = 0;
+unsigned int numInputs=0;
+char updateStr[16] = {0};
+
+typedef struct	{
+	// BladeEnc DLL Version number
+	BYTE byDLLMajorVersion;
+	BYTE byDLLMinorVersion;
+	// BladeEnc Engine Version Number
+	BYTE byMajorVersion;
+	BYTE byMinorVersion;
+	// DLL Release date
+	BYTE byDay;
+	BYTE byMonth;
+	WORD wYear;
+	// BladeEnc	Homepage URL
+	#define BE_MAX_HOMEPAGE 128
+	CHAR zHomepage[BE_MAX_HOMEPAGE + 1];
+	BYTE byAlphaLevel;
+	BYTE byBetaLevel;
+	BYTE byMMXEnabled;
+	BYTE btReserved[125];
+} BE_VERSION, *PBE_VERSION;
+typedef VOID (*BEVERSION)(PBE_VERSION);
+BEVERSION beVersion = NULL;
+void *init = NULL;
+void *params = NULL;
+void *encode = NULL;
+void *finish = NULL;
+void *lameclose = NULL;
+
+int CALLBACK DialogFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
+HINSTANCE instance = NULL;
+HINSTANCE libinst = NULL;
+HWND hMainDLG = NULL;
+RECT mainrect;
+HWND inWin = NULL, inWinWa = NULL;
+
+struct T_TABWND {
+	HWND hWnd;
+	int id;
+	int timer_freq;
+	TCITEMW tcitem;
+} wnd[MAX_TABWNDS] = {0},
+  out_wnd[MAX_OUTWNDS] = {0};
+int num_tabwnds = 0,
+	num_outwnds = 0;
+
+struct T_COL {
+	LVCOLUMNW lvcol;
+	LVITEMW lvitem[MAX_CELLS];
+	int num_cells;
+} col[MAX_COLS] = {0};
+int num_cols = 0;
+
+struct T_INPUTWND{
+	HWND hWnd;
+	int id;
+	int timer_freq;
+} in_wnd[MAX_INWNDS] = {0};
+int num_inwnds = 0;
+
+// shoutcast source
+struct T_INPUT_CONFIG {
+	int srate;
+	int nch;
+};
+struct MY_T_OUTPUT {
+	T_OUTPUT_CONFIG Config;
+	int Encoder;	// encoder this config is used by
+	int Handle;		// handle that the encoder understands
+	int AutoTitle;
+	int AutoConnect;
+	int Logging;
+	int LogCOS;
+	int NextTitles;
+	int nextTrackLog;
+	int nextTrackLogXML;
+	wchar_t nextTrackPath[MAX_PATH];
+	int useArt;
+	int usePlayingArt;
+	int useStreamArt;
+	wchar_t stationArtPath[MAX_PATH];
+	int saveEncoded;
+	wchar_t saveEncodedPath[MAX_PATH];
+} Output[NUM_OUTPUTS] = {0};
+SHOUTCAST_OUTPUT Encoder[NUM_ENCODERS];
+HANDLE Enc_mutex[NUM_ENCODERS] = {0};
+int Enc_LastType[NUM_ENCODERS] = {0};
+C_WAVEIN<NUM_BUFFERS, 5120 > Soundcard;
+
+int last_buffer = 0;
+int Connection_CurSelPos = 0;
+int Encoder_CurSelPos = 0;
+int Input_CurSelPos = 3;
+int InputDevice = DEFAULT_INPUTDEVICE;
+clock_t audiolag = 0;
+clock_t lastaudio = 0;
+int curtab = 1;
+int curouttab = 0;
+int lookAhead = 3;
+bool skipMetada = false;
+bool doNextLookAhead = false;
+HANDLE hthread = NULL;
+DWORD threadid = 0;
+HANDLE hthreadout = NULL;
+DWORD threadoutid = 0;
+HWND hWinamp = NULL;
+int ini_modified = 0;
+HANDLE logFiles[NUM_OUTPUTS] = {INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE};
+
+struct T_VU {
+	int vu_l;
+	int vu_r;
+	int update;
+	int lastUpdate;
+} VU;
+int peak_vu_l = -90;
+int peak_vu_r = -90;
+
+T_INPUT_CONFIG InputConfig;
+int MusVol = 9;
+int Mus2Vol = 3;
+int MicVol = 9;
+int FadeTime = 20;
+int MicFadeTime = 10; // mimic old behaviour with a faster fade up/down of the capture device
+int devopts = 0;
+clock_t FadeStartTime;
+clock_t MicFadeStartTime;
+int FadeOut = 0;
+WNDPROC prevButtonProc = NULL,
+		prevListViewProc = NULL,
+		prevHeaderProc = NULL,
+		prevTabWndProc = NULL,
+		prevOutTabWndProc = NULL;
+int blockmousemove = 0;
+T_INPUT_CONFIG LineInputAttribs[]= {
+	{22050, 1},
+	{44100, 1},
+	{22050, 2},
+	{44100, 2},
+};
+
+void AddSystrayIcon(HWND hWnd, UINT uIconId, HICON hIcon, UINT uMsg, LPWSTR lpszToolTip) {
+	NOTIFYICONDATAW tnid = {0};
+	tnid.cbSize = sizeof (NOTIFYICONDATAW);
+	tnid.hWnd = hWnd;
+	tnid.uID = SYSTRAY_BASE_ICON + uIconId;
+	tnid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE;
+	tnid.uCallbackMessage = SYSTRAY_BASE_MSG + uMsg;
+	tnid.hIcon = hIcon;
+	wcsncpy(tnid.szTip, lpszToolTip, ARRAYSIZE(tnid.szTip));
+	Shell_NotifyIconW(NIM_ADD, &tnid);
+	return;
+}
+
+void RemoveSystrayIcon(HWND hWnd, UINT uIconId) {
+	NOTIFYICONDATAW tnid = {0};
+	tnid.cbSize = sizeof (NOTIFYICONDATAW);
+	tnid.hWnd = hWnd;
+	tnid.uID = SYSTRAY_BASE_ICON + uIconId;
+	Shell_NotifyIconW(NIM_DELETE, &tnid);
+	return;
+}
+
+void AddTab(int dialog_id, wchar_t *tab_name, HWND hWndParent, DLGPROC DlgProc, int tab_id, int rect_id, int timer_freq) {
+	RECT r = {0};
+	T_TABWND *twnd = &wnd[num_tabwnds];
+	GetWindowRect(GetDlgItem(hWndParent, rect_id), &r);
+	ScreenToClient(hWndParent, (POINT *) & r);
+	twnd->id = dialog_id;
+	twnd->timer_freq = timer_freq;
+	twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DlgProc, dialog_id);
+	ShowWindow(twnd->hWnd, SW_HIDE);
+	SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+	twnd->tcitem.mask = TCIF_TEXT;
+	twnd->tcitem.pszText = tab_name;
+	twnd->tcitem.cchTextMax = wcslen(tab_name);
+	SendDlgItemMessage(hWndParent, tab_id, TCM_INSERTITEMW, num_tabwnds++, (LPARAM)&twnd->tcitem);
+	if (IsWindow(twnd->hWnd) && isthemethere) {
+		SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
+	}
+}
+
+void SetTab(int tabnum, HWND hWndParent, int tab_id) {
+	NMHDR nmh;
+	nmh.code = TCN_SELCHANGE;
+	nmh.hwndFrom = GetDlgItem(hWndParent, tab_id);
+	nmh.idFrom = tab_id;
+	curtab = tabnum;
+	SendMessage(nmh.hwndFrom, TCM_SETCURSEL, curtab, 0);
+	SendMessage(hWndParent, WM_NOTIFY, tab_id, (LPARAM) & nmh);
+}
+
+void AddInTab(int dialog_id, wchar_t *tab_name, HWND hWndParent) {
+	RECT r = {0};
+	T_INPUTWND *twnd = &in_wnd[num_inwnds++];
+	GetWindowRect(GetDlgItem(hWndParent, IDC_PANEL_RECT), &r);
+	ScreenToClient(hWndParent, (POINT *)&r);
+	twnd->id = dialog_id;
+	twnd->timer_freq = 0;
+	twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DialogFunc, dialog_id);
+	ShowWindow(twnd->hWnd, SW_HIDE);
+	SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+	SendDlgItemMessageW(hWndParent, IDC_INPUTDEVICE, CB_ADDSTRING, 0, (LPARAM)tab_name);
+	if (IsWindow(twnd->hWnd) && isthemethere) {
+		SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
+	}
+}
+
+void SetInTab(int tabnum, HWND hWndParent, int combo_id) {
+	SendDlgItemMessage(hWndParent, combo_id, CB_SETCURSEL, tabnum, 0);
+	SendMessage(hWndParent, WM_COMMAND, MAKEWPARAM(combo_id, CBN_SELCHANGE), (LPARAM) GetDlgItem(hWndParent, combo_id));
+}
+
+void AddOutTab(int dialog_id, wchar_t *tab_name, HWND hWndParent, DLGPROC DlgProc, int tab_id, int rect_id, int timer_freq) {
+	RECT r = {0};
+	T_TABWND *twnd = &out_wnd[num_outwnds];
+	GetWindowRect(GetDlgItem(hWndParent, IDC_PANELRECT_C), &r);
+	ScreenToClient(hWndParent, (POINT *)&r);
+	twnd->id = dialog_id;
+	twnd->timer_freq = 0;
+	twnd->hWnd = LocalisedCreateDialog(instance, dialog_id, hWndParent, DlgProc, dialog_id);
+	ShowWindow(twnd->hWnd, SW_HIDE);
+	SetWindowPos(twnd->hWnd, NULL, r.left, r.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
+	twnd->tcitem.mask = TCIF_TEXT;
+	twnd->tcitem.pszText = tab_name;
+	twnd->tcitem.cchTextMax = wcslen(tab_name);
+	SendDlgItemMessageW(hWndParent, IDC_CONTAB, TCM_INSERTITEMW, num_outwnds++, (LPARAM) & twnd->tcitem);
+	if (IsWindow(twnd->hWnd) && isthemethere) {
+		SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)twnd->hWnd, IPC_USE_UXTHEME_FUNC);
+	}
+}
+
+void SetOutTab(int tabnum, HWND hWndParent, int tab_id) {
+	NMHDR nmh;
+	nmh.code = TCN_SELCHANGE;
+	nmh.hwndFrom = GetDlgItem(hWndParent, tab_id);
+	nmh.idFrom = tab_id;
+	curouttab = tabnum;
+	SendMessage(nmh.hwndFrom, TCM_SETCURSEL, curouttab, 0);
+	SendMessage(hWndParent, WM_NOTIFY, tab_id, (LPARAM) & nmh);
+}
+
+void AddColumn(wchar_t *column_text, HWND listView) {
+	T_COL *tcol = &col[num_cols];
+	tcol->lvcol.mask = LVCF_TEXT;
+	tcol->lvcol.pszText = column_text;
+	tcol->lvcol.cchTextMax = wcslen(column_text);
+	SendMessageW(listView, LVM_INSERTCOLUMNW, num_cols++, (LPARAM)&tcol->lvcol);
+}
+
+void AddColItem(wchar_t *cell_text, int colnum, HWND hWndParent, int list_id, int pos = -1) {
+	LVITEMW *tcell = &col[colnum].lvitem[col[colnum].num_cells];
+	tcell->mask = TVIF_TEXT;
+	tcell->iItem = pos == -1 ? col[colnum].num_cells++ : pos;
+	tcell->iSubItem = colnum;
+	tcell->pszText = cell_text;
+	tcell->cchTextMax = wcslen(cell_text);
+	SendDlgItemMessageW(hWndParent, list_id, pos == -1 && colnum == 0 ? LVM_INSERTITEMW : LVM_SETITEMW, 0, (LPARAM)tcell);
+}
+
+void __inline interleave_buffer(const short * inLeft, short *outputbuf, const size_t num_samples) {
+    for (size_t i = 0; i < num_samples; ++i) {
+        outputbuf[i * 2] = inLeft[i];
+        outputbuf[i * 2 + 1] = inLeft[i];
+    }
+}
+
+DWORD WINAPI ThreadInput(LPVOID lpParameter) {
+	do {
+		// this is needed when doing soundcard capture
+		if (InputDevice == 1) DialogFunc((HWND) lpParameter, WM_TIMER, MAKEWPARAM(1234,0), 0);
+		short mybuf[32768] = {0};
+		size_t mysamps = 0;
+
+		if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
+			if (Input_CurSelPos != -1) {
+				if (InputDevice == 0) {
+					if (isplaying != 1) {
+						// when stopped or paused, we need to pump silent output
+						// and from testing, sending 2 emtpy samples appears to
+						// keep the output bitrate about the same as playback's
+						mysamps = sizeof(mybuf)/8;
+					} else {
+						mysamps = Crossfader->get(mybuf, sizeof (mybuf) / (InputConfig.nch * sizeof (short)), InputConfig.nch) * InputConfig.nch;
+					}
+				} else {
+					int samps = (LineInputAttribs[Input_CurSelPos].nch * sizeof (short));
+					if(LineInputAttribs[Input_CurSelPos].nch == 1) {
+						mysamps = Crossfader->get(mybuf, (samps ? sizeof (mybuf) / samps : sizeof (mybuf)) / 2, LineInputAttribs[Input_CurSelPos].nch) * LineInputAttribs[Input_CurSelPos].nch;
+						short *newbuf = (short*) malloc(mysamps * 2 * sizeof(short));
+						interleave_buffer(mybuf, newbuf, mysamps);
+						mysamps *= 2;
+						memcpy(mybuf, newbuf, mysamps * sizeof (short));
+						free(newbuf);
+					} else {
+						mysamps = Crossfader->get(mybuf, (samps ? sizeof (mybuf) / samps : sizeof (mybuf)), LineInputAttribs[Input_CurSelPos].nch) * LineInputAttribs[Input_CurSelPos].nch;
+					}
+				}
+			}
+			ReleaseMutex(cf_mutex);
+		}
+
+		if (mysamps > 0) {
+			short *tmp = mybuf;
+			for (size_t k = 0; k != NUM_ENCODERS; k++) {
+				if (WaitForSingleObject(Enc_mutex[k], INFINITE) == WAIT_OBJECT_0) {
+					size_t size = mysamps * sizeof (short);
+					short * newbuf = (short*) malloc(size);
+					if (newbuf) {
+						memcpy(newbuf, tmp, size);
+						Encoder[k].Run(OM_ENCODE, newbuf, size, k); // this seems to be modifying newbuf
+						free(newbuf);
+					}
+					ReleaseMutex(Enc_mutex[k]);
+				}
+			}
+		}
+		Sleep(25);
+	} while (hthread != NULL);
+	return 0;
+}
+
+DWORD WINAPI ThreadOutput(LPVOID lpParameter) {
+	do {
+		for (int k = 0; k < NUM_ENCODERS; k++) {
+			if (WaitForSingleObject(Enc_mutex[k], 25) == WAIT_OBJECT_0) {
+				if (Encoder[k].GetEncoder()) {
+					Encoder[k].Run(OM_OUTPUT | OM_OTHER);
+				}
+				ReleaseMutex(Enc_mutex[k]);
+			}
+		}
+		Sleep(25);
+	} while (hthreadout != NULL);
+	return 0;
+}
+
+char olddev[256] = {0};
+int DisplayDeviceName(void) {
+	if (InputDevice) {
+		char deviceBuf[256] = {0};
+		char *deviceName = Soundcard.getDeviceName(0);
+
+		if (deviceName && *deviceName) {
+			char tmp[128] = {0};
+			StringCchPrintfA(deviceBuf, ARRAYSIZE(deviceBuf), WASABI_API_LNGSTRING_BUF(IDS_DEVICE_STRING, tmp, 128), deviceName);
+		} else {
+			WASABI_API_LNGSTRING_BUF(IDS_NO_DEVICES_FOUND, deviceBuf, ARRAYSIZE(deviceBuf));
+			olddev[0] = 0;
+		}
+		SendDlgItemMessage(wnd[2].hWnd, IDC_CURDEVICE, WM_SETTEXT, 0,(LPARAM)deviceBuf);
+
+		// vista - 7 check for default device and restart soundcard if needed
+		if (IsVistaUp()) {
+			if (strcmp(deviceBuf, olddev) != 0) {
+				lstrcpyn(olddev, deviceBuf, ARRAYSIZE(olddev));
+				SuspendThread(hthread);
+				Soundcard.Close();
+				Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
+				ResumeThread(hthread);
+				ini_modified = 1;
+			}
+		}
+	} else {
+		SendDlgItemMessage(wnd[2].hWnd, IDC_CURDEVICE, WM_SETTEXT, 0,(LPARAM)"");
+	}
+
+	return 1;
+}
+
+#ifdef CAPTURE_TESTING
+//-----------------------------------------------------------
+// The input argument to this function is a pointer to the
+// IMMDevice interface for a capture endpoint device. The
+// function traverses the data path that extends from the
+// endpoint device to the system bus (for example, PCI)
+// or external bus (USB). If the function discovers a MUX
+// (input selector) in the path, it selects the MUX input
+// that connects to the stream from the endpoint device.
+//-----------------------------------------------------------
+#define EXIT_ON_ERROR(hres)  \
+              if (FAILED(hres)) { goto Exit; }
+#define SAFE_RELEASE(punk)  \
+              if ((punk) != NULL)  \
+                { (punk)->Release(); (punk) = NULL; }
+
+const IID IID_IDeviceTopology = __uuidof(IDeviceTopology);
+const IID IID_IPart = __uuidof(IPart);
+const IID IID_IConnector = __uuidof(IConnector);
+const IID IID_IAudioInputSelector = __uuidof(IAudioInputSelector);
+
+HRESULT SelectCaptureDevice(IMMDevice *pEndptDev)
+{
+    HRESULT hr = S_OK;
+    DataFlow flow;
+    IDeviceTopology *pDeviceTopology = NULL;
+    IConnector *pConnFrom = NULL;
+    IConnector *pConnTo = NULL;
+    IPart *pPartPrev = NULL;
+    IPart *pPartNext = NULL;
+    IAudioInputSelector *pSelector = NULL;
+
+    if (pEndptDev == NULL)
+    {
+        EXIT_ON_ERROR(hr = E_POINTER)
+    }
+
+    // Get the endpoint device's IDeviceTopology interface.
+    hr = pEndptDev->Activate(
+                      IID_IDeviceTopology, CLSCTX_ALL, NULL,
+                      (void**)&pDeviceTopology);
+    EXIT_ON_ERROR(hr)
+
+    // The device topology for an endpoint device always
+    // contains just one connector (connector number 0).
+    hr = pDeviceTopology->GetConnector(0, &pConnFrom);
+    SAFE_RELEASE(pDeviceTopology)
+    EXIT_ON_ERROR(hr)
+
+    // Make sure that this is a capture device.
+    hr = pConnFrom->GetDataFlow(&flow);
+    EXIT_ON_ERROR(hr)
+
+    if (flow != Out)
+    {
+        // Error -- this is a rendering device.
+        EXIT_ON_ERROR(hr = AUDCLNT_E_WRONG_ENDPOINT_TYPE)
+    }
+
+    // Outer loop: Each iteration traverses the data path
+    // through a device topology starting at the input
+    // connector and ending at the output connector.
+    while (TRUE)
+    {
+        BOOL bConnected;
+        hr = pConnFrom->IsConnected(&bConnected);
+        EXIT_ON_ERROR(hr)
+
+        // Does this connector connect to another device?
+        if (bConnected == FALSE)
+        {
+            // This is the end of the data path that
+            // stretches from the endpoint device to the
+            // system bus or external bus. Verify that
+            // the connection type is Software_IO.
+            ConnectorType  connType;
+            hr = pConnFrom->GetType(&connType);
+            EXIT_ON_ERROR(hr)
+
+            if (connType == Software_IO)
+            {
+                break;  // finished
+            }
+            EXIT_ON_ERROR(hr = E_FAIL)
+        }
+
+        // Get the connector in the next device topology,
+        // which lies on the other side of the connection.
+        hr = pConnFrom->GetConnectedTo(&pConnTo);
+        EXIT_ON_ERROR(hr)
+        SAFE_RELEASE(pConnFrom)
+
+        // Get the connector's IPart interface.
+        hr = pConnTo->QueryInterface(
+                        IID_IPart, (void**)&pPartPrev);
+        EXIT_ON_ERROR(hr)
+        SAFE_RELEASE(pConnTo)
+
+        // Inner loop: Each iteration traverses one link in a
+        // device topology and looks for input multiplexers.
+        while (TRUE)
+        {
+            PartType parttype;
+            UINT localId;
+            IPartsList *pParts;
+
+            // Follow downstream link to next part.
+            hr = pPartPrev->EnumPartsOutgoing(&pParts);
+            EXIT_ON_ERROR(hr)
+
+            hr = pParts->GetPart(0, &pPartNext);
+            pParts->Release();
+            EXIT_ON_ERROR(hr)
+
+            hr = pPartNext->GetPartType(&parttype);
+            EXIT_ON_ERROR(hr)
+
+            if (parttype == Connector)
+            {
+                // We've reached the output connector that
+                // lies at the end of this device topology.
+                hr = pPartNext->QueryInterface(
+                                  IID_IConnector,
+                                  (void**)&pConnFrom);
+                EXIT_ON_ERROR(hr)
+
+                SAFE_RELEASE(pPartPrev)
+                SAFE_RELEASE(pPartNext)
+                break;
+            }
+
+            // Failure of the following call means only that
+            // the part is not a MUX (input selector).
+            hr = pPartNext->Activate(
+                              CLSCTX_ALL,
+                              IID_IAudioInputSelector,
+                              (void**)&pSelector);
+            if (hr == S_OK)
+            {
+                // We found a MUX (input selector), so select
+                // the input from our endpoint device.
+                hr = pPartPrev->GetLocalId(&localId);
+                EXIT_ON_ERROR(hr)
+
+                hr = pSelector->SetSelection(localId, NULL);
+                EXIT_ON_ERROR(hr)
+
+                SAFE_RELEASE(pSelector)
+            }
+
+            SAFE_RELEASE(pPartPrev)
+            pPartPrev = pPartNext;
+            pPartNext = NULL;
+        }
+    }
+
+Exit:
+    SAFE_RELEASE(pConnFrom)
+    SAFE_RELEASE(pConnTo)
+    SAFE_RELEASE(pPartPrev)
+    SAFE_RELEASE(pPartNext)
+    SAFE_RELEASE(pSelector)
+    return hr;
+}
+#endif
+
+void setlev(int cs, int va) {
+	if (IsVistaUp() &&
+	   (cs == MIXERLINE_COMPONENTTYPE_SRC_LINE || cs ==  MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE)) {
+		//HRESULT hr = S_OK;
+		IMMDeviceEnumerator *pEnumerator = NULL;
+		IMMDevice *pDevice = NULL;
+		IMMDeviceCollection *ppDevices = NULL;
+		//hr = CoCreateGuid(&g_guidMyContext);
+		//EXIT_ON_ERROR(hr)
+
+		// Get enumerator for audio endpoint devices.
+		CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+		HRESULT hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
+							  NULL, CLSCTX_INPROC_SERVER,
+							  __uuidof(IMMDeviceEnumerator),
+							  (void**)&pEnumerator);
+		EXIT_ON_ERROR(hr)
+
+		hr = pEnumerator->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE | DEVICE_STATE_UNPLUGGED, &ppDevices);
+		EXIT_ON_ERROR(hr)
+
+		hr = ppDevices->Item(Input_Device_ID, &pDevice);
+		EXIT_ON_ERROR(hr)
+
+		//activate
+		hr = pDevice->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
+		EXIT_ON_ERROR(hr)
+
+		//set mic volume
+		float fVolume = (float)(va / 100.0f);
+		if (va > 2) {
+			hr = g_pEndptVol->SetMasterVolumeLevelScalar(fVolume, NULL/*&g_guidMyContext*/);
+			EXIT_ON_ERROR(hr)
+		} else {//mute
+			hr = g_pEndptVol->SetMasterVolumeLevelScalar((float)0.0f, NULL/*&g_guidMyContext*/);
+		}
+
+		/*hr = pDevice->Activate(__uuidof(IAudioStreamVolume ), CLSCTX_ALL, NULL, (void**)&g_pStreamVol);
+		EXIT_ON_ERROR(hr)
+
+		g_pStreamVol->SetChannelVolume(0, fVolume);
+		g_pStreamVol->SetChannelVolume(1, fVolume);
+
+		IMMDevice *pDefaultDevice = NULL;
+		hr = pEnumerator->GetDefaultAudioEndpoint(eCapture,eConsole,&pDefaultDevice);
+		EXIT_ON_ERROR(hr)
+
+		hr = pDefaultDevice->Activate(__uuidof(IAudioStreamVolume ), CLSCTX_ALL, NULL, (void**)&g_pStreamVol);
+		EXIT_ON_ERROR(hr)
+
+		g_pStreamVol->SetChannelVolume(0, fVolume);
+		g_pStreamVol->SetChannelVolume(1, fVolume);*/
+
+Exit:
+		SAFE_RELEASE(pEnumerator)
+		SAFE_RELEASE(pDevice)
+		SAFE_RELEASE(ppDevices)
+		SAFE_RELEASE(g_pEndptVol)
+		CoUninitialize();
+	} // end if mic
+
+	for (UINT i = 0; i < (IsVistaUp() ? mixerGetNumDevs() : 1); i++) {
+		HMIXER hmix;
+		#ifdef FOLLOW_MIXER
+		// TODO use a different handle??
+		mixerOpen(&hmix, i, (DWORD_PTR)hMainDLG, 0, MIXER_OBJECTF_MIXER|CALLBACK_WINDOW);
+		#endif
+		if (mixerOpen(&hmix, i, (DWORD_PTR)hMainDLG, 0, MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
+			MIXERLINE ml = {sizeof (ml), 0};
+			ml.dwComponentType = cs;
+			if (mixerGetLineInfo((HMIXEROBJ) hmix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
+				MIXERLINECONTROLS mlc = {sizeof (mlc), ml.dwLineID,};
+				MIXERCONTROL mc = {sizeof (mc),};
+				mlc.cControls = 1;
+				mlc.cbmxctrl = sizeof (mc);
+				mlc.pamxctrl = &mc;
+				mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
+				if (mixerGetLineControls((HMIXEROBJ) hmix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
+					MIXERCONTROLDETAILS mcd = {sizeof (mcd), mc.dwControlID, ml.cChannels,};
+					MIXERCONTROLDETAILS_UNSIGNED v[2];
+					mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
+					mcd.paDetails = v;
+					v[0].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
+					v[1].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
+					/*MMRESULT result = */mixerSetControlDetails((HMIXEROBJ) hmix, &mcd, MIXER_OBJECTF_MIXER);
+				}
+			}
+			mixerClose(hmix);
+		}
+	}
+
+	DisplayDeviceName();
+}
+
+int SetDeviceName(void) {
+	HRESULT hr = S_OK;
+	IMMDeviceEnumerator *pEnumerate = NULL;
+	IMMDevice *pDevice = NULL;
+	IMMDevice *pDefaultDevice = NULL;
+	IMMDeviceCollection *ppDevices = NULL;
+	IPropertyStore *pProps = NULL;
+	PROPVARIANT varName;
+
+	if (IsVistaUp()) {
+		CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+		PropVariantInit(&varName);
+		// Get enumerator for audio endpoint devices.
+		hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
+							  NULL, CLSCTX_INPROC_SERVER,
+							  __uuidof(IMMDeviceEnumerator),
+							  (void**)&pEnumerate);
+		EXIT_ON_ERROR(hr)
+
+		hr = pEnumerate->EnumAudioEndpoints(eCapture, DEVICE_STATE_ACTIVE | DEVICE_STATE_UNPLUGGED, &ppDevices);
+		EXIT_ON_ERROR(hr)
+
+		numInputs = 0;
+		hr = ppDevices->GetCount(&numInputs);
+		EXIT_ON_ERROR(hr)
+
+		// treat this as a dummy stop
+		Exit:;
+	}
+
+	int oldCount = SendDlgItemMessage(inWin, IDC_DEVBOX, CB_GETCOUNT, 0, 0);
+	SendDlgItemMessage(inWin, IDC_DEVBOX, CB_RESETCONTENT, 0,0);
+	EnableWindowDlgItem(inWin, IDC_REFRESH_DEVICES, IsVistaUp());
+
+	if (!IsVistaUp()) {//change back to true when vista enabled !
+		SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_MIC_LEGACY_MODE, NULL, 0));
+		SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_LINEIN_LEGACY_MODE, NULL, 0)); 
+	} else {
+		hr = pEnumerate->GetDefaultAudioEndpoint(eCapture, eConsole, &pDefaultDevice);
+		if (SUCCEEDED(hr) && pDefaultDevice != NULL) {
+			LPWSTR defaultName = NULL;
+			pDefaultDevice->GetId(&defaultName);
+
+			//jkey: This is for vista or 7, so we scan through and add friendly device names
+			//		though need to make sure that we don't re-add the current input device
+			//      otherwise with the waveout fudge we'll get really bad feedback on output
+			for (unsigned int i=0; i < numInputs; i++) {
+				LPWSTR itemName = NULL;
+				ppDevices->Item(i, &pDevice);
+				pDevice->GetId(&itemName);
+				// check the id of the endpoints to prevent adding in the default output device
+				if (defaultName && wcsicmp(itemName, defaultName)) {
+					pDevice->OpenPropertyStore(STGM_READ, &pProps);
+					pProps->GetValue(PKEY_Device_FriendlyName, &varName);
+					SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0,(LPARAM)varName.pwszVal);
+					SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETITEMDATA, i,(LPARAM)i);
+				}
+				CoTaskMemFree(itemName);
+			}
+			CoTaskMemFree(defaultName);
+		}
+
+		int count = SendDlgItemMessage(inWin, IDC_DEVBOX, CB_GETCOUNT, 0, 0);
+		if (!count) {
+			SendDlgItemMessageW(inWin, IDC_DEVBOX, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_NO_CAPTURE_DEVICES));
+		}
+		EnableWindowDlgItem(inWin, IDC_DEVBOX, count);
+		// reset to the first item in the list if there's any changes
+		if (!oldCount || count != oldCount) {
+			SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETCURSEL, 0, 0);
+		}
+
+		PropVariantClear(&varName);
+		SAFE_RELEASE(pProps)
+		SAFE_RELEASE(pEnumerate)
+		SAFE_RELEASE(pDevice)
+		SAFE_RELEASE(ppDevices)
+		CoUninitialize();
+	}
+
+	SendDlgItemMessage(inWin, IDC_DEVBOX, CB_SETCURSEL, Input_Device_ID, 0);
+	DisplayDeviceName();
+	return 1;
+}
+
+/*int getlev(int cs) {
+	HMIXER hmix;
+	int retval = -1;
+#ifdef USE_VISTA_SOUND_FIX
+	HRESULT hr = S_OK;
+	IMMDeviceEnumerator *pEnumerator = NULL;
+	IMMDevice *pDevice = NULL;
+	IMMDeviceCollection *ppDevices = NULL;
+	hr = CoCreateGuid(&g_guidMyContext);
+	EXIT_ON_ERROR(hr)
+
+	// Get enumerator for audio endpoint devices.
+	CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+	hr = CoCreateInstance(__uuidof(MMDeviceEnumerator),
+						  NULL, CLSCTX_INPROC_SERVER,
+						  __uuidof(IMMDeviceEnumerator),
+						  (void**)&pEnumerator);
+	EXIT_ON_ERROR(hr)
+
+	hr = pEnumerator->EnumAudioEndpoints(eCapture,DEVICE_STATE_ACTIVE,&ppDevices);
+	EXIT_ON_ERROR(hr)
+
+	hr = ppDevices->Item(Input_Device_ID,&pDevice);
+	EXIT_ON_ERROR(hr)
+
+	//activate
+	hr = pDevice->Activate(__uuidof(IAudioEndpointVolume),
+	CLSCTX_ALL, NULL, (void**)&g_pEndptVol);
+	EXIT_ON_ERROR(hr)
+	//set mic volume
+	float fVolume =0.0;
+	hr = g_pEndptVol->GetMasterVolumeLevel(&fVolume);
+	EXIT_ON_ERROR(hr)
+
+Exit:
+	if (FAILED(hr))	{
+		useXpSound = true;
+	} else {
+		retval = (int)fVolume * 100;
+		return retval;
+	}
+
+	SAFE_RELEASE(pEnumerator)
+	SAFE_RELEASE(pDevice)
+	SAFE_RELEASE(ppDevices)
+	SAFE_RELEASE(g_pEndptVol)
+	CoUninitialize();
+
+#endif //USE_VISTA_SOUND_FIX
+	if (mixerOpen(&hmix, 0, 0, 0, 0) == MMSYSERR_NOERROR) {
+		MIXERLINE ml = {sizeof (ml), 0};
+		ml.dwComponentType = cs;
+		if (mixerGetLineInfo((HMIXEROBJ) hmix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE) == MMSYSERR_NOERROR) {
+			MIXERLINECONTROLS mlc = {sizeof (mlc), ml.dwLineID,};
+			MIXERCONTROL mc = {sizeof (mc),};
+			mlc.cControls = 1;
+			mlc.cbmxctrl = sizeof (mc);
+			mlc.pamxctrl = &mc;
+			mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
+			if (mixerGetLineControls((HMIXEROBJ) hmix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE) == MMSYSERR_NOERROR) {
+				MIXERCONTROLDETAILS mcd = {sizeof (mcd), mc.dwControlID, ml.cChannels,};
+				MIXERCONTROLDETAILS_UNSIGNED v[2];
+				mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
+				mcd.paDetails = v;
+				if (mixerGetControlDetails((HMIXEROBJ) hmix, &mcd, 0) == MMSYSERR_NOERROR) {
+					retval = (v[0].dwValue * 100) / (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum);
+					// retval = ((v[0].dwValue + v[1].dwValue) * 5) / (mc.Bounds.dwMaximum-mc.Bounds.dwMinimum);
+				}
+			}
+		}
+		mixerClose(hmix);
+	}
+	return retval;
+}*/
+
+void TitleCallback(int Connection, int Mode) {
+	MY_T_OUTPUT *Out = &Output[Connection];
+	// title update
+	if (Mode == 0) {
+		if (Out->AutoTitle == 1) {
+			// look at the playback queue so we can get the correct 'next song'
+			if (!WASABI_API_QUEUEMGR) {
+				// due to loading orders its possible the queue won't have been loaded on init so check
+				ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
+			}
+
+			std::vector<std::wstring> nextList;
+			nextList.clear();
+			Encoder[Out->Encoder].UpdateTitle(0, nextList, Out->Handle, !!Out->NextTitles);
+		}
+	} else if (Mode == 1) {
+		// album art update
+		Encoder[Out->Encoder].UpdateAlbumArt(Out->Handle);
+	}
+}
+
+void CenterWindow(void) {
+    RECT rect, rectP;
+    int width, height;
+    int screenwidth, screenheight;
+    int x, y;
+
+	GetWindowRect(hMainDLG, &rect);
+	GetWindowRect(GetDesktopWindow(), &rectP);
+
+	width = rect.right - rect.left;
+	height = rect.bottom - rect.top;
+
+	x = ((rectP.right-rectP.left) - width) / 2 + rectP.left;
+	y = ((rectP.bottom-rectP.top) - height) / 2 + rectP.top;
+
+	screenwidth = GetSystemMetrics(SM_CXSCREEN);
+	screenheight = GetSystemMetrics(SM_CYSCREEN);
+
+	if (x < 0) x = 0;
+	if (y < 0) y = 0;
+	if (x + width > screenwidth) x = screenwidth - width;
+	if (y + height > screenheight) y = screenheight - height;
+
+	mainrect.left = x;
+	mainrect.top = y;
+}
+
+int LoadConfig(void) {
+	lookAhead = GetPrivateProfileInt(APP_Name, "lookAhead", lookAhead, IniName);
+	skipMetada = !!GetPrivateProfileInt(APP_Name, "skipMetada", skipMetada, IniName);
+	lastFilterIndex = GetPrivateProfileInt(APP_Name, "ofnidx", lastFilterIndex, IniName);
+
+	curtab = GetPrivateProfileInt(APP_Name, "CurTab", curtab, IniName);
+	Connection_CurSelPos = GetPrivateProfileInt(APP_Name, "Connection_CurSelPos", Connection_CurSelPos, IniName);
+	curouttab = GetPrivateProfileInt(APP_Name, "Connection_CurTab", curouttab, IniName);
+	Encoder_CurSelPos = GetPrivateProfileInt(APP_Name, "Encoder_CurSelPos", Encoder_CurSelPos, IniName);
+	InputDevice = GetPrivateProfileInt(APP_Name, "InputDevice", InputDevice, IniName);
+
+	Input_CurSelPos = GetPrivateProfileInt(APP_Name, "Input_CurSelPos", Input_CurSelPos, IniName);
+	InputConfig.srate = LineInputAttribs[3].srate;
+	InputConfig.nch = LineInputAttribs[3].nch;
+	cf_mutex = CreateMutex(NULL, TRUE, NULL);
+	Crossfader = new C_CROSSFADER(CrossfadeLen,
+								  LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].nch,
+								  LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].srate);
+
+	MusVol = GetPrivateProfileInt(APP_Name, "MusicVolume", MusVol, IniName);
+	Mus2Vol = GetPrivateProfileInt(APP_Name, "BGMusicVolume", Mus2Vol, IniName);
+	MicVol = GetPrivateProfileInt(APP_Name, "MicVolume", MicVol, IniName);
+
+	// as we've changed the scaling then we will need to adjust from old to new
+	int tempFadeTime = GetPrivateProfileInt(APP_Name, "PTT_FadeTime", -1, IniName);
+	if (tempFadeTime == -1) {
+		FadeTime = GetPrivateProfileInt(APP_Name, "PTT_FT", FadeTime, IniName);
+	} else {
+		FadeTime = tempFadeTime * 5;
+		// remove the old instance of the settings
+		WritePrivateProfileString(APP_Name, "PTT_FadeTime", 0, IniName);
+	}
+
+	int tempMicFadeTime = GetPrivateProfileInt(APP_Name, "PTT_MicFadeTime", -1, IniName);
+	if (tempMicFadeTime == -1) {
+		MicFadeTime = GetPrivateProfileInt(APP_Name, "PTT_MicFT", MicFadeTime, IniName);
+	} else {
+		MicFadeTime = tempMicFadeTime * 5;
+		// remove the old instance of the settings
+		WritePrivateProfileString(APP_Name, "PTT_MicFadeTime", 0, IniName);
+	}
+
+	Restore_PTT = GetPrivateProfileInt(APP_Name, "PTT_Restore", 0, IniName);
+	Input_Device_ID = GetPrivateProfileInt(APP_Name, "PTT_MicInput",0, IniName);
+
+	// align to middle of screen on new installs
+	CenterWindow();
+	mainrect.left = GetPrivateProfileInt(APP_Name, "WindowLeft", mainrect.left, IniName);
+	mainrect.top = GetPrivateProfileInt(APP_Name, "WindowTop", mainrect.top, IniName);
+
+	GetPrivateProfileString(APP_Name, "Update", 0, updateStr, 16, IniName);
+	// no point in indicating a new version if we're now showing as ahead
+	if (!CompareVersions(updateStr)) {
+		WritePrivateProfileString(APP_Name, "Update", 0, IniName);
+		updateStr[0] = 0;
+	}
+
+	for (int i = 0; i < NUM_OUTPUTS; i++) {
+		T_OUTPUT_CONFIG *Out = &Output[i].Config;
+		StringCchPrintfA(Out->Name, 32, "Output %u", i + 1);
+		StringCchPrintfW(Out->DisplayName, 32, WASABI_API_LNGSTRINGW(IDS_OUTPUT_X), i + 1);
+		Output[i].Encoder = -1;
+		Output[i].Handle = -1;
+		GetPrivateProfileString(Out->Name, "Address", "localhost", Out->Address, ARRAYSIZE(Out->Address), IniName);
+		GetPrivateProfileString(Out->Name, "UserID", "", Out->UserID, ARRAYSIZE(Out->UserID), IniName);
+		GetPrivateProfileString(Out->Name, "StreamID", "1", Out->StationID, ARRAYSIZE(Out->StationID), IniName);
+		Out->Port = GetPrivateProfileInt(Out->Name, "Port", 8000, IniName);
+		GetPrivateProfileString(Out->Name, "Password", "", Out->Password, ARRAYSIZE(Out->Password), IniName);
+		GetPrivateProfileString(Out->Name, "Cipherkey", "foobar", Out->cipherkey, ARRAYSIZE(Out->cipherkey), IniName);
+		GetPrivateProfileString(Out->Name, "Description", "Unnamed Server", Out->Description, ARRAYSIZE(Out->Description), IniName);
+		GetPrivateProfileString(Out->Name, "URL", "http://www.shoutcast.com", Out->ServerURL, ARRAYSIZE(Out->ServerURL), IniName);
+		GetPrivateProfileString(Out->Name, "Genre3", "Misc", Out->Genre, ARRAYSIZE(Out->Genre), IniName);
+		// check that the genre is a support value otherwise reset it to 'misc'
+		bool foundGenre = false;
+		for (int g = 0; g < ARRAYSIZE(genres); g++) {
+			if (!strcmpi(genres[g].name, Out->Genre)) {
+				foundGenre = true;
+				break;
+			}
+		}
+		if (foundGenre == false) {
+			lstrcpyn(Out->Genre, "Misc", ARRAYSIZE(Out->Genre));
+		}
+
+		GetPrivateProfileString(Out->Name, "AIM", "N/A", Out->AIM, ARRAYSIZE(Out->AIM), IniName);
+		GetPrivateProfileString(Out->Name, "ICQ", "0", Out->ICQ, ARRAYSIZE(Out->ICQ), IniName);
+		GetPrivateProfileString(Out->Name, "IRC", "N/A", Out->IRC, ARRAYSIZE(Out->IRC), IniName);
+		Out->Public = GetPrivateProfileInt(Out->Name, "Public", 1, IniName);
+		Out->AutoRecon = GetPrivateProfileInt(Out->Name, "AutoRecon", 1, IniName);
+		Out->ReconTime = GetPrivateProfileInt(Out->Name, "ReconTime", 5, IniName);
+		if (Out->ReconTime < 1) {
+			Out->ReconTime = 5;
+		}
+		Out->doTitleUpdate = GetPrivateProfileInt(Out->Name, "doTitleUpdate", 1, IniName);
+		GetPrivateProfileString(Out->Name, "now", "", Out->Now, ARRAYSIZE(Out->Now), IniName);
+		GetPrivateProfileString(Out->Name, "next", "", Out->Next, ARRAYSIZE(Out->Next), IniName);
+		Output[i].AutoTitle = GetPrivateProfileInt(Out->Name, "AutoTitle", 1, IniName);
+		Output[i].AutoConnect = GetPrivateProfileInt(Out->Name, "AutoConnect", 0, IniName);
+		Output[i].Logging = GetPrivateProfileInt(Out->Name, "Logging", 0, IniName);
+		Output[i].LogCOS = GetPrivateProfileInt(Out->Name, "LogCOS", 0, IniName);
+		Output[i].NextTitles = GetPrivateProfileInt(Out->Name, "NextTitles", 1, IniName);
+		Output[i].Config.protocol = GetPrivateProfileInt(Out->Name, "protocol", -1, IniName);
+		if (Output[i].Config.protocol == -1) {
+			Output[i].Config.protocol = MAKEWORD(2, 1);
+		}
+		// check the v1 password for : and split it if the dj/user id is empty (i.e. post 2.2.3 import)
+		if (LOBYTE(Output[i].Config.protocol) == 1 && Out->Password[0] && !Out->UserID[0]) {
+			char* password = strstr(Out->Password, ":");
+			if (password) {
+				*password = 0;
+				lstrcpyn(Out->UserID, Out->Password, ARRAYSIZE(Out->UserID));
+				lstrcpyn(Out->Password, ++password, ARRAYSIZE(Out->Password));
+			}
+		}
+		Output[i].nextTrackLog = GetPrivateProfileInt(Out->Name, "nextTrackLog", 0, IniName);
+		Output[i].nextTrackLogXML = GetPrivateProfileInt(Out->Name, "nextTrackLogXML", 0, IniName);
+		if (!GetPrivateProfileStringUTF8(Out->Name, "nextTrackPath", 0, Output[i].nextTrackPath, ARRAYSIZE(Output[i].nextTrackPath), IniName)) {
+			GetDefaultNextTracksLogFile(module.hwndParent, ARRAYSIZE(Output[i].nextTrackPath), Output[i].nextTrackPath, i);
+		}
+
+		Output[i].useArt = GetPrivateProfileInt(Out->Name, "useArt", 0, IniName);
+		Output[i].usePlayingArt = GetPrivateProfileInt(Out->Name, "usePlayingArt", 0, IniName);
+		Output[i].useStreamArt = GetPrivateProfileInt(Out->Name, "useStreamArt", 1, IniName);
+		GetPrivateProfileStringUTF8(Out->Name, "stationArtPath", 0, Output[i].stationArtPath, ARRAYSIZE(Output[i].stationArtPath), IniName);
+
+		Output[i].saveEncoded = GetPrivateProfileInt(Out->Name, "saveEncoded", 0, IniName);
+		GetPrivateProfileStringUTF8(Out->Name, "saveEncodedPath", 0, Output[i].saveEncodedPath, ARRAYSIZE(Output[i].saveEncodedPath), IniName);
+
+		Output[i].Encoder = GetPrivateProfileInt(Out->Name, "Encoder", i == 0 ? 0 : -1, IniName);
+		if (Output[i].Encoder != -1) {
+			if (WaitForSingleObject(Enc_mutex[Output[i].Encoder], INFINITE) == WAIT_OBJECT_0) {
+				Output[i].Handle = Encoder[Output[i].Encoder].AddOutput(i, Out, TitleCallback);
+				ReleaseMutex(Enc_mutex[Output[i].Encoder]);
+			}
+		}
+	}
+	return 1;
+}
+
+wchar_t* BuildLameVersion(void) {
+	static wchar_t version[128] = {0};
+	if (libinst != NULL && !version[0]) {
+		BE_VERSION ver;
+		beVersion(&ver);
+
+		if (ver.byBetaLevel) {
+			StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%ub%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion, (unsigned int)ver.byBetaLevel);
+		} else if (ver.byAlphaLevel) {
+			StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%ua%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion, (unsigned int)ver.byAlphaLevel);
+		} else {
+			StringCchPrintfW(version, ARRAYSIZE(version), L"%u.%u", (unsigned int)ver.byMajorVersion, (unsigned int)ver.byMinorVersion);
+		}
+	}
+	return version;
+}
+
+void LoadEncoders() {
+	/* load lame_enc.dll */
+	wchar_t dllname[MAX_PATH] = {0};
+	StringCchPrintfW(dllname, ARRAYSIZE(dllname), L"%s\\lame_enc.dll", GetSharedDirectoryW(module.hwndParent));
+
+	libinst = LoadLibraryW(dllname);
+	if (libinst == NULL) {
+		wchar_t title[128] = {0}, message[512] = {0};
+		StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
+		StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_FAILED_LOAD_LAMEDLL, NULL, 0), GetSharedDirectoryW(module.hwndParent));
+		MessageBoxW(module.hwndParent, message, title, MB_ICONWARNING);
+	} else {
+		beVersion = (BEVERSION) GetProcAddress(libinst, "beVersion");
+		init = (void *) GetProcAddress(libinst, "lame_init");
+		params = (void *) GetProcAddress(libinst, "lame_init_params");
+		encode = (void *) GetProcAddress(libinst, "lame_encode_buffer_interleaved");
+		finish = (void *) GetProcAddress(libinst, "lame_encode_flush");
+
+		if (!init || !params || !encode || !finish) {
+			wchar_t title[128] = {0};
+			StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
+			MessageBoxW(module.hwndParent, LocalisedString(IDS_LAMEDLL_ISSUE, NULL, 0), title, MB_ICONWARNING);
+			FreeLibrary(libinst);
+			libinst = 0;
+		}
+	}
+
+	/* load encoder type */
+	for (int i = 0; i < NUM_ENCODERS; i++) {
+		char name[32] = {0};
+		Enc_mutex[i] = CreateMutex(NULL, TRUE, NULL);
+		StringCchPrintfA(name, ARRAYSIZE(name), "Encoder %u", i + 1);
+		int EncType = GetPrivateProfileInt(name, "Type", 2, IniName);
+		// store our type for later on
+		Enc_LastType[i] = EncType;
+		switch (EncType) {
+			/* mp3 */
+			case 1:
+				{
+				fallback:
+					Encoder[i].SetLame(init, params, encode, finish);
+					Encoder[i].SetEncoder(DEFAULT_ENCODER);
+					C_ENCODER *Enc = Encoder[i].GetEncoder();
+					if (Enc) {
+						if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
+							T_ENCODER_MP3_INFO EncSettings;
+							int infosize = sizeof (EncSettings);
+							T_ENCODER_MP3_INFO *encset = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
+							if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+							EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+							EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+							EncSettings.output_bitRate = GetPrivateProfileInt(name, "BitRate", EncSettings.output_bitRate, IniName);
+							EncSettings.output_sampleRate = GetPrivateProfileInt(name, "SampleRate", EncSettings.output_sampleRate, IniName);
+							EncSettings.output_numChannels = GetPrivateProfileInt(name, "NumChannels", EncSettings.output_numChannels, IniName);
+							EncSettings.QualityMode = GetPrivateProfileInt(name, "QualityMode", 8, IniName);
+							Enc->ChangeSettings(&EncSettings);
+						}
+					}
+				}
+				break;
+
+			case 2:
+			// map any AAC LC from the prior versions to FHG AAC with 5.62+
+			case 3:
+				{ // FHG AAC
+					if (C_ENCODER_FHGAAC::isPresent(module.hwndParent)) {
+						Encoder[i].SetEncoder(new C_ENCODER_FHGAAC(module.hwndParent), 1);
+						C_ENCODER *Enc = Encoder[i].GetEncoder();
+						if (Enc) {
+							T_ENCODER_FHGAAC_INFO EncSettings;
+							int infosize = sizeof (EncSettings);
+							T_ENCODER_FHGAAC_INFO *encset = (T_ENCODER_FHGAAC_INFO *) Enc->GetExtInfo(&infosize);
+							if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+							EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+							EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+							Enc->ChangeSettings(&EncSettings);
+							((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
+						}
+					} else if (C_ENCODER_AACP::isPresent(module.hwndParent)) { // AAC+
+						Encoder[i].SetEncoder(new C_ENCODER_AACP(module.hwndParent), 1);
+						C_ENCODER *Enc = Encoder[i].GetEncoder();
+						if (Enc) {
+							T_ENCODER_AACP_INFO EncSettings;
+							int infosize = sizeof (EncSettings);
+							T_ENCODER_AACP_INFO *encset = (T_ENCODER_AACP_INFO *) Enc->GetExtInfo(&infosize);
+							if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+							EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+							EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+							Enc->ChangeSettings(&EncSettings);
+							((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
+						}
+					} else {
+						//Encoder[i].SetEncoder(NULL);
+						// attempt to get to a valid encoder if the aac one disappeared
+						goto fallback;
+					}
+				}
+				break;
+#ifdef USE_OGG
+			case 4:
+				{ // OGG
+					if (C_ENCODER_OGG::isPresent(module.hwndParent)) {
+						Encoder[i].SetEncoder(new C_ENCODER_OGG(module.hwndParent), 1);
+						C_ENCODER *Enc = Encoder[i].GetEncoder();
+						if (Enc) {
+							T_ENCODER_OGG_INFO EncSettings;
+							int infosize = sizeof (EncSettings);
+							T_ENCODER_OGG_INFO *encset = (T_ENCODER_OGG_INFO *) Enc->GetExtInfo(&infosize);
+							if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+							EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+							EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+							Enc->ChangeSettings(&EncSettings);
+							((C_ENCODER_NSV*) Enc)->ReadConfFile(IniName, name);
+						}
+					} else Encoder[i].SetEncoder(NULL);
+				}
+				break;
+#endif // USE_OGG
+			default:
+				{
+					Encoder[i].SetEncoder(NULL);
+				}
+				break;
+		}
+		ReleaseMutex(Enc_mutex[i]);
+	}
+}
+
+void SetEncoderPanelMode(HWND hDlg, C_ENCODER * Enc) {
+	BOOL show = (Enc != NULL);
+	if (show) {
+		if (Enc->UseNsvConfig() == true) {
+			ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_HIDE);
+			ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_SHOW);
+			wchar_t tmp[128] = {0};
+			StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_CURRENT_BITRATE, NULL, 0), ((T_EncoderIOVals*) Enc->GetExtInfo())->output_bitRate);
+			SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, tmp);
+			ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_HIDE);
+		} else {
+			wchar_t *lame_version = BuildLameVersion();
+			if (lame_version && *lame_version)
+			{
+				ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_SHOW);
+				ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
+				SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_ENCODER_SETTINGS, NULL, 0));
+
+				wchar_t tmp[128] = {0};
+				StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_LAME_ENCODER_VER, NULL, 0), lame_version);
+				SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LAME_VER, tmp);
+				ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_SHOW);
+			} else {
+				ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS, SW_HIDE);
+				ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
+				SetDlgItemTextW(hDlg, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_MP3_ENCODING_NOT_AVAILABLE, NULL, 0));
+			}
+		}
+	} else {
+		ShowWindowDlgItem(hDlg, IDC_ENCSETTINGS_LAME_VER, SW_HIDE);
+	}
+
+	// show / hide the groupbox around the main encoder options
+	// which is setup to make it look like it's only around the
+	// options available depending upon the mode that is in use
+	ShowWindowDlgItem(hDlg, IDC_INFO_FRAME4, !show);
+	ShowWindowDlgItem(hDlg, IDC_INFO_FRAME5, show);
+
+	// show / hide the save encoded audio options as applicable
+	ShowWindowDlgItem(hDlg, IDC_INFO_FRAME3, show);
+	ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO, show);
+	ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO_EDIT, show);
+	ShowWindowDlgItem(hDlg, IDC_SAVE_ENCODED_AUDIO_BROWSE, show);
+}
+
+void FreeStreamAlbumArt(int Index) {
+	if (streamImage[Index] > (ARGB32 *)0 &&
+		streamImage[Index] != (ARGB32 *)-1 &&
+		WASABI_API_MEMMGR) {
+		WASABI_API_MEMMGR->sysFree(streamImage[Index]);
+		streamImage[Index] = (ARGB32 *)-1;
+	}
+	streamLength[Index] = 0;
+}
+
+// destroy dlg and exit
+int doQuit(void) {
+	if (nowPlayingHook) {
+		UnhookWindowsHookEx(nowPlayingHook);
+		nowPlayingHook = 0;
+	}
+	if (nowPlayingHook2) {
+		UnhookWindowsHookEx(nowPlayingHook2);
+		nowPlayingHook2 = 0;
+	}
+
+	RemoveSystrayIcon(hMainDLG, SYSTRAY_ICY_ICON);
+
+	GetWindowRect(hMainDLG, &mainrect);
+
+	KillTimer(hMainDLG, wnd[curtab].id);
+	KillTimer(hMainDLG, IDD_ENCODER);
+	KillTimer(hMainDLG, 666);
+	KillTimer(hMainDLG, 1234);
+	KillTimer(hMainDLG, 1337);
+	KillTimer(hMainDLG, 2234);
+	KillTimer(hMainDLG, 2235);
+	if (curtab == 1) KillTimer(wnd[curtab].hWnd, out_wnd[curouttab].id);
+	if (curtab == 2) KillTimer(wnd[curtab].hWnd, in_wnd[InputDevice].id);
+	ini_modified = 1;
+	/* Disconnect all outputs */
+	int done;
+	do {
+		done = 1;
+		for (int i = 0; i < NUM_OUTPUTS; i++) {
+			MY_T_OUTPUT *Out = &Output[i];
+			if (Out->Encoder != -1 && Out->Handle != -1) {
+				SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+				int state = Enc->GetState(Out->Handle);
+				if (state != OUT_DISCONNECTED && state != OUT_ERROR) {
+					done = 0;
+					Enc->DisconnectOutput(Out->Handle);
+				} else {
+					// shutdown the logging options
+					if (Out->Logging) {
+						StopLogging(i);
+					}
+					if (Out->nextTrackLog) {
+						StopNextTracks(i);
+					}
+					if (Out->saveEncoded) {
+						StopSaveEncoded(i);
+					}
+				}
+				Enc->Run(OM_OUTPUT | OM_OTHER);
+			}
+		}
+		Sleep(200); 
+	} while (!done);
+
+	// reset levels if PTT is enabled when we are closing
+	if (FadeOut && InputDevice) {
+		int micsrc = Input_Device_ID  >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
+		setlev(micsrc, 0);
+		setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
+	}
+
+	if (hthread) {
+		CloseHandle(hthread);
+		hthread = NULL;
+	}
+
+	if (hthreadout) {
+		CloseHandle(hthreadout);
+		hthreadout = NULL;
+	}
+
+	ReleaseMutex(cf_mutex);
+	Soundcard.Close();
+
+	SendMessage(hMainDLG, WM_TIMER, MAKEWPARAM(666,0), 0); // force an INI save
+
+	if (playingImage && WASABI_API_MEMMGR) {
+		WASABI_API_MEMMGR->sysFree(playingImage);
+		playingImage = 0;
+	}
+
+	for (int i = 0; i < NUM_OUTPUTS; i++) {
+		FreeStreamAlbumArt(i);
+	}
+
+	if (libinst) {
+		FreeLibrary(libinst);
+		libinst = 0;
+	}
+	C_ENCODER_FHGAAC::Unload();
+	C_ENCODER_AACP::Unload();
+#ifdef USE_OGG
+	C_ENCODER_OGG::Unload();
+#endif // USE_OGG
+
+	for (int i = 0; i < num_tabwnds; i++) DestroyWindow(wnd[i].hWnd);
+	for (int i = 0; i < num_inwnds; i++) DestroyWindow(in_wnd[i].hWnd);
+	for (int i = 0; i < num_outwnds; i++) DestroyWindow(out_wnd[i].hWnd);
+
+	for (int ii = 0; ii < NUM_OUTPUTS; ii++) {
+		MY_T_OUTPUT *Out = &Output[ii];
+		// removed encoder selection
+		if (Out->Encoder != -1) {
+			if (Out->Handle != -1) {
+				if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+					Encoder[Out->Encoder].RemoveOutput(Out->Handle);
+					ReleaseMutex(Enc_mutex[Out->Encoder]);
+				}
+			}
+		}
+	}
+
+	DestroyWindow(hMainDLG);
+	hMainDLG = NULL;
+
+	num_cols = num_outwnds = num_inwnds = num_tabwnds = 0;
+	memset(&col, 0, sizeof(col));
+	memset(&wnd, 0, sizeof(wnd));
+	memset(&out_wnd, 0, sizeof(out_wnd));
+	memset(&in_wnd, 0, sizeof(in_wnd));
+	memset(&Output, 0, sizeof(Output));
+	WASABI_API_LNG_HINST = WASABI_API_ORIG_HINST = 0;
+
+	memset(&lastFile, 0, sizeof(lastFile));
+	memset(&lastSec, 0, sizeof(lastSec));
+	memset(&lastFile, 0, sizeof(lastFile));
+	memset(&lastMode, -1, sizeof(lastMode));
+	memset(&lastEnable, 0, sizeof(lastEnable));
+	memset(&buttonWnd, 0, sizeof(buttonWnd));
+	memset(&tabWnd, 0, sizeof(tabWnd));
+	memset(&outTabWnd, 0, sizeof(outTabWnd));
+	memset(&streamLength, 0, sizeof(streamLength));
+	memset(&secChanged, 0, sizeof(secChanged));
+
+	playingImage_w = playingImage_h = playingLength = playingType;
+
+	if (boldFont) {
+		DeleteObject(boldFont);
+		boldFont = NULL;
+	}
+	normalFont = NULL;
+
+	ServiceRelease(WASABI_API_SVC, AGAVE_API_CONFIG, AgaveConfigGUID);
+	ServiceRelease(WASABI_API_SVC, WASABI_API_LNG, languageApiGUID);
+	ServiceRelease(WASABI_API_SVC, WASABI_API_MEMMGR, memMgrApiServiceGuid);
+	ServiceRelease(WASABI_API_SVC, AGAVE_API_ALBUMART, albumArtGUID);
+	ServiceRelease(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
+	ServiceRelease(WASABI_API_SVC, WASABI_API_EXPLORERFINDFILE,ExplorerFindFileApiGUID);
+	ServiceRelease(WASABI_API_SVC, WAC_API_DOWNLOADMANAGER, DownloadManagerGUID);
+	WASABI_API_SVC = NULL;
+
+	return 1;
+}
+
+void SetBoldDialogItemFont(HWND hwndControl) {
+	if (!boldFont) {
+		HFONT hFont = (HFONT)SendMessageW(hMainDLG, WM_GETFONT, 0, 0);
+		LOGFONTW lf = {0};
+		GetObjectW(hFont, sizeof(LOGFONTW), &lf);
+		lf.lfWeight = FW_BOLD;
+		boldFont = CreateFontIndirectW(&lf);
+	}
+	if (boldFont) {
+		SendMessageW(hwndControl, WM_SETFONT, (WPARAM)boldFont, MAKELPARAM(1,0));
+	}
+}
+
+LRESULT WINAPI headerProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	if (uMsg == WM_SETCURSOR) {
+		return TRUE;
+	}
+	return CallWindowProcW(prevHeaderProc, hWnd, uMsg, wParam, lParam);
+}
+
+LRESULT WINAPI listViewProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	switch (uMsg) {
+		case WM_COMMAND:
+			switch (LOWORD(wParam)) {
+				case IDC_STREAM_1:
+				case IDC_STREAM_2:
+				case IDC_STREAM_3:
+				case IDC_STREAM_4:
+				case IDC_STREAM_5:
+				{
+					int oldCurSelPos = Connection_CurSelPos;
+					Connection_CurSelPos = (LOWORD(wParam) - IDC_STREAM_1);
+					ListView_SetItemState(hWnd, Connection_CurSelPos, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
+					SetFocus(hWnd);
+					SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_CONNECT, BN_CLICKED), (LPARAM)GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
+					Connection_CurSelPos = oldCurSelPos;
+				}
+				return 0;
+			}
+			break;
+
+		case WM_NOTIFY:
+			if(((LPNMHDR)lParam)->code == HDN_BEGINTRACKW ||
+			   ((LPNMHDR)lParam)->code == HDN_ITEMCHANGINGW) {
+				return TRUE;
+			}
+		break;
+	}
+	return CallWindowProcW(prevListViewProc, hWnd, uMsg, wParam, lParam);
+}
+
+void SetTabErrorText(HWND hwnd, int index, int current, LPRECT r, bool update = false) {
+	HDC hDC = GetDC(hwnd);
+	if (!normalFont) {
+		normalFont = (HFONT)SendMessageW(hMainDLG, WM_GETFONT, 0, 0);
+	}
+	HFONT hOldFont = (HFONT)SelectObject(hDC, normalFont);
+	int oldTextColor = SetTextColor(hDC, (!update ? RGB(255,0,0) : RGB(0,0,255)));
+	int oldBkMode = SetBkMode(hDC, TRANSPARENT);
+
+	wchar_t buf[128] = {0};
+	TCITEMW pitem = {0};
+	pitem.mask = TCIF_TEXT;
+	pitem.pszText = buf;
+	pitem.cchTextMax = ARRAYSIZE(buf);
+	SendMessageW(hwnd, TCM_GETITEMW, index, (LPARAM)&pitem);
+
+	r->top += (current ? 1 : 3);
+	r->left += 6;
+
+	// if themeing is enabled then we need to paint the background to avoid the font going weird / double-bold like
+	// and to ensure we're correct, am taking a 1px sliver and stretching it across the area before drawing the text
+	if (isthemethere) {
+		StretchBlt(hDC, r->left, r->top + 1, r->right - r->left - 3, r->bottom - r->top - 3, hDC, r->left - 4, r->top + 1,  1, r->bottom - r->top - 3, SRCCOPY);
+	}
+
+	DrawTextW(hDC, pitem.pszText, wcslen(pitem.pszText), r, DT_SINGLELINE);
+	SetTextColor(hDC, oldTextColor);
+	SetBkMode(hDC, oldBkMode);
+	SelectObject(hDC, hOldFont);
+	ReleaseDC(hwnd, hDC);
+}
+
+LRESULT WINAPI tabWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	LRESULT ret = CallWindowProcW(prevTabWndProc, hWnd, uMsg, wParam, lParam);
+	if (uMsg == WM_PAINT) {
+		RECT r = {0};
+		int item = ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED);
+		if ((curtab == 1 ?
+			 (lastMode[Connection_CurSelPos] >= 3 && lastMode[Connection_CurSelPos] <= 6) :
+			 (lastMode[item] >= 3 && lastMode[item] <= 6)
+			) && TabCtrl_GetItemRect(hWnd, 1, &r)) {
+			SetTabErrorText(hWnd, 1, (curtab == 1), &r);
+		}
+
+		// show the update flag on things!
+		if (updateStr && updateStr[0]) {
+			RECT r = {0};
+			TabCtrl_GetItemRect(tabWnd, 3, &r);
+			SetTabErrorText(tabWnd, 3, (curtab == 3), &r, TRUE);
+		}
+	}
+	return ret;
+}
+
+LRESULT WINAPI outTabWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	LRESULT ret = CallWindowProcW(prevOutTabWndProc, hWnd, uMsg, wParam, lParam);
+	if (uMsg == WM_PAINT) {
+		for (int i = 0; i < NUM_OUTPUTS; i++) {
+			RECT r = {0};
+			int index[] = {0, 0, 1, 2};
+			if ((lastMode[i] >= 3 && lastMode[i] <= 6) && (i == Connection_CurSelPos) && TabCtrl_GetItemRect(hWnd, index[(lastMode[i] - 3)], &r)) {
+				SetTabErrorText(hWnd, index[(lastMode[i] - 3)], (curouttab == index[(lastMode[i] - 3)]), &r);
+			}
+		}
+	}
+	return ret;
+}
+
+LRESULT WINAPI buttonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	int ret;
+	switch (uMsg) {
+		case WM_LBUTTONDOWN:
+			ret = CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
+			if (SendDlgItemMessage(GetParent(hWnd), IDC_LOCK, BM_GETSTATE, 0, 0) != BST_CHECKED) {
+				blockmousemove = 1;
+				KillTimer(hMainDLG, 2234);
+				KillTimer(hMainDLG, 2235);
+				if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != 1) {
+					clock_t myTime = clock();
+					if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
+					if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
+				}
+				FadeOut = 1;
+				SetTimer(hMainDLG, 2234, 10, NULL); // fade out
+				SetTimer(hMainDLG, 2235, 10, NULL); // fade out
+				//if (FadeOut) do_capture();
+				#ifdef CAPTURE_TESTING
+				if (FadeOut) {
+					if (!pPlayer) {
+						pPlayer = new Player(hMainDLG);
+					}
+					if (!pCallbacks) {
+						pCallbacks = new CPlayerCallbacks();
+					}
+					pPlayer->SetPlayerCallbacks(pCallbacks);
+					pPlayer->RefreshDeviceList(eRender);
+					pPlayer->RefreshDeviceList(eCapture);
+					pPlayer->SelectDefaultDevice(eRender, eConsole);
+					pPlayer->SelectDefaultDevice(eCapture, eConsole);
+					pPlayer->SelectDeviceFromList(eCapture, 0);
+					//pPlayer->SelectDeviceFromList(eRender, 2);
+			        if (pPlayer->Play(eCaptureEndpoint) == FALSE) {
+						return TRUE;
+					}
+				}
+				#endif
+			} else {
+				SendMessage(hWnd, BM_SETSTATE, TRUE, 0);
+				ret = 0;
+			}
+			return ret;
+
+		case WM_MOUSEMOVE:
+			if (blockmousemove) return 0;
+			break;
+
+		case WM_LBUTTONUP:
+			ret = CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
+			if (SendDlgItemMessage(GetParent(hWnd), IDC_LOCK, BM_GETSTATE, 0, 0) != BST_CHECKED) {
+				blockmousemove = 0;
+				KillTimer(hMainDLG, 2234);
+				KillTimer(hMainDLG, 2235);
+				if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != 0) {
+					clock_t myTime = clock();
+					if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
+					if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
+				}
+				FadeOut = 0;
+				SetTimer(hMainDLG, 2234, 10, NULL); // fade in
+				SetTimer(hMainDLG, 2235, 10, NULL); // fade in
+			} else {
+				SendMessage(hWnd, BM_SETSTATE, TRUE, 0);
+				ret = 0;
+			}
+			return ret;
+	}
+	return CallWindowProcW(prevButtonProc, hWnd, uMsg, wParam, lParam);
+}
+
+int CALLBACK EncFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	switch (uMsg) {
+		case WM_INITDIALOG:
+			{
+				// doing this to get the button + combobox to appear as the same size when scrolling through them all
+				RECT r;
+				GetClientRect(GetDlgItem(hDlg, IDC_ENCSETTINGS), &r);
+				MapWindowPoints(GetDlgItem(hDlg, IDC_ENCSETTINGS), hDlg, (LPPOINT)&r,2);
+				InflateRect(&r, 1, 1);
+				SetWindowPos(GetDlgItem(hDlg, IDC_ENCSETTINGS_BUTTON), 0, r.left, r.top, r.right-r.left, r.bottom-r.top, SWP_NOZORDER|SWP_NOACTIVATE);
+			}
+			break;
+		case WM_COMMAND:
+			{
+				switch (LOWORD(wParam)) {
+				case IDC_ENCODERLIST:
+					{
+						if (HIWORD(wParam) == LBN_SELCHANGE) {
+							MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+							Encoder_CurSelPos = Out->Encoder;
+
+							if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
+								C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+								HWND e = hDlg;
+								SendDlgItemMessage(e, IDC_ENCTYPE, CB_RESETCONTENT, 0, 0);
+								int item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_NONE, NULL, 0));
+								SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"None");
+
+								item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_MP3_ENCODER, NULL, 0));
+								SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"MP3 Encoder");
+
+								if (C_ENCODER_FHGAAC::isPresent(module.hwndParent)) {
+									item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_FHGAAC_ENCODER, NULL, 0));
+									SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"Fraunhofer Encoder");
+								} else if (C_ENCODER_AACP::isPresent(module.hwndParent)) {
+									item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_AACP_ENCODER, NULL, 0));
+									SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"AAC+ Encoder");
+								}
+#ifdef USE_OGG
+								if (C_ENCODER_OGG::isPresent(module.hwndParent)) {
+									// TODO
+									item = SendDlgItemMessageW(e, IDC_ENCTYPE, CB_ADDSTRING, 0, (LPARAM) L"OGG Vorbis Encoder"/*LocalisedString(IDS_OGG_ENCODER, NULL, 0)*/);
+									SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETITEMDATA, item, (LPARAM)"OGG Vorbis Encoder");
+								}
+#endif // USE_OGG
+
+								SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_RESETCONTENT, 0, 0);
+								SetEncoderPanelMode(e, Enc);
+
+								int attribnum = 0, typeval = 0;
+								if (Enc) {
+									int i;
+									for (int i = 0; i < NUM_ENCODERS; i++) {
+										char* encoder = (char*)SendDlgItemMessage(e, IDC_ENCTYPE, CB_GETITEMDATA, i, 0);
+										if (!strcmp(Enc->GetName(), encoder)) {
+											typeval = i;
+											break;
+										}
+									}
+
+									int infosize = sizeof (T_EncoderIOVals);
+									T_ENCODER_MP3_INFO *EncInfo = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
+									for (i = Enc->GetNumAttribs() - 1; i >= 0; i--) {
+										T_ATTRIB attrib;
+										Enc->EnumAttrib(i, &attrib);
+										SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_INSERTSTRING, 0, (LPARAM) attrib.Text);
+										T_ENCODER_MP3_INFO *OutVal = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
+										if (OutVal && EncInfo && infosize) {
+											T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) EncInfo;
+											if(OutVal->output_bitRate == EncSettings->output_bitRate &&
+											   OutVal->output_sampleRate == EncSettings->output_sampleRate &&
+											   OutVal->output_numChannels == EncSettings->output_numChannels) {
+												attribnum = i;
+											}
+										}
+									}
+								} else {
+									SendDlgItemMessageW(e, IDC_ENCSETTINGS, CB_ADDSTRING, 0, (LPARAM) LocalisedString(IDS_NONE, NULL, 0));
+									ShowWindowDlgItem(e, IDC_ENCSETTINGS, SW_HIDE);
+									ShowWindowDlgItem(e, IDC_ENCSETTINGS_BUTTON, SW_HIDE);
+									SetDlgItemTextW(e, IDC_ENCSETTINGS_LABEL, LocalisedString(IDS_NO_ENCODER_SELECTED, NULL, 0));
+								}
+
+								SendDlgItemMessage(e, IDC_ENCSETTINGS, CB_SETCURSEL, attribnum, 0);
+								SendDlgItemMessage(e, IDC_ENCTYPE, CB_SETCURSEL, typeval, 0);
+								ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
+								ini_modified = 1;
+								SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_ENCSETTINGS, CBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_ENCSETTINGS));
+							}
+						}
+					}
+					break;
+
+				case IDC_ENCTYPE:
+					{
+						if (HIWORD(wParam) == CBN_SELCHANGE) {
+							int typenum = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
+
+							// check to see if this is the same encoder as last time as
+							// there's no need to update it if there hasn't been a change
+							// so selecting the same encoder won't cause a settings reset
+							if (typenum && typenum == Enc_LastType[Encoder_CurSelPos]) break;
+							else Enc_LastType[Encoder_CurSelPos] = typenum;
+
+							char* typestr = (char*)SendMessage((HWND) lParam, CB_GETITEMDATA, typenum, 0);
+							if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
+								if (!strcmpi("MP3 Encoder", typestr)) {
+									//lame setup
+									Encoder[Encoder_CurSelPos].SetLame(init, params, encode, finish);
+									Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_MP3(init, params, encode, finish), 1);
+
+									C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+
+									if (Enc) {
+										if (strcmpi(Enc->GetName(), "MP3 Encoder") == 0) {
+											T_ENCODER_MP3_INFO EncSettings;
+											int infosize = sizeof (EncSettings);
+											T_ENCODER_MP3_INFO *encset = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
+											if (encset && infosize)
+												memcpy(&EncSettings, encset, infosize);
+
+											EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+											EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+											EncSettings.output_bitRate = MP3_DEFAULT_OUTPUTBITRATE;
+											EncSettings.output_sampleRate = MP3_DEFAULT_OUTPUTSAMPLERATE;
+											EncSettings.output_numChannels = MP3_DEFAULT_OUTPUTNUMCHANNELS;
+											Enc->ChangeSettings(&EncSettings);
+										}
+									}
+								} else if (!strcmpi("Fraunhofer Encoder", typestr)) { // FHG AAC
+									Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_FHGAAC(module.hwndParent), 1);
+
+									C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+									if (Enc) {
+										T_ENCODER_FHGAAC_INFO EncSettings;
+										int infosize = sizeof (EncSettings);
+										T_ENCODER_FHGAAC_INFO *encset = (T_ENCODER_FHGAAC_INFO *) Enc->GetExtInfo(&infosize);
+										if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+										EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+										EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+										Enc->ChangeSettings(&EncSettings);
+									}
+								} else if (!strcmpi("AAC+ Encoder", typestr)) { //AAC+
+									Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_AACP(module.hwndParent), 1);
+
+									C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+									if (Enc) {
+										T_ENCODER_AACP_INFO EncSettings;
+										int infosize = sizeof (EncSettings);
+										T_ENCODER_AACP_INFO *encset = (T_ENCODER_AACP_INFO *) Enc->GetExtInfo(&infosize);
+										if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+										EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+										EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+										Enc->ChangeSettings(&EncSettings);
+									}
+								}
+#ifdef USE_OGG
+								else if (!strcmpi("OGG Vorbis Encoder", typestr)) { //OGG
+									Encoder[Encoder_CurSelPos].SetEncoder(new C_ENCODER_OGG(module.hwndParent), 1);
+
+									C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+									if (Enc) {
+										T_ENCODER_OGG_INFO EncSettings;
+										int infosize = sizeof (EncSettings);
+										T_ENCODER_OGG_INFO *encset = (T_ENCODER_OGG_INFO *) Enc->GetExtInfo(&infosize);
+										if (encset && infosize) memcpy(&EncSettings, encset, infosize);
+										EncSettings.input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+										EncSettings.input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+										Enc->ChangeSettings(&EncSettings);
+									}
+								}
+#endif // USE_OGG
+								else {
+									int i;
+									for (i = 0; i < NUM_OUTPUTS; i++) {
+										MY_T_OUTPUT *Out = &Output[i];
+										if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle);
+									}
+									Encoder[Encoder_CurSelPos].SetEncoder(NULL);
+								}
+
+								// if we can re-map the extension then we do so against the encoder selected
+								// which will override what was manually set but this ensures it is correct!
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								if (Out->saveEncodedPath[0] && typenum != 0) {
+									PathRemoveExtensionW(Out->saveEncodedPath);
+									PathAddExtensionW(Out->saveEncodedPath,
+													  (Enc_LastType[Connection_CurSelPos] != 0 ?
+													   (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg") ? L".mp3" :
+													    (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/ogg") ? L".ogg" : L".aac")) : L""));
+
+									// update things as the filename was changed
+									SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, Out->saveEncodedPath);
+									if (Out->saveEncoded) {
+										StopSaveEncoded(Connection_CurSelPos);
+										StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
+									}
+								}
+
+								SetEncoderPanelMode(hDlg, Encoder[Encoder_CurSelPos].GetEncoder());
+								ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
+								ini_modified = 1;
+								SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_ENCODERLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_ENCODERLIST));
+							}
+						}
+					}
+					break;
+
+				case IDC_ENCSETTINGS_BUTTON:
+					{
+						C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+						if (Enc) if (Enc->UseNsvConfig()) {
+							((C_ENCODER_NSV*) Enc)->Configure(hDlg, module.hDllInstance);
+							if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
+								ini_modified = 1;
+								for (int i = 0; i < NUM_OUTPUTS; i++) {
+									MY_T_OUTPUT *Out = &Output[i];
+									if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) {
+										Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle, 1, 5);
+									}
+								}
+								ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
+							}
+						}
+						SetEncoderPanelMode(hDlg, Enc);
+					}
+					break;
+
+				case IDC_ENCSETTINGS:
+					{
+						if (HIWORD(wParam) == CBN_SELCHANGE) {
+							T_ATTRIB attrib;
+							int attribnum = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
+							if (WaitForSingleObject(Enc_mutex[Encoder_CurSelPos], INFINITE) == WAIT_OBJECT_0) {
+								C_ENCODER *Enc = Encoder[Encoder_CurSelPos].GetEncoder();
+								if (Enc) {
+									int i;
+									if (attribnum < 0 || attribnum >= Enc->GetNumAttribs()) attribnum = 0;
+									int oldattrib = -1;
+									int infosize = sizeof (T_EncoderIOVals);
+									T_EncoderIOVals *EncInfo = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
+									for (i = Enc->GetNumAttribs() - 1; i >= 0 && oldattrib == -1; i--) {
+										Enc->EnumAttrib(i, &attrib);
+										if (attrib.OutputVals && EncInfo && infosize) {
+											T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
+											T_ENCODER_MP3_INFO *EncSettings2 = (T_ENCODER_MP3_INFO *) EncInfo;
+											//if (memcmp(attrib.OutputVals, EncInfo, infosize) == 0) oldattrib = i;
+											if(EncSettings2->output_bitRate == EncSettings->output_bitRate &&
+											   EncSettings2->output_sampleRate == EncSettings->output_sampleRate &&
+											   EncSettings2->output_numChannels == EncSettings->output_numChannels) {
+												oldattrib = i;
+											}
+										}
+									}
+									if (attribnum != oldattrib) {
+										if (Enc->EnumAttrib(attribnum, &attrib)) {
+											// we make sure that we set the input channels and samplerate to
+											// that of the mode being used instead of the default values as
+											// this allows us to get things to work correctly (done in 2.3.2)
+											T_ENCODER_MP3_INFO *EncSettings = (T_ENCODER_MP3_INFO *) attrib.OutputVals;
+											if(InputDevice == 1) {
+												EncSettings->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+												EncSettings->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+											}
+											Enc->ChangeSettings(EncSettings);
+											ini_modified = 1;
+											for (i = 0; i < NUM_OUTPUTS; i++) {
+												MY_T_OUTPUT *Out = &Output[i];
+												if (Out->Encoder == Encoder_CurSelPos && Out->Handle != -1) {
+													Encoder[Encoder_CurSelPos].DisconnectOutput(Out->Handle, 1, 5);
+												}
+											}
+										}
+									}
+								}
+								ReleaseMutex(Enc_mutex[Encoder_CurSelPos]);
+							}
+						}
+					}
+					break;
+				}//switch
+			}
+			break;
+	}// umsg
+	return CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
+}
+
+/* Connection Page callback */
+INT_PTR CALLBACK ConnectionFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	switch (uMsg) {
+		case WM_INITDIALOG:
+			{
+				switch (lParam) {
+					case IDD_CONNECTION:
+						{
+							int i;
+							wchar_t temp[128];
+							SendDlgItemMessage(hDlg, IDC_OUTPUTLIST, LB_RESETCONTENT, 0, 0);
+							for (i = 0; i < NUM_OUTPUTS; i++) {
+								T_OUTPUT_CONFIG *Out = &Output[i].Config;
+								SendDlgItemMessageW(hDlg, IDC_OUTPUTLIST, LB_ADDSTRING, 0, (LPARAM) Out->DisplayName);
+							}
+							SendDlgItemMessage(hDlg, IDC_OUTPUTLIST, LB_SETCURSEL, Connection_CurSelPos, 0);
+							num_outwnds = 0;
+							SendDlgItemMessage(hDlg, IDC_CONTAB, TCM_DELETEALLITEMS, 0, 0);
+							AddOutTab(IDD_PANEL_LOGIN, LocalisedString(IDS_PANEL_LOGIN, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							AddOutTab(IDD_PANEL_DIRECTORY, LocalisedString(IDS_PANEL_DIRECTORY, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							AddOutTab(IDD_ENCODER, LocalisedString(IDS_PANEL_ENCODERS, temp, 128), hDlg, EncFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							AddOutTab(IDD_PANEL_TITLE, LocalisedString(IDS_PANEL_TITLES, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							AddOutTab(IDD_ARTWORK, LocalisedString(IDS_PANEL_ART, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							AddOutTab(IDD_LOGGING, LocalisedString(IDS_PANEL_LOGGING, temp, 128), hDlg, DialogFunc, IDC_CONTAB, IDC_PANELRECT_C, 0);
+							SetOutTab(curouttab, hDlg, IDC_CONTAB);
+							SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_OUTPUTLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_OUTPUTLIST));
+							SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK,Output[Connection_CurSelPos].AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
+						}
+						break;
+				}//lparam
+			}
+			return 0;
+	}//uMsg
+	return CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
+}
+
+void ShowUpdateMessage(HWND hDlg)
+{
+	bool update = (updateStr && updateStr[0]);
+	if (IsWindow(hDlg))
+	{
+		HWND control = GetDlgItem(hDlg, IDC_UPDATE_HEADER);
+		if (update)
+		{
+			wchar_t message[128] = {0};
+			StringCchPrintfW(message, ARRAYSIZE(message), WASABI_API_LNGSTRINGW(IDS_UPDATE_HEADER), updateStr);
+
+			SetWindowTextW(control, message);
+			SetBoldDialogItemFont(control);
+		}
+		else 
+		{
+			SetWindowTextW(control, WASABI_API_LNGSTRINGW(IDS_UPDATE));
+			SendMessageW(control, WM_SETFONT, SendMessageW(hMainDLG, WM_GETFONT, 0, 0), 0);
+			InvalidateRect(hDlg, 0, TRUE);
+		}
+
+		ShowWindowDlgItem(hDlg, IDC_STATIC_UPDATE, update);
+		ShowWindowDlgItem(hDlg, IDC_UPDATELINK, update);
+	}
+
+	SetWindowTextW(hMainDLG, WASABI_API_LNGSTRINGW((update ? IDS_UPDATE_TITLE : IDS_MODULE_NAME)));
+
+	if (IsWindow(tabWnd)) {
+		RECT r = {0};
+		TabCtrl_GetItemRect(tabWnd, 3, &r);
+		InvalidateRect(tabWnd, &r, 0);
+	}
+}
+
+class VersionCheckCallback : public ifc_downloadManagerCallback
+{
+public:
+	void OnInit( DownloadToken token )
+	{
+		api_httpreceiver *http = WAC_API_DOWNLOADMANAGER->GetReceiver( token );
+		if ( http )
+		{
+			http->AllowCompression();
+			http->addheader( "Accept: */*" );
+		}
+	}
+
+	void OnFinish( DownloadToken token )
+	{
+		api_httpreceiver *http = WAC_API_DOWNLOADMANAGER->GetReceiver( token );
+		if ( http && http->getreplycode() == 200 )
+		{
+			char *buf = 0;
+			size_t size = 0;
+			if ( WAC_API_DOWNLOADMANAGER->GetBuffer( token, (void **)&buf, &size ) == 0 && size > 0 )
+			{
+				buf[ size - 1 ] = 0;
+
+				char *p = buf;
+				while ( size && ( *p == ' ' || *p == '\t' || *p == '\r' || *p == '\n' ) )
+				{
+					p++;
+					size--;
+				}
+
+				// e.g. dsp_sc,2.3.4.210,http://download.nullsoft.com/shoutcast/tools/shoutcast-dsp-2-3-4-windows.exe
+				if ( p && *p )
+				{
+					char *tok = strtok( p, "," );
+					if ( tok )
+					{
+						if ( !strncmp( tok, "dsp_sc", 6 ) )
+						{
+							tok = strtok( NULL, "," );
+							if ( tok )
+							{
+								bool needsUpdating = CompareVersions( tok );
+								lstrcpyn( updateStr, ( needsUpdating ? tok : "" ), ARRAYSIZE( updateStr ) );
+								WritePrivateProfileString( APP_Name, "Update", ( needsUpdating ? updateStr : 0 ), IniName );
+								ShowUpdateMessage( updateWnd );
+								if ( !needsUpdating )
+								{
+									ShowWindowDlgItem( updateWnd, IDC_STATIC_UPDATE, TRUE );
+								}
+								SetDlgItemTextW( updateWnd, IDC_STATIC_UPDATE, WASABI_API_LNGSTRINGW( ( needsUpdating ? IDS_HAS_NEW_UPDATE : IDS_NO_NEW_UPDATE ) ) );
+							}
+						}
+					}
+				}
+			}
+		}
+
+		if ( IsWindow( updateWnd ) )
+		{
+			EnableWindowDlgItem( updateWnd, IDC_GET_UPDATE, TRUE );
+			SetDlgItemTextW( updateWnd, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
+		}
+	}
+
+	void OnError( DownloadToken token )
+	{
+		if ( IsWindow( updateWnd ) )
+		{
+			ShowWindowDlgItem( updateWnd, IDC_STATIC_UPDATE, TRUE );
+			SetDlgItemTextW( updateWnd, IDC_STATIC_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_UPDATE_FAIL ) );
+			EnableWindowDlgItem( updateWnd, IDC_GET_UPDATE, TRUE );
+			SetDlgItemTextW( updateWnd, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
+		}
+	}
+
+	RECVS_DISPATCH;
+};
+
+#define CBCLASS VersionCheckCallback
+START_DISPATCH;
+VCB( IFC_DOWNLOADMANAGERCALLBACK_ONINIT,   OnInit )
+VCB( IFC_DOWNLOADMANAGERCALLBACK_ONFINISH, OnFinish )
+VCB( IFC_DOWNLOADMANAGERCALLBACK_ONERROR,  OnError )
+END_DISPATCH;
+#undef CBCLASS
+
+static VersionCheckCallback versionCheckCallback;
+
+static void CheckVersion( HWND hDlg )
+{
+	ShowWindowDlgItem( hDlg, IDC_STATIC_UPDATE, FALSE );
+	ShowWindowDlgItem( hDlg, IDC_UPDATELINK, FALSE );
+
+	if ( WAC_API_DOWNLOADMANAGER )
+	{
+		char url[ 128 ] = { 0 };
+		StringCchPrintf( url, ARRAYSIZE( url ), "http://yp.shoutcast.com/update?c=dsp_sc&v=%s&wa=%x", APP_Version, GetWinampVersion( module.hwndParent ) );
+		updateWnd = hDlg;
+		WAC_API_DOWNLOADMANAGER->DownloadEx( url, &versionCheckCallback, api_downloadManager::DOWNLOADEX_BUFFER );
+	}
+	else
+	{
+		wchar_t title[ 128 ] = { 0 }, message[ 512 ] = { 0 };
+		StringCchPrintfW( title, ARRAYSIZE( title ), LocalisedString( IDS_PLUGIN_NAME, NULL, 0 ), APP_VersionW );
+		StringCchPrintfW( message, ARRAYSIZE( message ), LocalisedString( IDS_UPDATE_CHECK_ERROR, NULL, 0 ) );
+		if ( MessageBoxW( module.hwndParent, message, title, MB_ICONWARNING | MB_YESNO ) == IDYES )
+		{
+			SendMessage( module.hwndParent, WM_WA_IPC, (WPARAM)DOWNLOAD_URL, IPC_OPEN_URL );
+		}
+		SetDlgItemTextW( hDlg, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW( IDS_CHECK_FOR_UPDATES ) );
+		EnableWindowDlgItem( hDlg, IDC_GET_UPDATE, TRUE );
+	}
+}
+
+INT_PTR CALLBACK AboutFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	if (uMsg == WM_COMMAND) {
+		switch(LOWORD(wParam))
+		{
+			case IDC_ABOUTLINK:
+			{
+				SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)"http://www.shoutcast.com/", IPC_OPEN_URL);
+			}
+			break;
+
+			case IDC_HELPLINK:
+			{
+				// look for a lcoal copy of the documentation otherwise then do as before and use the wiki verison
+				wchar_t path[MAX_PATH] = {0};
+				StringCchPrintfW(path, ARRAYSIZE(path), L"%s\\SHOUTcast Source DSP\\Source_DSP_Plug-in.html", GetPluginDirectoryW(module.hwndParent));
+				if(ShellExecuteW(module.hwndParent, L"open", path, NULL, NULL, SW_SHOWNORMAL) < (HINSTANCE)32)
+				{
+					SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)L"http://wiki.shoutcast.com/wiki/Source_DSP_Plug-in", IPC_OPEN_URL);
+				}
+			}
+			break;
+
+			case IDC_FORUMLINK:
+			{
+				SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)L"http://forums.shoutcast.com/forumdisplay.php?f=140", IPC_OPEN_URL);
+			}
+			break;
+
+			case IDC_UPDATELINK:
+			{
+				SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)DOWNLOAD_URL, IPC_OPEN_URL);
+			}
+			break;
+
+			case IDC_ABOUT_ICON:
+			{
+				if (HIWORD(wParam) == STN_DBLCLK) {
+					static bool toggle;
+					SendDlgItemMessage(hDlg, IDC_ABOUT_ICON, STM_SETIMAGE, IMAGE_ICON, (LPARAM)GetICYIcon(!toggle));
+					SendMessage(hMainDLG, WM_SETICON, ICON_SMALL, (LPARAM)GetICYIcon(!toggle));
+					toggle = !toggle;
+				}
+			}
+			break;
+
+			case IDC_GET_UPDATE:
+			{
+				EnableWindowDlgItem(hDlg, IDC_GET_UPDATE, FALSE);
+				SetDlgItemTextW(hDlg, IDC_GET_UPDATE, WASABI_API_LNGSTRINGW(IDS_CHECKING_FOR_UPDATES));
+				CheckVersion(hDlg);
+			}
+			break;
+		}
+	}
+	LRESULT ret = CallWindowProcW((WNDPROC)DialogFunc, hDlg, uMsg, wParam, lParam);
+	link_handledraw(hDlg, uMsg, wParam, lParam);
+	return ret;
+}
+
+void UpdateTitleControls(void) {
+	MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+	if (Out->Config.doTitleUpdate) {
+		int length = (GetWindowTextLength(GetDlgItem(out_wnd[3].hWnd, IDC_TITLE)) > 0);
+		int sc2mode = (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
+
+		EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, Out->AutoTitle && !sc2mode);
+
+		if (Out->AutoTitle) {
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, FALSE);
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, FALSE);
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, FALSE);
+		} else {
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, length);
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, TRUE);
+			EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, !sc2mode && length);
+		}
+	} else {
+		EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, FALSE);
+		EnableWindowDlgItem(out_wnd[3].hWnd, IDC_TITLE, FALSE);
+		EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT, FALSE);
+		EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, FALSE);
+	}
+}
+
+void LockOptionControls(BOOL unlock) {
+	int protocol = LOBYTE(Output[Connection_CurSelPos].Config.protocol),
+		automatic = (HIBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
+	BOOL sc1 = (protocol == 1);
+
+	// First Connection panel
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_ADDRESS, unlock);
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PORT, unlock);
+	// ensure the SC2 items are enabled only if SC1 mode is disabled
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_STATIONID, (sc1 ? FALSE : unlock));
+
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_USERID, unlock);
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PASSWORD, unlock);
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_RECONNECT, unlock);
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_TIMEOUT, unlock);
+	EnableWindowDlgItem(out_wnd[0].hWnd, IDC_PROTOCOL, unlock);
+
+	// controls the information shown on the connection panel
+	//ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_FRAME2, !sc1);
+	ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT2, (protocol == 2) && !automatic);
+	ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT3, (protocol == 1) && !automatic);
+	ShowWindowDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT4, automatic);
+
+	// artwork panel controls
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_V1_NOTE, sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ARTWORK_V1_FRAME, sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ART_V2_NOTE, !sc1);
+	ShowWindowDlgItem(out_wnd[4].hWnd, IDC_ARTWORK_V2_FRAME, !sc1);
+
+	// Second Connection panel
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_PUBLIC, unlock);
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_DESCRIPTION, unlock);
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_SERVERURL, unlock);
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_GENRE, FALSE);
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_GENRES, unlock);
+	// ensure the SC1 items are enabled only if SC1 mode is enabled
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_AIM, (!sc1 ? FALSE : unlock));
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_ICQ, (!sc1 ? FALSE : unlock));
+	EnableWindowDlgItem(out_wnd[1].hWnd, IDC_IRC, (!sc1 ? FALSE : unlock));
+
+	// Encoder tab
+	EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCTYPE, unlock);
+	EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCSETTINGS_BUTTON, unlock);
+	EnableWindowDlgItem(out_wnd[2].hWnd, IDC_ENCSETTINGS, unlock);
+}
+
+void WritePrivateProfileInt(LPCSTR lpKeyName, int value, LPCSTR lpAppName, LPCSTR lpFileName) {
+	char tmp[64] = {0};
+	StringCchPrintfA(tmp, ARRAYSIZE(tmp), "%u", value);
+	WritePrivateProfileString((!lpAppName ? APP_Name : lpAppName), lpKeyName, tmp, (!lpFileName ? IniName : lpFileName));
+}
+
+wchar_t* GetFileMetaData(wchar_t* file, wchar_t* metadata, wchar_t* buffer, int buffer_len) {
+extendedFileInfoStructW efs;
+	efs.filename=file;
+	efs.metadata=metadata;
+	efs.ret=buffer;
+	efs.retlen=buffer_len;
+	SendMessage(module.hwndParent, WM_WA_IPC, (WPARAM)&efs, IPC_GET_EXTENDED_FILE_INFOW);
+	return buffer;
+}
+
+void UpdateNextTracks(wchar_t* next, int pos, std::vector<int> &nextListIdx, std::vector<std::wstring> &nextList) {
+	nextList.clear();
+	nextListIdx.clear();
+
+	int queued = (WASABI_API_QUEUEMGR ? WASABI_API_QUEUEMGR->GetNumberOfQueuedItems() : 0);
+	if (WASABI_API_QUEUEMGR && queued) {
+		for (int i = 0; i < queued && (lookAhead == -1 ? 1 : i < lookAhead); i++) {
+			int idx = WASABI_API_QUEUEMGR->GetQueuedItemFromIndex(i);
+			nextList.push_back((wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, idx, IPC_GETPLAYLISTTITLEW));
+			nextListIdx.push_back(idx);
+		}
+	} else {
+		if (next[0]) {
+			nextList.push_back(next);
+			nextListIdx.push_back(pos);
+		}
+	}
+}
+
+int GetNextTracks(int len, int pos, wchar_t* next) {
+	int nextpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETNEXTLISTPOS);
+
+	// attempt to use the new look ahead api in 5.61+ otherwise use existing
+	// method or if the new api returns a failure just to cover all bases
+	if (doNextLookAhead && nextpos != -1 && len >= 1) {
+		wcscpy_s((wchar_t*)next, 1024, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, nextpos, IPC_GETPLAYLISTTITLEW));
+	} else {
+		// get the next title (as long as shuffle is off, etc)
+		// with it mapped back to the first track as appropriate
+		if (len >= 2 && !SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GET_SHUFFLE)) {
+			pos = (pos >= len ? 0 : pos);
+			wcscpy_s((wchar_t*)next, 1024, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, pos, IPC_GETPLAYLISTTITLEW));
+		}
+	}
+	return pos;
+}
+
+void FillNextTracks(int index, bool xml) {
+	// on change then we refresh the file as applicable
+	std::vector<std::wstring> nextList;
+	std::vector<int> nextListIdx;
+	wchar_t next[1024] = {0};
+	int curpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS);
+	int len = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTLENGTH);
+	int pos = curpos + 1;
+	pos = GetNextTracks(len, pos, next);
+	UpdateNextTracks(next, pos, nextListIdx, nextList);
+	WriteNextTracks(index, module.hwndParent, nextListIdx, nextList, xml);
+}
+
+static ARGB32 *loadImgFromFile(const wchar_t *file, int *len)
+{
+	*len = 0;
+	HANDLE hf = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
+	if (hf != INVALID_HANDLE_VALUE)
+	{
+		*len = GetFileSize(hf, 0);
+		if (WASABI_API_MEMMGR) {
+			ARGB32* im = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(*len);
+			if (im) {
+				DWORD bytes_read;
+				ReadFile(hf, im, *len, &bytes_read, 0);
+				CloseHandle(hf);
+				return im;
+			}
+		}
+		CloseHandle(hf);
+	}
+	return (ARGB32 *)-1;
+}
+
+static wchar_t bytes[32], kilo[32], mega[32], giga[32], tera[32];
+wchar_t* sizeStr(unsigned int size) {
+	static wchar_t temp[256];
+	if (GetWinampVersion(module.hwndParent) >= 0x5064) {
+		// TODO swap over to the native Winamp version on newer clients
+		return WASABI_API_LNG->FormattedSizeString(temp, ARRAYSIZE(temp), size);
+	} else {
+		if (!bytes[0]) {
+			LocalisedString(IDS_B, bytes, ARRAYSIZE(bytes));
+			LocalisedString(IDS_KIB, kilo, ARRAYSIZE(kilo));
+			LocalisedString(IDS_MIB, mega, ARRAYSIZE(mega));
+			LocalisedString(IDS_GIB, giga, ARRAYSIZE(giga));
+		}
+
+		if(size < 1024) {
+			StringCchPrintfW(temp, ARRAYSIZE(temp), L"%u %s", size, bytes);
+		} else if(size < 1048576) {
+			StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1024.0f), kilo);
+		} else if(size < 1073741824) {
+			StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1048576.0f), mega);
+		} else if(size < 1099511627776){
+			StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1073741824.0f), giga);
+		} else{
+			StringCchPrintfW(temp, ARRAYSIZE(temp), L"%.02f %s", (size / 1073741824.0f), tera);
+		}
+	}
+	return temp;
+}
+
+void UpdateArtworkMessage() {
+	MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+	SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
+	wchar_t buf[1024], playing[256], stream[256];
+	T_OUTPUT_INFO *Info = Enc->GetOutputInfo(Out->Handle);
+	int streamSize = (Info ? Info->art_cached_length[0] : 0),
+		playingSize = (Info ? Info->art_cached_length[1] : 0);
+
+	StringCchPrintfW(stream, ARRAYSIZE(stream),
+					 WASABI_API_LNGSTRINGW(!Out->useArt || !Out->useStreamArt ? IDS_DISABLED :
+					 (streamSize == 0 ? IDS_EMPTY_ART : IDS_ENABLED_SIZE)),
+					 sizeStr(streamSize));
+
+	StringCchPrintfW(playing, ARRAYSIZE(playing),
+					 WASABI_API_LNGSTRINGW(!Out->useArt || !Out->usePlayingArt ? IDS_DISABLED :
+					 (playingSize == 0 ? IDS_EMPTY_ART : IDS_ENABLED_SIZE)),
+					 sizeStr(playingSize));
+
+	StringCchPrintfW(buf, ARRAYSIZE(buf), WASABI_API_LNGSTRINGW(IDS_V2_ARTWORK), stream, playing);
+	SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_V2_NOTE, buf);
+}
+
+void UpdatePlayingAlbumArt(int Connection, int Index, bool usePlayingArt) {
+	// do some quick checks as no need to send if not applicable to do so
+	if (!usePlayingArt && !playingImage) {
+		return;
+	}
+
+	// hard code the playing art to be sent in png format
+	Encoder[Index].UpdateAlbumArtCache((usePlayingArt ? playingImage : 0),
+									   (usePlayingArt ? playingLength : 0),
+									   playingType, Connection);
+	UpdateArtworkMessage();
+}
+
+bool UpdateStreamAlbumArt(int Connection, int Index, const wchar_t* stationArtPath, bool useStreamArt) {
+	int artType = 0x0;
+	bool update = false;
+
+	// if not enabled and loaded then unload and refresh
+	if (!useStreamArt && streamImage[Index] != (ARGB32 *)-1) {
+		FreeStreamAlbumArt(Index);
+		// bit of a fiddle to force a dummy update
+		artType = 0x4000;
+		update = true;
+	} else if (useStreamArt && streamImage[Index] != (ARGB32 *)-1) {
+		FreeStreamAlbumArt(Index);
+	}
+
+	// if enabled and not loaded then attempt to load
+	if (!update && streamImage[Index] == (ARGB32 *)-1) {
+		if (useStreamArt) {
+			streamImage[Index] = loadImgFromFile(stationArtPath, &streamLength[Index]);
+
+			wchar_t* ext = PathFindExtensionW(stationArtPath);
+			if (ext) {
+				if (*ext) ext++;
+
+				update = true;
+				if (!wcsnicmp(ext, L"jpeg", 4) || !wcsnicmp(ext, L"jpg", 3)) {
+					artType = 0x4000;
+				} else if (!wcsnicmp(ext, L"png", 3)) {
+					artType = 0x4001;
+				} else if (!wcsnicmp(ext, L"bmp", 3)) {
+					artType = 0x4002;
+				} else if (!wcsnicmp(ext, L"gif", 3)) {
+					artType = 0x4003;
+				} else {
+					update = false;
+				}
+			}
+		} else {
+			// if not enabled and not loaded then do nothing
+			UpdateArtworkMessage();
+			return false;
+		}
+	}
+
+	if (update) {
+		Encoder[Index].UpdateAlbumArtCache((!useStreamArt || streamImage[Index] == (ARGB32 *)-1 ? 0 : streamImage[Index]),
+										   (!useStreamArt ? 0: streamLength[Index]), artType, Connection);
+	}
+	UpdateArtworkMessage();
+	return update;
+}
+
+void UpdateVUMeters()
+{
+	int volume = 0;
+	int vu_l = VU.vu_l;
+	int vu_r = VU.vu_r;
+	VU.vu_l = 0;
+	VU.vu_r = 0;
+	VU.lastUpdate = VU.update;
+	VU.update = 0;
+	wchar_t tmp[256], temp[32], temp2[32];
+
+	if (vu_l != 0) {
+		volume = (int) (20 * log10((double) vu_l));
+		StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
+	} else {
+		volume = 0;
+		LocalisedString(IDS_INF_DB, tmp, 256);
+	}
+	if (volume - 90 > peak_vu_l) {
+		StringCchPrintfW(temp2, ARRAYSIZE(temp2), LocalisedString(IDS_X_DB_PEAK, temp, 32), (peak_vu_l = volume - 90));
+		SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_LP, temp2);
+		SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_LP, temp2);
+	}
+
+	SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_L, tmp);
+	SendDlgItemMessage(wnd[0].hWnd, IDC_VOLUMEGRAPH_L, PBM_SETPOS, volume, 0);
+	SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_L, tmp);
+	SendDlgItemMessage(wnd[2].hWnd, IDC_VOLUMEGRAPH_L, PBM_SETPOS, volume, 0);
+	if (vu_r != 0) {
+		volume = (int) (20 * log10((double) vu_r));
+		StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
+	} else {
+		volume = 0;
+		LocalisedString(IDS_INF_DB, tmp, 256);
+	}
+	if (volume - 90 > peak_vu_r) {
+		StringCchPrintfW(temp2, ARRAYSIZE(temp2), LocalisedString(IDS_X_DB_PEAK, temp, 32), (peak_vu_r = volume - 90));
+		SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_RP, temp2);
+		SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_RP, temp2);
+	}
+
+	SetDlgItemTextW(wnd[0].hWnd, IDC_VOLUMETEXT_R, tmp);
+	SendDlgItemMessage(wnd[0].hWnd, IDC_VOLUMEGRAPH_R, PBM_SETPOS, volume, 0);
+	SetDlgItemTextW(wnd[2].hWnd, IDC_VOLUMETEXT_R, tmp);
+	SendDlgItemMessage(wnd[2].hWnd, IDC_VOLUMEGRAPH_R, PBM_SETPOS, volume, 0);
+}
+
+void UpdateSummaryDetails(int item) {
+	if (item == -1) {
+		return;
+	}
+
+	wchar_t message[2048], temp[128], temp2[128], temp3[128],
+			temp4[128] = {0}, temp5[128], temp6[128], temp7[128];
+	char temp8[128];
+	MY_T_OUTPUT *Out = &Output[item];
+	C_ENCODER *Enc = Encoder[Out->Encoder].GetEncoder();
+
+	if (Enc) {
+		StringCchPrintfW(temp4, ARRAYSIZE(temp4), LocalisedString(IDS_SUMMARY_KBPS, NULL, 0), ((T_EncoderIOVals*) Enc->GetExtInfo())->output_bitRate);
+	}
+
+	StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_SUMMARY, NULL, 0),
+					 // TODO show automatic mode ?
+					 (LOBYTE(Out->Config.protocol) != 1 ? 2 : 1),
+					 LocalisedString((Out->Config.Public ? IDS_PUBLIC : IDS_PRIVATE), temp, 128),
+					 (Out->Config.Address[0] ? Out->Config.Address : LocalisedStringA(IDS_NOT_SET_SUMMARY, temp8, 128)),
+					 Out->Config.Port,
+					 LocalisedString((Out->Config.doTitleUpdate ? (Out->AutoTitle ? IDS_FOLLOW_WA : IDS_MANUAL) : IDS_DISABLED), temp2, 128),
+					 (Enc_LastType[item] != 0 ? (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg")?L"MP3":L"AAC+") : LocalisedString(IDS_NOT_SET, temp3, 128)),
+					 temp4,
+					 LocalisedString((Out->Logging ? IDS_YES : IDS_NO), temp5, 128),
+					 LocalisedString((Out->AutoConnect ? IDS_YES : IDS_NO), temp6, 128),
+					 LocalisedString((Out->saveEncoded ? IDS_YES : IDS_NO), temp7, 128));
+
+	SetDlgItemTextW(wnd[0].hWnd, IDC_SUMMARY, message);
+
+	// see if we're looking at a incomplete setup and flag up the output tab as applicable
+	if (IsWindow(tabWnd)) {
+		RECT r = {0};
+		TabCtrl_GetItemRect(tabWnd, 1, &r);
+		if ((lastMode[item] >= 3 && lastMode[item] <= 6)) {
+			SetTabErrorText(tabWnd, 1, 0, &r);
+		} else {
+			InvalidateRect(tabWnd, &r, 0);
+		}
+	}
+}
+
+void ProcessPlayingStatusUpdate(void) {
+	if (isplaying == 1 && SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETOUTPUTTIME)) {
+		if (was_paused) {
+			was_paused = 0;
+			play_diff = GetTickCount();
+		}
+	} else if (isplaying == 3) {
+		// pause
+		was_paused = 1;
+	} else if (isplaying == 0 && was_playing == 1) {
+		// stop
+		was_playing = was_paused = 0;
+	} else if (isplaying == 0 && was_playing == 0) {
+		// non-playing track advance
+		PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
+	}
+}
+
+// check against a list of known "illegal" names as well as not allowing
+// the creation of a station with the name the same as a genre string
+bool stationNameAllowed(char* name){
+	if(name && *name)
+	{
+		int checked = 0;
+		for (int i = 0; i < ARRAYSIZE(genres); i++) {
+			checked += !lstrcmpi(name, genres[i].name);
+		}
+
+		// check for punctuation only titles with double-processing
+		// to strip out alphanum+space and space in second and then
+		// we compare a difference in lengths where different is ok
+		if (lstrlen(name) > 0) {
+			char* stripped = (char*)malloc(lstrlen(name)+1);
+			char* stripped2 = (char*)malloc(lstrlen(name)+1);
+			stripped[0] = 0;
+			for(int i = 0, j = 0; i < lstrlen(name); i++) {
+				if(!isalnum(name[i]) && name[i] != ' ') {
+					stripped[j] = name[i];
+					stripped[++j] = 0;
+				}
+			}
+			for(int i = 0, j = 0; i < lstrlen(name); i++) {
+				if(name[i] != ' ') {
+					stripped2[j] = name[i];
+					stripped2[++j] = 0;
+				}
+			}
+			checked += !(lstrlen(stripped2) > lstrlen(stripped));
+			free(stripped);
+			free(stripped2);
+		}
+
+		char* invalidNames[] = {"127.0.0.1", "admin", "auto dj", "auto jedi", "auto pj",
+								"auto-dj", "autodj", "autopj", "demo", "dj", "internet radio",
+								"live", "local server", "localhost", "localserver", "music",
+								"my radio", "my server", "my station name", "my test server",
+								"n/a", "pj", "playlist", "radio", "radio station", "test",
+								"test server", "unnamed server", "virtual dj", "virtualdj",
+								"web rdio", "web radio", "song", "teste", "default stream",
+								"radio stream", "whmsonic autodj", "autopilot",
+								"this is my server name"};
+		for(int i = 0; i < ARRAYSIZE(invalidNames); i++)
+		{
+			checked += !lstrcmpi(name, invalidNames[i]);
+		}
+		return (!checked);
+	}
+	return false;
+}
+
+HBITMAP WAResizeImage(HBITMAP hbmp, INT cx, INT cy) {
+	BITMAP bi = {0};
+	if (!hbmp || !GetObjectW(hbmp, sizeof(BITMAP), &bi)) return hbmp;
+
+	if (bi.bmWidth != cx || bi.bmHeight != cy) {
+		HDC hdc, hdcDst, hdcSrc;
+		HBITMAP hbmpOld1, hbmpOld2;
+
+		int ix = cy*(bi.bmWidth*1000/bi.bmHeight)/1000, iy;
+		if (ix > cx) { 
+			iy = cx*(bi.bmHeight*1000/bi.bmWidth)/1000; 
+			ix = cx;
+		}
+		else iy = cy;
+
+		hdc = GetDC(NULL);
+		hdcSrc = CreateCompatibleDC(hdc);
+		hdcDst = CreateCompatibleDC(hdc);
+		hbmpOld1 = (HBITMAP)SelectObject(hdcSrc, hbmp);
+		hbmp = CreateCompatibleBitmap(hdc, cx, cy);
+		hbmpOld2 = (HBITMAP)SelectObject(hdcDst, hbmp);
+		if (ix != cx || iy != cy) {
+			RECT r;
+			SetRect(&r, 0, 0, cx, cy);
+			FillRect(hdcDst, &r, GetSysColorBrush(COLOR_BTNFACE));
+		}
+		SetStretchBltMode(hdcDst, HALFTONE);
+		StretchBlt(hdcDst, (cx - ix)/2, (cy - iy)/2, ix, iy, hdcSrc, 0, 0, bi.bmWidth, bi.bmHeight, SRCCOPY);
+
+		SelectObject(hdcDst, hbmpOld2);
+		hbmpOld2 = (HBITMAP)SelectObject(hdcSrc, hbmpOld1);
+		if (hbmpOld2) DeleteObject(hbmpOld2);
+
+		DeleteDC(hdcSrc);
+		DeleteDC(hdcDst);
+		ReleaseDC(NULL, hdc);
+	}
+	return hbmp;
+}
+
+HBITMAP getBitmap(ARGB32 * data, int w, int h)
+{
+	BITMAPINFO info={0};
+	info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+	info.bmiHeader.biWidth = w;
+	info.bmiHeader.biHeight = -h;
+	info.bmiHeader.biPlanes = 1;
+	info.bmiHeader.biBitCount = 32;
+	info.bmiHeader.biCompression = BI_RGB;
+	HDC dc = GetDC(NULL);
+	HBITMAP bm = CreateCompatibleBitmap(dc, w, h);
+	SetDIBits(dc, bm, 0, h, data, &info, DIB_RGB_COLORS);
+	ReleaseDC(NULL, dc);
+	return WAResizeImage(bm, 155, 88);
+}
+
+ARGB32 * decompressImage(const void *data, int datalen, int * dataW, int * dataH) {
+	ARGB32* ret=NULL;
+	FOURCC imgload = svc_imageLoader::getServiceType();
+	int n = WASABI_API_SVC->service_getNumServices(imgload);
+	for (int i = 0; i < n; i++) {
+		waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgload,i);
+		if (sf) {
+			svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
+			if (l) {
+				if (l->testData(data,datalen)) {
+					ret = l->loadImage(data,datalen,dataW,dataH);
+					sf->releaseInterface(l);
+					break;
+				}
+				sf->releaseInterface(l);
+			}
+		}
+	}
+	return ret;
+}
+
+INT_PTR CALLBACK DialogFunc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	if (SYSTRAY_BASE_MSG + SYSTRAY_MAXIMIZE_MSG == uMsg) {
+		int which = LOWORD(wParam) - SYSTRAY_BASE_ICON;
+		switch (LOWORD(lParam)) {
+			case WM_LBUTTONDOWN:
+				{
+					switch (which) {
+						case 1:
+						{
+							RemoveSystrayIcon(hDlg, SYSTRAY_ICY_ICON);
+							ShowWindow(hDlg, SW_SHOW);
+							SendMessage(hDlg, WM_SYSCOMMAND, SC_RESTORE, 0);
+						}
+						break;
+					}
+				}
+				break;
+		}
+	}
+	switch (uMsg) {
+#ifdef FOLLOW_MIXER
+		case MM_MIXM_CONTROL_CHANGE:
+		{
+			HMIXER mix = (HMIXER)wParam;
+			DWORD dwControlID = (DWORD)lParam;
+			//if (dwControlID == 3)
+			{
+				MIXERLINE ml = {sizeof (ml), 0};
+				ml.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_LINE;
+				ml.dwLineID = dwControlID;
+				if (mixerGetLineInfo((HMIXEROBJ) mix, &ml, MIXER_GETLINEINFOF_COMPONENTTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
+					MIXERLINECONTROLS mlc = {sizeof (mlc), dwControlID,};
+					MIXERCONTROL mc = {sizeof (mc),};
+					//mlc.cControls = 1;
+					mlc.cbmxctrl = sizeof (mc);
+					mlc.pamxctrl = &mc;
+					mlc.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME;
+					//mlc.dwControlID = dwControlID;
+					mlc.dwLineID = dwControlID;//ml.dwLineID;
+			char a[128];
+			sprintf(a,"MM_MIXM_CONTROL_CHANGE: %d\n",dwControlID);
+			OutputDebugString(a);
+					if (mixerGetLineControls((HMIXEROBJ) mix, &mlc, MIXER_GETLINECONTROLSF_ONEBYTYPE|MIXER_OBJECTF_MIXER) == MMSYSERR_NOERROR) {
+						//MIXERCONTROLDETAILS mcd = {sizeof (mcd), 0,};
+			char a[128];
+			sprintf(a,"MM_MIXM_CONTROL_CHANGE 2: %d\n",dwControlID);
+			OutputDebugString(a);
+						/*MIXERCONTROLDETAILS_UNSIGNED v[2];
+						mcd.cbDetails = sizeof (MIXERCONTROLDETAILS_UNSIGNED);
+						mcd.paDetails = v;
+						/*v[0].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
+						v[1].dwValue = mc.Bounds.dwMinimum + (va * (mc.Bounds.dwMaximum - mc.Bounds.dwMinimum)) / 100;
+						MMRESULT result = mixerSetControlDetails((HMIXEROBJ) hmix, &mcd, MIXER_OBJECTF_MIXER);*/
+					}
+				}
+			}
+		}
+		break;
+#endif
+
+		case WM_LBUTTONUP:
+			GetWindowRect(hDlg, &mainrect);
+			break;
+
+		case WM_INITDIALOG:
+			{
+				switch (lParam) {
+					case IDD_DIALOG:
+					{
+						int i;
+						wchar_t temp[128] = {0};
+						hMainDLG = hDlg;
+						for (i = 0; i < NUM_ENCODERS; i++) Enc_mutex[i] = NULL;
+						INITCOMMONCONTROLSEX ICCE;
+						ICCE.dwSize = sizeof (ICCE);
+						ICCE.dwICC = ICC_WIN95_CLASSES;
+						InitCommonControlsEx(&ICCE);
+						GetSCIniFile(module.hwndParent);
+						VU.update = VU.lastUpdate = 0;
+						memset(&VU, 0, sizeof (VU));
+						memset(&Output, 0, sizeof (Output));
+
+						// as only 5.61+ supports the IPC_GETNEXTLISTPOS api we check and cache version now
+						doNextLookAhead = (GetWinampVersion(module.hwndParent) >= 0x5061);
+
+						/* Load config */
+						LoadConfig();
+
+						/* Load Encoders */
+						LoadEncoders();
+
+						/* Start logging and encoded output saving */
+						for (i = 0; i < NUM_OUTPUTS; i++) {
+							if (Output[i].Logging) {
+								StartLogging(i, Output[i].LogCOS);
+							}
+							if (Output[i].nextTrackLog) {
+								StartNextTracks(i, Output[i].nextTrackPath);
+							}
+							if (Output[i].saveEncoded) {
+								StartSaveEncoded(i, Output[i].saveEncodedPath);
+							}
+						}
+
+						// ensure we've cached the title information, etc as needed before starting
+						isplaying = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_ISPLAYING);
+						if (isplaying) ProcessPlayingStatusUpdate();
+						PostMessage(hDlg, WM_USER, 0, nowPlayingID);
+
+						/* Setup main tabs */
+						num_tabwnds = 0;
+						SendDlgItemMessage(hDlg, IDC_TAB, TCM_DELETEALLITEMS, 0, 0);
+						AddTab(IDD_MAIN, LocalisedString(IDS_TAB_MAIN, temp, 128), hDlg, DialogFunc, IDC_TAB, IDC_RECT, 100);
+						AddTab(IDD_CONNECTION, LocalisedString(IDS_TAB_OUTPUT, temp, 128), hDlg, ConnectionFunc, IDC_TAB, IDC_RECT, 100);
+						AddTab(IDD_INPUT, LocalisedString(IDS_TAB_INPUT, temp, 128), hDlg, DialogFunc, IDC_TAB, IDC_RECT, 100);
+						AddTab(IDD_ABOUT, LocalisedString(IDS_TAB_ABOUT, temp, 128), hDlg, AboutFunc, IDC_TAB, IDC_RECT, 100);
+						SetTab(curtab, hDlg, IDC_TAB);
+
+						/* threads and timer */
+						hthread = CreateThread(NULL, 0, ThreadInput, hDlg, CREATE_SUSPENDED, &threadid);
+						SetThreadPriority(hthread, THREAD_PRIORITY_HIGHEST);
+						hthreadout = CreateThread(NULL, 0, ThreadOutput, hDlg, CREATE_SUSPENDED, &threadoutid);
+						SetThreadPriority(hthreadout, THREAD_PRIORITY_HIGHEST);
+						Soundcard.Close();
+						Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
+						SetTimer(hDlg, 666, 300000, NULL); // start up INI save timer
+						FadeStartTime = 0;
+						MicFadeStartTime = 0;
+						FadeOut = 0;
+						ini_modified = 1;
+						ReleaseMutex(cf_mutex);
+						SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK,Output[Connection_CurSelPos].AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
+
+						// deal with the PTT restore mode along with setting up the 'down arrow' button
+						SendDlgItemMessage(in_wnd[1].hWnd, IDC_LOCK, BM_SETCHECK, Restore_PTT ? BST_CHECKED : BST_UNCHECKED, 0);
+						PostMessage(in_wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_LOCK, BN_CLICKED), (LPARAM)GetDlgItem(in_wnd[1].hWnd, IDC_LOCK));
+
+						SendDlgItemMessage(in_wnd[1].hWnd, IDC_LOCK_MODE, BM_SETIMAGE, IMAGE_ICON,
+										   (LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_DOWNARROW),
+															 IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
+
+						SendDlgItemMessage(in_wnd[1].hWnd, IDC_REFRESH_DEVICES, BM_SETIMAGE, IMAGE_ICON,
+										   (LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_REFRESH),
+															 IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
+
+						/* setup information parts to be in bold */
+						SetBoldDialogItemFont(GetDlgItem(wnd[0].hWnd, IDC_SUMMARY));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[1].hWnd, IDC_INFO_TEXT));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT2));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT3));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[0].hWnd, IDC_INFO_TEXT4));
+						SetBoldDialogItemFont(GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[4].hWnd, IDC_ART_V1_NOTE));
+						SetBoldDialogItemFont(GetDlgItem(out_wnd[4].hWnd, IDC_ART_V2_NOTE));
+
+						/* subclass the listview on the summary page for specific handling */
+						HWND listView = GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS);
+						ListView_SetItemState(listView, 0, LVIS_SELECTED, LVIS_SELECTED);
+						prevListViewProc = (WNDPROC) SetWindowLongPtrW(listView, GWLP_WNDPROC, (LONG_PTR) listViewProc);
+						prevHeaderProc = (WNDPROC) SetWindowLongPtrW(ListView_GetHeader(listView), GWLP_WNDPROC, (LONG_PTR) headerProc);
+
+						/* subclass the tab control on the main dialog for error notifications */
+						tabWnd = GetDlgItem(hMainDLG, IDC_TAB);
+						prevTabWndProc = (WNDPROC) SetWindowLongPtrW(tabWnd, GWLP_WNDPROC, (LONG_PTR) tabWndProc);
+
+						/* subclass the tab control on the connection page for error notifications */
+						outTabWnd = GetDlgItem(wnd[1].hWnd, IDC_CONTAB);
+						prevOutTabWndProc = (WNDPROC) SetWindowLongPtrW(outTabWnd, GWLP_WNDPROC, (LONG_PTR) outTabWndProc);
+
+						/* only once everything else has been done then we start the threads */
+						ResumeThread(hthread);
+						ResumeThread(hthreadout);
+						break;
+					}
+
+					case IDD_MAIN:
+					{
+						HWND listView = GetDlgItem(hDlg, IDC_OUTPUTSTATUS);
+						ListView_DeleteAllItems(listView);
+						ListView_SetExtendedListViewStyle(listView, LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER|LVS_EX_LABELTIP);
+						AddColumn(L"", listView);
+						AddColumn(LocalisedString(IDS_COL_OUTPUT_NAME, NULL, 0), listView);
+						AddColumn(LocalisedString(IDS_COL_STATUS, NULL, 0), listView);
+						for (int i = 0; i < NUM_OUTPUTS; i++) {
+							AddColItem(L"", 0, hDlg, IDC_OUTPUTSTATUS);
+							AddColItem(Output[i].Config.DisplayName, 1, hDlg, IDC_OUTPUTSTATUS);
+							AddColItem(L"", 2, hDlg, IDC_OUTPUTSTATUS);
+						}
+
+						// fill the header of the output list with the column headers
+						ListView_SetColumnWidth(listView, 0, 24);//LVSCW_AUTOSIZE_USEHEADER);
+						ListView_SetColumnWidth(listView, 1, LVSCW_AUTOSIZE_USEHEADER);
+						int width = ListView_GetColumnWidth(listView, 0) + ListView_GetColumnWidth(listView, 1);
+						RECT listViewRect;
+						GetClientRect(listView, &listViewRect);
+						ListView_SetColumnWidth(listView, 2, (listViewRect.right - listViewRect.left) - width);
+
+						// add in status / action buttons for the first column...
+						for (int i = 0; i < NUM_OUTPUTS; i++) {
+							POINT pt;
+							ListView_GetItemPosition(listView, i, &pt);
+							ListView_GetItemRect(listView, i, &listViewRect, LVIR_BOUNDS);
+							buttonWnd[i] = CreateWindowW(L"button", L"", WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | WS_DISABLED | BS_ICON,
+													    1, pt.y, ListView_GetColumnWidth(listView, 0) - 3,
+													    (listViewRect.bottom - listViewRect.top),
+													    listView, (HMENU)(IDC_STREAM_1+i), 0, 0);
+							SendMessage(buttonWnd[i], BM_SETIMAGE, IMAGE_ICON,
+													  (LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_PLAY),
+																		IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
+						}
+
+						CheckRadioButton(hDlg, IDC_INPUT_WINAMP, IDC_INPUT_SOUNDCARD, (IDC_INPUT_WINAMP + InputDevice));
+						SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_L, PBM_SETRANGE, 0, MAKELONG(0, 90));
+						SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_R, PBM_SETRANGE, 0, MAKELONG(0, 90));
+						for (int ii = 0; ii < NUM_OUTPUTS; ii++) {
+							int encnum = ii;
+							MY_T_OUTPUT *Out = &Output[ii];
+							// removed encoder selection
+							if (Out->Encoder != -1) {
+								if (Out->Handle != -1) {
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Encoder[Out->Encoder].RemoveOutput(Out->Handle);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							}
+
+							Out->Encoder = encnum;
+							if (Out->Encoder != -1) {
+								if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+									Out->Handle = Encoder[Out->Encoder].AddOutput(Out->Encoder, &Out->Config, TitleCallback);
+									ReleaseMutex(Enc_mutex[Out->Encoder]);
+								}
+								ini_modified = 1;
+							}
+							// TODO
+							//SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_NOTITLES, BN_CLICKED), (LPARAM) GetDlgItem(hDlg, IDC_NOTITLES));
+						}
+						break;
+					}
+
+					case IDD_INPUT:
+					{
+						SendDlgItemMessage(hDlg, IDC_INPUTDEVICE, CB_RESETCONTENT, 0, 0);
+						AddInTab(IDD_PANEL_WINAMP, LocalisedString(IDS_INPUT_WINAMP, NULL, 0), hDlg);
+						AddInTab(IDD_PANEL_LINEIN, LocalisedString(IDS_INPUT_SOUNDCARD, NULL, 0), hDlg);
+						SetInTab(InputDevice, hDlg, IDC_INPUTDEVICE);
+						EnableWindowDlgItem(hDlg, IDC_INPUTDEVICE, 1);
+						EnableWindowDlgItem(hDlg, IDC_INPUTDEVICESTATIC, 1);
+						SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_L, PBM_SETRANGE, 0, MAKELONG(0, 90));
+						SendDlgItemMessage(hDlg, IDC_VOLUMEGRAPH_R, PBM_SETRANGE, 0, MAKELONG(0, 90));
+						break;
+					}
+
+					case IDD_ABOUT:
+					{
+						// this will make sure that we've got the icon shown even when using a localised version
+						// as well as setting the dialog icon to the icy icon irrespective of the dialog class's
+						SendDlgItemMessage(hDlg, IDC_ABOUT_ICON, STM_SETIMAGE, IMAGE_ICON, (LPARAM)GetICYIcon());
+						SendMessage(hMainDLG, WM_SETICON, ICON_SMALL, (LPARAM)GetICYIcon());
+
+						wchar_t about[1024], tmp[256];
+						StringCchPrintfW(about, ARRAYSIZE(about), LocalisedString(IDS_ABOUT_MESSAGE, NULL, 0),
+										 LocalisedString(IDS_MODULE_NAME, tmp, 256),
+										 APP_Version, APP_Build, __DATE__);
+						SetDlgItemTextW(hDlg, IDC_PROGRAMNAME, about);
+						link_startsubclass(hDlg, IDC_ABOUTLINK);
+						link_startsubclass(hDlg, IDC_HELPLINK);
+						link_startsubclass(hDlg, IDC_FORUMLINK);
+						link_startsubclass(hDlg, IDC_UPDATELINK);
+
+						ShowUpdateMessage(hDlg);
+						break;
+					}
+
+					case IDD_PANEL_WINAMP:
+					{
+						wchar_t buf[128] = {0};
+						inWinWa = hDlg;
+						HWND metalist = GetDlgItem(hDlg, IDC_METALIST);
+						ListView_SetExtendedListViewStyle(metalist, LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER|LVS_EX_LABELTIP);
+						AddColumn(L"", metalist);
+						AddColumn(L"", metalist);
+						AddColItem(LocalisedString(IDS_FILEPATH, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_TITLE, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_ARTIST, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_ALBUM, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_GENRE, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_YEAR, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						AddColItem(LocalisedString(IDS_COMMENT, buf, ARRAYSIZE(buf)), 0, hDlg, IDC_METALIST);
+						ListView_SetColumnWidth(metalist, 0, LVSCW_AUTOSIZE);
+						RECT metalistRect;
+						GetClientRect(metalist, &metalistRect);
+						ListView_SetColumnWidth(metalist, 1, (metalistRect.right - metalistRect.left) - ListView_GetColumnWidth(metalist, 0));
+						break;
+					}
+
+					case IDD_PANEL_LINEIN:
+					{
+						inWin = NULL;
+     					prevButtonProc = (WNDPROC) SetWindowLongPtrW(GetDlgItem(hDlg, IDC_PTT), GWLP_WNDPROC, (LONG_PTR) buttonProc);
+						SendDlgItemMessage(hDlg, IDC_MUSSLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
+						SendDlgItemMessage(hDlg, IDC_MUS2SLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
+						SendDlgItemMessage(hDlg, IDC_MICSLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 10));
+						SendDlgItemMessage(hDlg, IDC_FADESLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 25));
+						SendDlgItemMessage(hDlg, IDC_MICFADESLIDER, TBM_SETRANGE, TRUE, MAKELONG(0, 25));
+						SendDlgItemMessage(hDlg, IDC_MUSSLIDER, TBM_SETPOS, TRUE, MusVol);
+						SendDlgItemMessage(hDlg, IDC_MUS2SLIDER, TBM_SETPOS, TRUE, Mus2Vol);
+						SendDlgItemMessage(hDlg, IDC_MICSLIDER, TBM_SETPOS, TRUE, MicVol);
+						SendDlgItemMessage(hDlg, IDC_FADESLIDER, TBM_SETPOS, TRUE, FadeTime);
+						SendDlgItemMessage(hDlg, IDC_MICFADESLIDER, TBM_SETPOS, TRUE, MicFadeTime);
+						SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MUSSLIDER));
+						SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MUS2SLIDER));
+						SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MICSLIDER));
+						SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_FADESLIDER));
+						SendMessage(hDlg, WM_HSCROLL, 0, (LPARAM) GetDlgItem(hDlg, IDC_MICFADESLIDER));
+						inWin = hDlg;
+						SetDeviceName();
+						SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_DEVBOX, CBN_SELCHANGE), (LPARAM)GetDlgItem(hDlg,IDC_DEVBOX));
+						break;
+					}
+
+					case IDD_PANEL_LOGIN:
+					{
+						SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_AUTOMATIC, NULL, 0));
+						SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 0,(LPARAM)0);
+						SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_V2_MODE, NULL, 0));
+						SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 1,(LPARAM)2);
+						SendDlgItemMessageW(hDlg, IDC_PROTOCOL, CB_ADDSTRING, 0,(LPARAM)LocalisedString(IDS_V1_MODE, NULL, 0));
+						SendDlgItemMessage(hDlg, IDC_PROTOCOL, CB_SETITEMDATA, 2,(LPARAM)1);
+						SendDlgItemMessage(hDlg, IDC_TIMEOUT, EM_SETLIMITTEXT, 5, 0);
+						break;
+					}
+
+					case IDD_PANEL_DIRECTORY:
+					{
+						SendDlgItemMessage(hDlg, IDC_GENRES, BM_SETIMAGE, IMAGE_ICON,
+										   (LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(IDI_DOWNARROW),
+															 IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
+						break;
+					}
+				}
+			}
+			return 1;
+
+		case WM_CLOSE:
+			{
+				if (hDlg == hMainDLG)
+				{
+					doQuit();
+				}
+			}
+			break;
+
+		case WM_USER:
+			{
+				if (lParam == nowPlayingID && wParam == 0) {
+					// Winamp Title handling
+					wchar_t title[1024] = {0},
+							next[1024] = {0},
+							song[1024] = {0},
+							artist[1024] = {0},
+							album[1024] = {0},
+							genre[1024] = {0},
+							comment[1024] = {0},
+							year[32] = {0},
+							tmp2[1024] = {0};
+					char buffer[1024] = {0},
+						 buffer2[1024] = {0};
+
+					// winamp playlist length in tracks
+					int len = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTLENGTH);
+					int curpos = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS);
+					int pos = curpos + 1;
+					int len2 = 0;
+
+					// get the current title
+					if (len >= 1) {
+						wcscpy_s(lastFile, MAX_PATH, (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, curpos, IPC_GETPLAYLISTFILEW));
+						wcscpy_s(title, ARRAYSIZE(title), (wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC, curpos, IPC_GETPLAYLISTTITLEW));
+					} else {
+						title[0] = lastFile[0] = 0;
+					}
+
+					// get the position of the next track if possible
+					pos = GetNextTracks(len, pos, next);
+
+					if (skipMetada == false) {
+						AddColItem(lastFile, 1, inWinWa, IDC_METALIST, 0);
+						GetFileMetaData(lastFile, L"title", song, ARRAYSIZE(song));
+						AddColItem((song && song[0] ? song : title), 1, inWinWa, IDC_METALIST, 1);
+						GetFileMetaData(lastFile, L"artist", artist, ARRAYSIZE(artist));
+						AddColItem((artist[0] ? artist : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 2);
+						GetFileMetaData(lastFile, L"album", album, ARRAYSIZE(album));
+						AddColItem((album[0] ? album : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 3);
+						GetFileMetaData(lastFile, L"genre", genre, ARRAYSIZE(genre));
+						AddColItem((genre[0] ? genre : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 4);
+						GetFileMetaData(lastFile, L"year", year, ARRAYSIZE(year));
+						AddColItem((year[0] ? year : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 5);
+						GetFileMetaData(lastFile, L"comment", comment, ARRAYSIZE(comment));
+						AddColItem((comment[0] ? comment : L"<emtpy>"), 1, inWinWa, IDC_METALIST, 6);
+
+						if (WASABI_API_MEMMGR && playingImage) {
+							WASABI_API_MEMMGR->sysFree(playingImage); playingImage = 0;
+						}
+
+						playingLength = 0;
+						playingType = 0x4100;	// default in-case of issue
+
+						// attempt to get the type of the image, defaulting to jpeg for older versions
+						// as only on 5.64+ are we able to query Winamp properly for the artwork type
+						wchar_t* mimeType = 0, *uiType = L"jpeg";
+						if (GetWinampVersion(module.hwndParent) >= 0x5064)
+						{
+							LPVOID bits;
+							size_t len;
+							if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArtData(lastFile, L"cover", &bits, &len, &mimeType) == ALBUMART_SUCCESS) {
+								// make sure to free the original image after we've converted
+								playingImage = (ARGB32 *)bits;
+								playingLength = len;
+
+								wchar_t *ext = &mimeType[0];
+								if (ext && *ext) {
+									uiType = ext;
+									if (!wcsnicmp(ext, L"jpeg", 4) || !wcsnicmp(ext, L"jpg", 3)) {
+										playingType = 0x4100;
+									} else if (!wcsnicmp(ext, L"png", 3)) {
+										playingType = 0x4101;
+									} else if (!wcsnicmp(ext, L"bmp", 3)) {
+										playingType = 0x4102;
+									} else if (!wcsnicmp(ext, L"gif", 3)) {
+										playingType = 0x4103;
+									}
+								}
+
+								// update the current artwork on the winamp panel
+								// have to decode as we get the raw data normally
+								HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
+								HBITMAP bm = getBitmap(decompressImage(playingImage, playingLength, &playingImage_w, &playingImage_h), playingImage_w, playingImage_h);
+								HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)bm);
+								if (bmold) DeleteObject(bmold);
+								InvalidateRect(artwork, NULL, TRUE);
+							}
+						} else {
+							playingImage_w = 0, playingImage_h = 0;
+							if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArt(lastFile, L"cover", &playingImage_w, &playingImage_h, &playingImage) == ALBUMART_SUCCESS) {
+								// make sure to free the original image after we've converted
+								ARGB32 *firstPlayingImage = playingImage;
+
+								// update the current artwork on the winamp panel
+								// no need to decode as it's already done by this
+								HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
+								HBITMAP bm = getBitmap(playingImage, playingImage_w, playingImage_h);
+								HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)bm);
+								if (bmold) DeleteObject(bmold);
+								InvalidateRect(artwork, NULL, TRUE);
+
+								playingImage = writeImg(playingImage, playingImage_w, playingImage_h, &playingLength, L"jpeg");
+								WASABI_API_MEMMGR->sysFree(firstPlayingImage);
+							} else {
+								playingImage = 0;
+							}
+						}
+
+						wchar_t tmp3[1024] = {0};
+						if(playingImage)
+						{
+							StringCchPrintfW(tmp3, ARRAYSIZE(tmp3), L"Playing Artwork: Width=%d; Height=%d; Data=%s;",
+											 playingImage_w, playingImage_h, sizeStr(playingLength));
+
+							// only use this on compatible Winamp installs where possible
+							wchar_t *mime = 0;
+							if (GetWinampVersion(module.hwndParent) >= 0x5064 &&
+								AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArtOrigin(lastFile, L"cover", &mime)) {
+								if (mime)
+								{
+									uiType = wcschr(mime, L'/');
+									if (uiType && *uiType)
+									{
+										uiType++;
+									}
+								}
+							} else {
+								if (mimeType)
+								{
+									uiType = wcschr(mimeType, L'/');
+									if (uiType && *uiType)
+									{
+										uiType++;
+									}
+								}
+							}
+
+							wchar_t buf[256] = {0};
+							StringCchPrintfW(buf, ARRAYSIZE(buf), LocalisedString(IDS_ARTWORK_SIZES, NULL, 0),
+											 playingImage_w, playingImage_h, sizeStr(playingLength),
+											 (uiType && *uiType ? uiType : mime));
+							SetDlgItemTextW(inWinWa, IDC_ARTWORK3, buf);
+							WASABI_API_MEMMGR->sysFree(mime);
+						}
+						else
+						{
+							// update the current artwork on the winamp panel
+							// by setting a generic image when nothing loaded
+							HWND artwork = GetDlgItem(inWinWa, IDC_ARTWORK);
+							HBITMAP bmold = (HBITMAP)SendMessage(artwork, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)0);
+							if (bmold) DeleteObject(bmold);
+							SetDlgItemTextW(inWinWa, IDC_ARTWORK3, L"");
+							StringCchPrintfW(tmp3, ARRAYSIZE(tmp3), L"Playing Artwork: Cleared;");
+						}
+						if (mimeType) WASABI_API_MEMMGR->sysFree(mimeType);
+						ShowWindowDlgItem(inWinWa, IDC_ARTWORK, (playingLength > 0));
+						ShowWindowDlgItem(inWinWa, IDC_ARTWORK2, (playingLength == 0));
+						ShowWindowDlgItem(inWinWa, IDC_ARTWORK3, (playingLength > 0));
+						CreateLogFileMessage(buffer2, tmp3, &len2);
+					}
+
+					// look at the playback queue so we can get the correct 'next song'
+					if (WASABI_API_SVC && !WASABI_API_QUEUEMGR) {
+						// due to loading orders its possible the queue won't have been loaded on init so check
+						ServiceBuild(WASABI_API_SVC, WASABI_API_QUEUEMGR, QueueManagerApiGUID);
+					}
+
+					std::vector<std::wstring> nextList;
+					std::vector<int> nextListIdx;
+					UpdateNextTracks(next, pos, nextListIdx, nextList);
+
+					StringCchPrintfW(tmp2, ARRAYSIZE(tmp2), L"Metadata: Artist=%s; Album=%s; Genre=%s; Year=%s; Comment=%s; Title=%s;",
+									 artist, album, genre, year, comment, (song && song[0] ? song : title));
+					len = 0;
+					CreateLogFileMessage(buffer, tmp2, &len);
+
+					// update the title cache for all of the encoders otherwise we might fail, etc
+					for (int i = 0; i < NUM_OUTPUTS; i++) {
+						MY_T_OUTPUT *Out = &Output[i];
+
+						if (Out->nextTrackLog) {
+							WriteNextTracks(i, module.hwndParent, nextListIdx, nextList, !!Out->nextTrackLogXML);
+						}
+
+						if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+							Encoder[i].UpdateTitleCache(title, nextList, song, album, artist, genre, comment, year, Out->Handle, !!Out->NextTitles);
+							ReleaseMutex(Enc_mutex[Out->Encoder]);
+						}
+
+						// skip this all if the mode is not enabled and only in SC2 mode
+						if ((LOBYTE(Out->Config.protocol) != 1) && Out->useArt) {
+							// this will only update generally on first connection
+							if (Out->useStreamArt && streamImage[i] == (ARGB32 *)-1) {
+								UpdateStreamAlbumArt(Out->Handle, i, Out->stationArtPath, !!Out->useStreamArt);
+							}
+
+							// this will update against what is read from the playing
+							if (Out->usePlayingArt) {
+								UpdatePlayingAlbumArt(Out->Handle, i, Out->useArt && Out->usePlayingArt);
+							}
+						}
+
+						// save the updated metadata to the log file (if enabled)
+						if (Out->Logging && logFiles[i] != INVALID_HANDLE_VALUE) {
+							DWORD written = 0;
+							WriteFile(logFiles[i], buffer, len, &written, 0);
+							WriteFile(logFiles[i], buffer2, len2, &written, 0);
+						}
+					}
+				}
+			}
+			break;
+
+		case WM_TIMER:
+			{
+				if (wParam == IDD_MAIN || wParam == IDD_INPUT) {
+					if (VU.update || VU.update != VU.lastUpdate)
+					{
+						UpdateVUMeters();
+					}
+				}
+
+				if (wParam == 1234) { // input timer
+					if (InputDevice == 1) {
+						for (int i = 0; i < NUM_BUFFERS; i++) {
+							if (Soundcard.isFilled(last_buffer)) {
+								short *buffer = Soundcard[last_buffer];
+								int scardsmps = Soundcard.getNumSamples(last_buffer);
+								int numsamps = scardsmps * InputConfig.nch;
+								if (!VU.update) {
+									for (int j = 0; j < numsamps; j++) {
+										if (VU.vu_l < buffer[j]) VU.vu_l = buffer[j];
+										if (LineInputAttribs[Input_CurSelPos].nch == 2) {
+											if (VU.vu_r < buffer[j + 1]) VU.vu_r = buffer[j + 1];
+											j++;
+										}
+									}
+									if (LineInputAttribs[Input_CurSelPos].nch == 1) VU.vu_r = VU.vu_l;
+									VU.update = 1;
+								}
+								if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
+									Crossfader->put(buffer, scardsmps);
+									ReleaseMutex(cf_mutex);
+								}
+								Soundcard.cycleBuffer(last_buffer++);
+								if (last_buffer >= NUM_BUFFERS) last_buffer = 0;
+							}
+						}
+					}
+				} else if (wParam == IDD_MAIN || wParam == IDD_CONNECTION ||
+						   wParam == IDD_INPUT || wParam == IDD_ABOUT) {
+					wchar_t title[1024] = {0};
+					wchar_t next[1024] = {0};
+					int states[NUM_OUTPUTS] = {OUT_ERROR,OUT_ERROR,OUT_ERROR,OUT_ERROR,OUT_ERROR};
+		
+					for (int i = 0; i < NUM_OUTPUTS; i++) {
+						wchar_t tmp[1024] = {0};
+						static wchar_t old_tmp[NUM_ENCODERS][1024] = {0};
+						MY_T_OUTPUT *Out = &Output[i];
+						SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
+						bool encoder_ok = false;
+						if (Enc) {
+							C_ENCODER *Encoder = Enc->GetEncoder();
+							if (Encoder) {
+								if (strcmp(Encoder->GetName(), "MP3 Encoder") == 0) {
+									encoder_ok = (libinst != NULL);
+								} else {
+									encoder_ok = true;
+								}
+							}
+						}
+						lastEnable[i] = (encoder_ok && Out->Config.Address[0] && Out->Config.Password[0] &&
+										 stationNameAllowed(Out->Config.Description));
+
+						if (Out->Encoder == -1 || Out->Handle == -1) {
+							LocalisedString(IDS_NOT_CONNECTED, tmp, ARRAYSIZE(tmp));
+							if (wParam == IDD_CONNECTION && i == Connection_CurSelPos) {
+								GetDlgItemTextW(out_wnd[3].hWnd, IDC_TITLE, title, sizeof (title) / sizeof (wchar_t));
+								GetDlgItemTextW(out_wnd[3].hWnd, IDC_NEXT, next, sizeof (next) / sizeof (wchar_t));
+							}
+						} else {
+							if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+								T_OUTPUT_INFO *Info = Enc->GetOutputInfo(Out->Handle);
+								if (title != NULL && next != NULL && Info != NULL) {
+									if (Info->Title)
+									{
+										free(Info->Title);
+									}
+									Info->Title = _wcsdup(title);
+								}
+
+								states[i] = Enc->GetState(Out->Handle);
+								switch (states[i]) {
+									case OUT_ERROR:
+										{
+											LocalisedString(IDS_ERROR, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_DISCONNECTED:
+										{
+											if (Info->Succeeded < 0) {
+												if (Info->ErrorMsg && Info->ErrorMsg[0]) {
+													// if an error is reported, try to give a user-friendly error message
+													if (!strcmp("NAK:Deny", Info->ErrorMsg))
+														// localised Password error
+														LocalisedString(IDS_PASS_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("CipherFail",Info->ErrorMsg))
+														// localised cipher error
+														LocalisedString(IDS_CIPHER_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("BitrateError",Info->ErrorMsg))
+														// localised bitrate error (not allowed / not supported)
+														LocalisedString(IDS_BITRATE_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("StreamID",Info->ErrorMsg))
+														// localised stream moved error
+														LocalisedString(IDS_STREAMID_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("StreamMoved",Info->ErrorMsg))
+														LocalisedString(IDS_STREAM_MOVED_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("VersionError",Info->ErrorMsg))
+														// localised version error
+														LocalisedString(IDS_VERSION_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("Blocked",Info->ErrorMsg))
+														// localised blocked error
+														LocalisedString(IDS_BLOCKED_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("InUse",Info->ErrorMsg))
+														// localised in use error
+														LocalisedString(IDS_IN_USE_ERROR, tmp, ARRAYSIZE(tmp));
+													else if (!strcmp("ParseError",Info->ErrorMsg))
+														// localised parse error
+														LocalisedString(IDS_PARSE_ERROR, tmp, ARRAYSIZE(tmp));
+													else
+														// non localised dynamic nak error
+														StringCchPrintfW(tmp, ARRAYSIZE(tmp), L"%hs", Info->ErrorMsg);
+												} else {
+													// localised Password error
+													LocalisedString(IDS_PASS_ERROR, tmp, ARRAYSIZE(tmp));
+												}
+												Out->Config.AutoRecon = 0;
+											} else {
+												if (Info->last_state == OUT_RECV_CIPHER ||
+													Info->last_state == OUT_REQUEST_CIPHER) {
+													StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_ENABLE_OTHER_MODE, NULL, 0), (Info->last_state == OUT_RECV_CIPHER ? 1 : 2));
+												} else {
+													LocalisedString((lastEnable[i] ? IDS_NOT_CONNECTED : IDS_NOT_CONFIGURED), tmp, ARRAYSIZE(tmp));
+												}
+												lastSec[i] = 0;
+											}
+										}
+										break;
+									case OUT_CONNECT:
+										{
+											if ((clock() - Info->ConnectionTime) / CLOCKS_PER_SEC < 1) {
+												StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), 1);
+											} else {
+												LocalisedString(IDS_CONNECTING, tmp, ARRAYSIZE(tmp));
+											}
+										}
+										break;
+									case OUT_REQUEST_CIPHER:
+										{
+											LocalisedString(IDS_SEND_CIPHER_REQUEST, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_CIPHER:
+										{
+											LocalisedString(IDS_CIPHER_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SENDAUTH:
+										{
+											LocalisedString(IDS_SENDING_AUTH, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECVAUTHRESPONSE:
+										{
+											LocalisedString(IDS_RECEIVING_AUTH_RESPONSE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_MIME:
+										{
+											LocalisedString(IDS_SENDING_CONTENT_TYPE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_MIME:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_BITRATE:
+										{
+											LocalisedString(IDS_SENDING_BITRATE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_BITRATE:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_BUFSIZE:
+										{
+											LocalisedString(IDS_SEND_BUF_SIZE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_BUFSIZE:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_MAX:
+										{
+											LocalisedString(IDS_SEND_MAX_PAYLOAD_SIZE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_MAX:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SENDYP:
+										{
+											LocalisedString(IDS_SEND_YP_INFO, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_INITFLUSH:
+										{
+											LocalisedString(IDS_SEND_FLUSH, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_INITFLUSH:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_INITSTANDBY:
+										{
+											LocalisedString(IDS_SEND_STANDBY, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_INITSTANDBY:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									/*case OUT_SEND_INTRO:
+										{
+											LocalisedString(IDS_SEND_INTRO_FILE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_INTRO:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_SEND_BACKUP:
+										{
+											LocalisedString(IDS_SEND_BACKUP_FILE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECV_BACKUP:
+										{
+											LocalisedString(IDS_RESPONSE_RECEIVED, tmp, ARRAYSIZE(tmp));
+										}
+										break;*/
+									case OUT_SEND_ARTWORK:
+									case OUT_SEND_METADATA:
+										break;
+									case OUT_SENDCONTENT:
+										{
+											time_t time_value = time(NULL) - Info->ConnectedAt;
+											long hour = (long)(time_value/3600);
+											long min = (time_value/60)%60;
+											long sec = time_value%60;
+											static wchar_t format[256];
+											if (!format[0]) LocalisedString(IDS_SENT_X, format, ARRAYSIZE(format));
+											StringCchPrintfW(tmp, ARRAYSIZE(tmp), format, hour, min, sec, sizeStr(Info->BytesSent));
+											lastSec[i] = sec;
+
+											// do this to filter out some of the log
+											// events so it'll only happen every second
+											if (lastSec[i] == sec - 1) {
+												secChanged[i] = true;
+											}
+										}
+										break;
+									case OUT_DISCONNECT:
+										{
+											LocalisedString(IDS_DISCONNECTING, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+									case OUT_RECONNECT:
+										{
+											if (Info->Reconnect) {
+												int seconds = Info->ReconnectTime - ((clock() - Info->ConnectionTime) / CLOCKS_PER_SEC);
+												if (seconds > 0) {
+													StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), seconds);
+												} else {
+													if (Info->Switching) {
+														StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_SWITCHING_PROTOCOL, NULL, 0),
+																		 (Info->Switching == 2 ? 2 : 1), (Info->Switching == 2 ? 1 : 2));
+													} else {
+														StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_RECONNECTING_X, NULL, 0), seconds);
+													}
+												}
+											} else {
+												if (Info->Switching) {
+													StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_SWITCHING_PROTOCOL, NULL, 0),
+																	 (Info->Switching == 2 ? 2 : 1), (Info->Switching == 2 ? 1 : 2));
+												} else {
+													LocalisedString(IDS_DISCONNECTING, tmp, ARRAYSIZE(tmp));
+												}
+											}
+										}
+										break;
+									case OUT_TITLESENDUPDATE:
+										{
+											LocalisedString(IDS_SEND_TITLE_UPDATE, tmp, ARRAYSIZE(tmp));
+										}
+										break;
+								}
+
+								if (Out->AutoConnect && states[i] == OUT_DISCONNECTED) {
+									Enc->ConnectOutput(Out->Handle);
+								}
+
+								ReleaseMutex(Enc_mutex[Out->Encoder]);
+							}
+						}
+
+						// output log messages to the log files if enabled
+						// but filter things a bit more with the sent state
+						if (tmp[0] && wcsnicmp(old_tmp[i], tmp, ARRAYSIZE(tmp))) {
+							if (Out->Logging && logFiles[i] != INVALID_HANDLE_VALUE) {
+								if (states[i] != OUT_SENDCONTENT || (states[i] == OUT_SENDCONTENT && secChanged[i] == true)) {
+									DWORD written = 0;
+									int len = 0;
+									char buffer[1024];
+									if (states[i] == OUT_CONNECT) {
+										wchar_t tmp2[2048] = {0};
+										int protocol = (LOBYTE(Out->Config.protocol) != 1 ? 2 : 1);
+										StringCchPrintfW(tmp2, ARRAYSIZE(tmp2),
+														 L"Connecting to... Server: %hs; Port: %d; Mode: v%d; Stream ID: %hs; DJ / User ID: %hs",
+														 Out->Config.Address, Out->Config.Port, protocol,
+														 (protocol == 1 ? "n/a" : Out->Config.StationID),
+														 (!Out->Config.UserID[0] ? "n/a" : Out->Config.UserID));
+										CreateLogFileMessage(buffer, tmp2, &len);
+										WriteFile(logFiles[i], buffer, len, &written, 0);
+									} else {
+										CreateLogFileMessage(buffer, tmp, &len);
+										WriteFile(logFiles[i], buffer, len, &written, 0);
+									}
+								}
+							}
+							secChanged[i] = false;
+						}
+
+						// update summary and output page view and text states as applicable
+						if (wParam == IDD_MAIN ||
+							(wParam == IDD_CONNECTION && i == Connection_CurSelPos)) {
+							// update status text for the output being processed
+							if (tmp[0]) {
+								if (wParam == IDD_CONNECTION && i == Connection_CurSelPos) {
+									SetDlgItemTextW(wnd[1].hWnd, IDC_STATUS, tmp);
+								}
+								AddColItem(tmp, 2, wnd[0].hWnd, IDC_OUTPUTSTATUS, i);
+							}
+
+							bool encoder_ok = false;
+							if (Enc) {
+								C_ENCODER *Encoder = Enc->GetEncoder();
+								if (Encoder) {
+									if (strcmp(Encoder->GetName(), "MP3 Encoder") == 0) {
+										encoder_ok = (libinst != NULL);
+									} else {
+										encoder_ok = true;
+									}
+								}
+							}
+
+							// update the playback buttons on the summary page
+							int mode = (Out->Config.Address[0] ? (Out->Config.Password[0] ?
+										(stationNameAllowed(Out->Config.Description) ?
+										 (encoder_ok ? (states[i] == OUT_DISCONNECTED ? 0 :
+										 states[i] == OUT_DISCONNECT ? 1 : states[i] == OUT_RECONNECT ? 7 : 2) : 6) : 5) : 4) : 3);
+
+							// used to limit the amount of processing which is done for this to keep updates to just what is needed
+							if (lastMode[i] == -1 || lastMode[i] != mode) {
+								int image_id[] = {IDI_PLAY, IDI_KILL, IDI_STOP, IDI_PLAY, IDI_PLAY, IDI_PLAY, IDI_PLAY, IDI_STOP};
+
+								// do checks to see if we need to update the error state of the tab items
+								int oldMode = lastMode[i];
+								lastMode[i] = mode;
+
+								RECT r = {0};
+								if (IsWindow(outTabWnd)) {
+									int index[] = {0, 0, 1, 2};
+									if (lastMode[i] >= 3 && lastMode[i] <= 6) {
+										TabCtrl_GetItemRect(outTabWnd, index[(lastMode[i] - 3)], &r);
+										InvalidateRect(outTabWnd, &r, 0);
+									}
+
+									if (oldMode >= 3 && oldMode <= 6) {
+										TabCtrl_GetItemRect(outTabWnd, index[(oldMode - 3)], &r);
+										InvalidateRect(outTabWnd, &r, 0);
+									}
+								}
+
+								TabCtrl_GetItemRect(GetDlgItem(hMainDLG, IDC_TAB), 1, &r);
+								InvalidateRect(GetDlgItem(hMainDLG, IDC_TAB), &r, 0);
+
+								// control the button states on the pages
+								EnableWindow(buttonWnd[i], lastEnable[i]);
+
+								EnableWindowDlgItem(wnd[1].hWnd, IDC_CONNECT, lastEnable[i]);
+								EnableWindowDlgItem(wnd[1].hWnd, IDC_AUTOCONNECT, lastEnable[i]);
+
+								SendMessage(buttonWnd[i], BM_SETIMAGE, IMAGE_ICON,
+											(LPARAM)LoadImage(module.hDllInstance, MAKEINTRESOURCE(image_id[mode]),
+															  IMAGE_ICON, 0, 0, LR_SHARED | LR_LOADTRANSPARENT | LR_CREATEDIBSECTION));
+
+								// control the 'connect' button to be disabled when no encoder / no password / invalid station name
+								if (i == Connection_CurSelPos) {
+									int button_id[] = {IDS_CONNECT, IDS_KILL, IDS_DISCONNECT, IDS_SET_SERVER, IDS_SET_PASSWORD, IDS_CHANGE_NAME, IDS_SET_ENCODER, IDS_ABORT};
+									SetDlgItemTextW(wnd[1].hWnd, IDC_CONNECT, LocalisedString(button_id[mode], NULL, 0));
+									LockOptionControls((states[i] == OUT_DISCONNECTED && Out->Handle != -1));
+
+									InvalidateRect(GetDlgItem(out_wnd[0].hWnd, IDC_ADDRESS_HEADER), 0, 0);
+									InvalidateRect(GetDlgItem(out_wnd[0].hWnd, IDC_PASSWORD_HEADER), 0, 0);
+									InvalidateRect(GetDlgItem(out_wnd[1].hWnd, IDC_NAME_HEADER), 0, 0);
+									InvalidateRect(GetDlgItem(out_wnd[2].hWnd, IDC_ENCODER_HEADER), 0, 0);
+								}
+							}
+
+							// update the title set
+							if (Out->AutoTitle) SetDlgItemTextW(out_wnd[0].hWnd, IDC_TITLE, title);
+						}
+
+						// preserve the last status message for filtering of the log output, etc
+						if (tmp[0]) wcsncpy(old_tmp[i], tmp, 1024);
+					}
+				} else if (wParam == 1337) { // stream title update
+					KillTimer(hDlg, wParam);
+					PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
+				} else if (wParam == 2234) { // fade (music)
+					if (InputDevice) {
+						clock_t MusCurTime = clock();
+						if (FadeStartTime == 0) {
+							FadeStartTime = MusCurTime;
+						}
+						MusCurTime -= FadeStartTime;
+						int micsrc = Input_Device_ID  >= 1  ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
+						if (MusCurTime < (FadeTime * 100)) {
+							int musvol = FadeOut ? (MusVol * 10)+((((Mus2Vol - MusVol)*10) * MusCurTime) / (FadeTime * 100)) : (Mus2Vol * 10)+((((MusVol - Mus2Vol)*10) * MusCurTime) / (FadeTime * 100));
+							setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, musvol);
+						} else {
+							if (FadeOut) {
+								setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, Mus2Vol * 10);
+							} else {
+								setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
+							}
+							FadeStartTime = 0;
+							KillTimer(hDlg, wParam);
+							// kill captured device
+							#ifdef CAPTURE_TESTING
+							if (!FadeOut) {// end_capture();
+								if (pPlayer != NULL) {
+									pPlayer->Stop();
+									delete pPlayer;
+									pPlayer = NULL;
+								}
+							}
+							#endif
+						}
+					}
+				} else if (wParam == 2235) { // fade (capture device)
+					if (InputDevice) {
+						clock_t MicCurTime = clock();
+						if (MicFadeStartTime == 0) {
+							MicFadeStartTime = MicCurTime;
+						}
+						MicCurTime -= MicFadeStartTime;
+						int micsrc = Input_Device_ID  >= 1  ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
+						if (MicCurTime < (MicFadeTime * 100)) {
+							int micvol = FadeOut ? ((MicVol * 10) * MicCurTime) / (MicFadeTime * 100) : (MicVol * 10)+(((MicVol*-10) * MicCurTime) / (MicFadeTime * 100));
+							setlev(micsrc, micvol);
+						} else {
+							if (FadeOut) {
+								setlev(micsrc, MicVol * 10);
+							} else {
+								setlev(micsrc, 0);
+							}
+							MicFadeStartTime = 0;
+							KillTimer(hDlg, wParam);
+							// kill captured device
+							#ifdef CAPTURE_TESTING
+							if (!FadeOut) {// end_capture();
+								if (pPlayer != NULL) {
+									pPlayer->Stop();
+									delete pPlayer;
+									pPlayer = NULL;
+								}
+							}
+							#endif
+						}
+					}
+				} else if (wParam == 666) { // INI save timer
+					if (!ini_modified) break;
+					ini_modified = 0;
+					int i;
+					WritePrivateProfileInt("ofnidx", lastFilterIndex, 0, 0);
+					WritePrivateProfileInt("CurTab", curtab, 0, 0);
+					WritePrivateProfileInt("Connection_CurSelPos", Connection_CurSelPos, 0, 0);
+					WritePrivateProfileInt("Connection_CurTab", curouttab, 0, 0);
+					WritePrivateProfileInt("Encoder_CurSelPos", Encoder_CurSelPos, 0, 0);
+					WritePrivateProfileInt("Input_CurSelPos", Input_CurSelPos, 0, 0);
+					WritePrivateProfileInt("InputDevice", InputDevice, 0, 0);
+					WritePrivateProfileInt("MusicVolume", MusVol, 0, 0);
+					WritePrivateProfileInt("BGMusicVolume", Mus2Vol, 0, 0);
+					WritePrivateProfileInt("MicVolume", MicVol, 0, 0);
+					WritePrivateProfileInt("PTT_FT", FadeTime, 0, 0);
+					WritePrivateProfileInt("PTT_MicFT", MicFadeTime, 0, 0);
+					WritePrivateProfileInt("PTT_MicInput", Input_Device_ID, 0, 0);
+					WritePrivateProfileInt("PTT_Restore", Restore_PTT, 0, 0);
+
+					if (!IsIconic(hDlg)) {
+						WritePrivateProfileInt("WindowLeft", mainrect.left, 0, 0);
+						WritePrivateProfileInt("WindowTop", mainrect.top, 0, 0);
+					}
+
+					for (i = 0; i < NUM_ENCODERS; i++) {
+						int Type = 0;
+						char name[32];
+						StringCchPrintfA(name, ARRAYSIZE(name), "Encoder %u", i + 1);
+
+						if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
+							C_ENCODER *Enc = Encoder[i].GetEncoder();
+							if (Enc) {
+								if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
+									int infosize = sizeof (T_ENCODER_MP3_INFO);
+									T_ENCODER_MP3_INFO *EncInfo = (T_ENCODER_MP3_INFO *) Enc->GetExtInfo(&infosize);
+									WritePrivateProfileInt("BitRate", EncInfo->output_bitRate, name, 0);
+									WritePrivateProfileInt("SampleRate", EncInfo->output_sampleRate, name, 0);
+									WritePrivateProfileInt("NumChannels", EncInfo->output_numChannels, name, 0);
+									WritePrivateProfileInt("QualityMode", EncInfo->QualityMode, name, 0);
+									Type = 1;
+								} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) { // FHG AAC
+									((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
+									Type = 2;
+								} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) { // AAC+
+									((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
+									Type = 2;
+								}
+#ifdef USE_OGG
+								else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) { // OGG
+									((C_ENCODER_NSV*) Enc)->FillConfFile(IniName, name);
+									Type = 4;
+								}
+#endif
+							}
+							ReleaseMutex(Enc_mutex[i]);
+						}
+						WritePrivateProfileInt("Type", Type, name, 0);
+					}
+
+					for (i = 0; i < NUM_OUTPUTS; i++) {
+						T_OUTPUT_CONFIG *Out = &Output[i].Config;
+						WritePrivateProfileString(Out->Name, "Address", Out->Address, IniName);
+						WritePrivateProfileInt("Port", Out->Port, Out->Name, 0);
+						WritePrivateProfileString(Out->Name, "UserID", Out->UserID, IniName);
+						WritePrivateProfileString(Out->Name, "StreamID", Out->StationID, IniName);
+						WritePrivateProfileString(Out->Name, "Password", Out->Password, IniName);
+						// disabled saving of this as it defeats the point of setting it on load
+						// (as it's otherwise over-written with the correct value from the server)
+						//WritePrivateProfileString(Out->Name, "Cipherkey", Out->cipherkey, IniName);
+						WritePrivateProfileString(Out->Name, "Description", Out->Description, IniName);
+						WritePrivateProfileString(Out->Name, "URL", Out->ServerURL, IniName);
+						WritePrivateProfileString(Out->Name, "Genre3", Out->Genre, IniName);
+						WritePrivateProfileString(Out->Name, "AIM", Out->AIM, IniName);
+						WritePrivateProfileString(Out->Name, "ICQ", Out->ICQ, IniName);
+						WritePrivateProfileString(Out->Name, "IRC", Out->IRC, IniName);
+						WritePrivateProfileInt("Public", Out->Public ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("AutoRecon", Out->AutoRecon ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("ReconTime", Out->ReconTime ? Out->ReconTime : 1, Out->Name, 0);
+						WritePrivateProfileInt("doTitleUpdate", Out->doTitleUpdate ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileString(Out->Name, "now", Out->Now, IniName);
+						WritePrivateProfileString(Out->Name, "next", Out->Next, IniName);
+						WritePrivateProfileInt("AutoTitle", Output[i].AutoTitle ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("AutoConnect", Output[i].AutoConnect ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("Logging", Output[i].Logging ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("LogCOS", Output[i].LogCOS ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("NextTitles", Output[i].NextTitles ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("Protocol", Output[i].Config.protocol, Out->Name, 0);
+						WritePrivateProfileInt("nextTrackLog", Output[i].nextTrackLog ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("nextTrackLogXML", Output[i].nextTrackLogXML ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileString(Out->Name, "nextTrackPath", ConvertToUTF8(Output[i].nextTrackPath), IniName);
+						WritePrivateProfileInt("useArt", Output[i].useArt ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("usePlayingArt", Output[i].usePlayingArt ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileInt("useStreamArt", Output[i].useStreamArt ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileString(Out->Name, "stationArtPath", ConvertToUTF8(Output[i].stationArtPath), IniName);
+						WritePrivateProfileInt("saveEncoded", Output[i].saveEncoded ? 1 : 0, Out->Name, 0);
+						WritePrivateProfileString(Out->Name, "saveEncodedPath", ConvertToUTF8(Output[i].saveEncodedPath), IniName);
+						WritePrivateProfileInt("Encoder", Output[i].Encoder, Out->Name, 0);
+					}
+				}
+			}
+			break;
+
+		case WM_SHOWWINDOW:
+			{
+				if (IsWindow(hDlg) && hDlg == hMainDLG && wnd[curtab].timer_freq != 0) {
+					KillTimer(hDlg, wnd[curtab].id);
+					SetTimer(hDlg, wnd[curtab].id, wnd[curtab].timer_freq, NULL);
+				} else if (IsWindow(hDlg) && hDlg == wnd[2].hWnd && in_wnd[InputDevice].timer_freq != 0) {
+					KillTimer(hDlg, in_wnd[InputDevice].id);
+					SetTimer(hDlg, in_wnd[InputDevice].id, in_wnd[InputDevice].timer_freq, NULL);
+				} else if (IsWindow(hDlg) && hDlg == wnd[1].hWnd && out_wnd[curouttab].timer_freq != 0) {
+					KillTimer(hDlg, out_wnd[curouttab].id);
+					SetTimer(hDlg, out_wnd[curouttab].id, out_wnd[curouttab].timer_freq, NULL);
+				}
+			}
+			break;
+
+			//Handle Minimize to systray here
+		case WM_SIZE:
+			{
+				switch (wParam) {
+					case SIZE_RESTORED:
+						{
+							RemoveSystrayIcon(hDlg, SYSTRAY_ICY_ICON);
+							ShowWindow(hDlg, SW_SHOW);
+						}
+						break;
+					case SIZE_MINIMIZED:
+						{
+							AddSystrayIcon(hDlg, SYSTRAY_ICY_ICON, GetICYIcon(),
+										   SYSTRAY_MAXIMIZE_MSG, szDescription2W);
+							ShowWindow(hDlg, SW_HIDE);
+						}
+						break;
+				}
+			}
+			break;
+
+		case WM_COMMAND:
+			{
+				switch (LOWORD(wParam)) {
+					case IDC_NOTITLES:
+					case IDC_AUTOTITLE:
+					case IDC_MANUALTITLE:
+					//case IDC_EXTERNALTITLE:
+						{
+							// TODO will need to change around some of the logic to cope with the external option
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								int lastAutoTitle = Out->AutoTitle;
+								Out->Config.doTitleUpdate = (LOWORD(wParam) != IDC_NOTITLES);
+								Out->AutoTitle = (LOWORD(wParam) == IDC_AUTOTITLE);
+								ini_modified = 1;
+								CheckRadioButton(hDlg, IDC_NOTITLES, IDC_MANUALTITLE, LOWORD(wParam));
+								UpdateTitleControls();
+								// if enabling then send the title update
+								if ((LOWORD(wParam) == IDC_AUTOTITLE) && lastAutoTitle != Out->AutoTitle) {
+									if (Out->Encoder != -1 && Out->Handle != -1) {
+										SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+										if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+											std::vector<std::wstring> nextList;
+											nextList.clear();
+											Enc->UpdateTitle(0, nextList, Out->Handle, !!Out->NextTitles, true);
+											ReleaseMutex(Enc_mutex[Out->Encoder]);
+										}
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_SENDNEXTTITLES:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->NextTitles = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_VIEW_LOG:
+						{
+							wchar_t file[MAX_PATH];
+							ShellExecuteW(hMainDLG, L"open", GetSCLogFile(module.hwndParent, ARRAYSIZE(file), file, Connection_CurSelPos), 0, NULL, SW_SHOW);
+						}
+						break;
+
+					case IDC_CLEAR_LOG:
+						{
+							MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+							if (Out->Logging && logFiles[Connection_CurSelPos] != INVALID_HANDLE_VALUE) {
+								SetFilePointer(logFiles[Connection_CurSelPos], 0, NULL, FILE_BEGIN);
+								SetEndOfFile(logFiles[Connection_CurSelPos]);
+							} else {
+								wchar_t file[MAX_PATH];
+								HANDLE handle = CreateFileW(GetSCLogFile(module.hwndParent, ARRAYSIZE(file), file, Connection_CurSelPos),
+															GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
+								if (handle != INVALID_HANDLE_VALUE) {
+									SetFilePointer(handle, 0, NULL, FILE_BEGIN);
+									SetEndOfFile(handle);
+									CloseHandle(handle);
+								}
+							}
+						}
+						break;
+
+					case IDC_LOGGING:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->Logging = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								if (Out->Logging) {
+									StartLogging(Connection_CurSelPos,Out->LogCOS);
+								} else {
+									StopLogging(Connection_CurSelPos);
+								}
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_CLEAR_ON_STARTUP:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->LogCOS = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_NEXT_TRACK_LOG:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->nextTrackLog = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								if (Out->nextTrackLog) {
+									StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
+									FillNextTracks(Connection_CurSelPos, !!Out->nextTrackLogXML);
+								} else {
+									StopNextTracks(Connection_CurSelPos);
+								}
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, Out->nextTrackLog);
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, Out->nextTrackLog);
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_BROWSE, Out->nextTrackLog);
+
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_NEXT_TRACK_XML:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->nextTrackLogXML = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								// reset the file if changing the state
+								if (Out->nextTrackLog) {
+									StopNextTracks(Connection_CurSelPos);
+									StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
+									FillNextTracks(Connection_CurSelPos, !!Out->nextTrackLogXML);
+								}
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_NEXT_TRACK_EDIT:
+						{
+							if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_NEXT_TRACK_BROWSE:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								wchar_t filepath[MAX_PATH] = {0},
+										file[MAX_PATH] = {0},
+										filter[64] = {0};
+								// strip path so we can set initial directory, etc
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								wcsncpy(filepath, Out->nextTrackPath, MAX_PATH);
+								wcsncpy(file, Out->nextTrackPath, MAX_PATH);
+								PathRemoveFileSpecW(filepath);
+								PathStripPathW(file);
+
+								OPENFILENAMEW ofn = {0};
+								ofn.lStructSize=sizeof(ofn);
+								ofn.hwndOwner=hMainDLG;
+
+								WASABI_API_LNGSTRINGW_BUF(IDS_ALL_FILES, filter, 64);
+								wchar_t * ptr=filter;
+								while(ptr && *ptr) {
+									if (*ptr==L'|') *ptr=0;
+									ptr++;
+								}
+
+								ofn.lpstrFilter=filter;
+								ofn.lpstrInitialDir=filepath;
+								ofn.lpstrFile=file;
+								ofn.nMaxFile=MAX_PATH;
+								ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
+								ofn.lpstrDefExt=L"log";
+								if (GetSaveFileNameW(&ofn))
+								{
+									// update things if the filename changed, etc
+									wcsncpy(Out->nextTrackPath, file, MAX_PATH);
+									SetDlgItemTextW(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, Out->nextTrackPath);
+									if (Out->nextTrackLog) {
+										StopNextTracks(Connection_CurSelPos);
+										StartNextTracks(Connection_CurSelPos, Out->nextTrackPath);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_SAVE_ENCODED_AUDIO:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->saveEncoded = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+
+								// reset the file if changing the state
+								if (Out->saveEncoded) {
+									StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
+								} else {
+									StopSaveEncoded(Connection_CurSelPos);
+								}
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_SAVE_ENCODED_AUDIO_EDIT:
+						{
+							if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_SAVE_ENCODED_AUDIO_BROWSE:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								wchar_t filepath[MAX_PATH] = {0},
+										file[MAX_PATH] = {0},
+										filter[64] = {0};
+								// strip path so we can set initial directory, etc
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								wcsncpy(filepath, Out->saveEncodedPath, MAX_PATH);
+								wcsncpy(file, Out->saveEncodedPath, MAX_PATH);
+								PathRemoveFileSpecW(filepath);
+								PathStripPathW(file);
+
+								OPENFILENAMEW ofn = {0};
+								ofn.lStructSize=sizeof(ofn);
+								ofn.hwndOwner=hMainDLG;
+								// sets the default extension if not specified to the type of the encoder being used
+								ofn.lpstrDefExt=(Enc_LastType[Connection_CurSelPos] != 0 ?
+												 (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/mpeg") ? L"mp3" :
+												  (!strcmp(Encoder[Out->Encoder].GetEncoder()->GetContentType(),"audio/ogg") ? L"ogg" : L"aac")) : L"");
+
+								StringCchPrintfW(filter, ARRAYSIZE(filter), WASABI_API_LNGSTRINGW(IDS_MPEG_AUDIO_FILES), ofn.lpstrDefExt, ofn.lpstrDefExt);
+								wchar_t* ptr=filter;
+								while(ptr && *ptr) {
+									if (*ptr==L'|') *ptr=0;
+									ptr++;
+								}
+
+								ofn.lpstrFilter=filter;
+								ofn.lpstrInitialDir=filepath;
+								ofn.lpstrFile=file;
+								ofn.nMaxFile=MAX_PATH;
+								ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
+
+								if (GetSaveFileNameW(&ofn))
+								{
+									// update things if the filename changed, etc
+									wcsncpy(Out->saveEncodedPath, file, MAX_PATH);
+									SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, Out->saveEncodedPath);
+									if (Out->saveEncoded) {
+										StopSaveEncoded(Connection_CurSelPos);
+										StartSaveEncoded(Connection_CurSelPos, Out->saveEncodedPath);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_USE_ART:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->useArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, Out->useArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, Out->useArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, Out->useArt && Out->useStreamArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, Out->useArt && Out->useStreamArt);
+
+								// only update if we need to do so
+								UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, Out->useArt && Out->useStreamArt);
+
+								// this will update against what is read from the playing
+								UpdatePlayingAlbumArt(Out->Handle, Connection_CurSelPos, Out->useArt && Out->usePlayingArt);
+
+								Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
+
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_USE_ART_PLAYING:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->usePlayingArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								ini_modified = 1;
+
+								if(Out->usePlayingArt){
+									playingLength = 0;
+									playingType = 0x4101;	// default in-case of issue
+
+									int w = 0, h = 0;
+									if (AGAVE_API_ALBUMART && AGAVE_API_ALBUMART->GetAlbumArt(lastFile, L"cover", &w, &h, &playingImage) == ALBUMART_SUCCESS) {
+										// make sure to free the original image after we've converted
+										ARGB32 *firstPlayingImage = playingImage;
+										playingImage = writeImg(playingImage, w, h, &playingLength, L"png");
+										WASABI_API_MEMMGR->sysFree(firstPlayingImage);
+									} else {
+										playingImage = 0;
+									}
+								}
+
+								UpdatePlayingAlbumArt(Out->Handle, Connection_CurSelPos, Out->useArt && Out->usePlayingArt);
+								Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
+							}
+						}
+						break;
+
+					case IDC_USE_ART_STREAM:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->useStreamArt = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								ini_modified = 1;
+
+								// skip this all if the mode is not enabled and only in SC2 mode
+								if ((LOBYTE(Out->Config.protocol) != 1) && Out->useArt) {
+									// this will only update generally on first connection
+									if (Out->useStreamArt && streamImage[Connection_CurSelPos] == (ARGB32 *)-1) {
+										UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt);
+									}
+								}
+
+								if (UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt)) {
+									Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
+								}
+
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, Out->useStreamArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, Out->useStreamArt);
+							}
+						}
+						break;
+
+					case IDC_ART_EDIT:
+						{
+							if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_ART_BROWSE:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								wchar_t filepath[MAX_PATH] = {0},
+										file[MAX_PATH] = {0};
+								// strip path so we can set initial directory, etc
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								wcsncpy(filepath, Out->stationArtPath, MAX_PATH);
+								wcsncpy(file, Out->stationArtPath, MAX_PATH);
+								PathRemoveFileSpecW(filepath);
+								PathStripPathW(file);
+
+								OPENFILENAMEW ofn = {0};
+								ofn.lStructSize=sizeof(ofn);
+								ofn.hwndOwner=hMainDLG;
+								ofn.lpstrInitialDir=filepath;
+								ofn.lpstrFile=file;
+								ofn.nMaxFile=MAX_PATH;
+								ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
+								ofn.lpstrDefExt=L"png";
+								ofn.nFilterIndex=lastFilterIndex;
+
+								static int tests_run = 0;
+								static wchar_t filter[1024] = {0}, *sff = filter;
+
+								if (!tests_run) {
+									tests_run = 1;
+									FOURCC imgload = svc_imageLoader::getServiceType();
+									int n = WASABI_API_SVC->service_getNumServices(imgload);
+									for (int i=0; i<n; i++) {
+										waServiceFactory *sf = WASABI_API_SVC->service_enumService(imgload, i);
+										if (sf) {
+											svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
+											if (l) {
+												static int tests_idx[4] = {0, 1, 2, 3};
+												size_t size = 1024;
+												int j = 0, tests_str[] = {IDS_JPEG_FILE, IDS_PNG_FILE, IDS_BMP_FILE, IDS_GIF_FILE};
+												wchar_t *tests[] = {L"*.jpg", L"*.png", L"*.bmp", L"*.gif"};
+												for (int i = 0; i < ARRAYSIZE(tests); i++) {
+													if (l->isMine(tests[i])) {
+														tests_idx[j] = i;
+														j++;
+														int len = 0;
+														LocalisedString(tests_str[i], sff, size);
+														size-=(len = wcslen(sff)+1);
+														sff+=len;
+														wcsncpy(sff, (!i ? L"*.jpg;*.jpeg" : tests[i]), size);
+														size-=(len = wcslen(sff)+1);
+														sff+=len;
+													}
+												}
+												sf->releaseInterface(l);
+											}
+										}
+									}
+								}
+
+								ofn.lpstrFilter = filter;
+
+								if (GetOpenFileNameW(&ofn))
+								{
+									// update things if the filename changed, etc
+									wcsncpy(Out->stationArtPath, file, MAX_PATH);
+									SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_EDIT, Out->stationArtPath);
+
+									if (UpdateStreamAlbumArt(Out->Handle, Connection_CurSelPos, Out->stationArtPath, !!Out->useStreamArt)) {
+										Encoder[Connection_CurSelPos].UpdateArtwork(Out->Handle);
+									}
+								}
+								lastFilterIndex = ofn.nFilterIndex;
+							}
+						}
+						break;
+
+					case IDC_AUTOCONNECT:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								Output[Connection_CurSelPos].AutoConnect = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								if (Output[Connection_CurSelPos].Encoder) {
+									if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
+										ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_RECONNECT:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								Output[Connection_CurSelPos].Config.AutoRecon = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+								if (Output[Connection_CurSelPos].Encoder) {
+									if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
+										ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_PROTOCOL:
+						{
+							if (HIWORD(wParam) == CBN_SELCHANGE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+
+								int cur_sel = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0),
+									protocol = SendMessage((HWND) lParam, CB_GETITEMDATA, cur_sel, 0);
+
+								Out->Config.protocol = MAKEWORD(protocol, !protocol);
+
+								// force a refresh on selection change
+								lastMode[Connection_CurSelPos] = -1;
+
+								// jkey: disable or enable userid stationid based on protocol.
+								if (Output[Connection_CurSelPos].Encoder) {
+									if (WaitForSingleObject(Enc_mutex[Output[Connection_CurSelPos].Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Encoder[Output[Connection_CurSelPos].Encoder].UpdateOutput(Output[Connection_CurSelPos].Handle);
+										ReleaseMutex(Enc_mutex[Output[Connection_CurSelPos].Encoder]);
+									}
+								}
+								//shoutcast 2 else 1 enable aim,icq,irc
+								EnableWindowDlgItem(hDlg, IDC_STATIONID, (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1));
+								UpdateTitleControls();
+							}
+						}
+						break;
+
+					case IDC_CONNECT:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								SHOUTCAST_OUTPUT *Enc = Out->Encoder != -1 ? &Encoder[Out->Encoder] : NULL;
+								if (Enc && Out->Handle != -1) {
+									int state = Enc->GetState(Out->Handle);
+									if (state == OUT_DISCONNECTED) { // disconnected... connect now
+										Enc->ConnectOutput(Out->Handle);
+									} else { // connected... disconnect now
+										Enc->DisconnectOutput(Out->Handle);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_DEVBOX:
+						{
+							if (HIWORD(wParam) == CBN_SELCHANGE) {
+								Input_Device_ID = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
+							}
+						}
+						break;
+
+					case IDC_LOCK:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								int checked = SendMessage((HWND) lParam, BM_GETCHECK, -1, -1) == BST_CHECKED;
+								EnableWindowDlgItem(hDlg, IDC_PTT, !checked);
+								SendDlgItemMessage(hDlg, IDC_PTT, BM_SETSTATE, checked ? BST_CHECKED : BST_UNCHECKED, 0);
+								KillTimer(hMainDLG, 2234);
+								KillTimer(hMainDLG, 2235);
+								if ((MicFadeStartTime != 0 || FadeStartTime != 0) && FadeOut != checked) {
+									clock_t myTime = clock();
+									if (FadeStartTime != 0) FadeStartTime = myTime - ((FadeTime * 100)-(myTime - FadeStartTime));
+									if (MicFadeStartTime != 0) MicFadeStartTime = myTime - ((MicFadeTime * 100)-(myTime - MicFadeStartTime));
+								}
+								if(!ptt_load && Restore_PTT || ptt_load) {
+									FadeOut = checked;
+									SetTimer(hMainDLG, 2234, 10, NULL); // fade out
+									SetTimer(hMainDLG, 2235, 10, NULL); // fade out
+								} else {
+									SetDeviceName();
+								}								
+								ptt_load = 1;
+								//if (FadeOut) do_capture();
+								#ifdef CAPTURE_TESTING
+								if (FadeOut) {
+									if (!pPlayer) {
+										pPlayer = new Player(hMainDLG);
+									}
+									if (!pCallbacks) {
+										pCallbacks = new CPlayerCallbacks();
+									}
+									pPlayer->SetPlayerCallbacks(pCallbacks);
+									pPlayer->RefreshDeviceList(eRender);
+									pPlayer->RefreshDeviceList(eCapture);
+									pPlayer->SelectDefaultDevice(eRender, eConsole);
+									pPlayer->SelectDefaultDevice(eCapture, eConsole);
+									pPlayer->SelectDeviceFromList(eCapture, 0);
+									//pPlayer->SelectDeviceFromList(eRender, 2);
+									if (pPlayer->Play(eCaptureEndpoint) == FALSE) {
+										return TRUE;
+									}
+								}
+								#endif
+							}
+						}
+						break;
+
+					case IDC_LOCK_MODE:
+						{
+							HMENU hmenu = CreatePopupMenu();
+							RECT r;
+							GetWindowRect((HWND)lParam, &r);
+
+							MENUITEMINFOW i = {sizeof(i), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING,
+							                   Restore_PTT ? MFS_CHECKED : 0, 1337};
+							i.dwTypeData = LocalisedString(IDS_PTT_ON_STARTUP, NULL, 0);
+							InsertMenuItemW(hmenu, 0, TRUE, &i);
+							if (TrackPopupMenu(hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, r.left, r.bottom, 0, (HWND)lParam, NULL) == 1337) {
+								Restore_PTT = !Restore_PTT;
+							}
+							DestroyMenu(hmenu);
+						}
+						break;
+
+					case IDC_REFRESH_DEVICES:
+						{
+							if (IsVistaUp()) {
+								SendDlgItemMessage(inWin,IDC_DEVBOX, CB_RESETCONTENT, 0, 0);
+								SetDeviceName();
+							}
+						}
+						break;
+
+					case IDC_MIXER:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								// open vista / win7 or win2k / xp recording panel
+								// (more sensible esp. for vista / win7)
+								if (IsVistaUp()) {
+									ShellExecuteW(hMainDLG, L"open", L"control.exe", L"mmsys.cpl,,1", NULL, SW_SHOW);
+								} else {
+									ShellExecuteW(hMainDLG, L"open", L"sndvol32.exe", L"", NULL, SW_SHOW);
+									ShellExecuteW(hMainDLG, L"open", L"sndvol32.exe", L"/r", NULL, SW_SHOW);
+								}
+							}
+						}
+						break;
+
+					case IDC_OUTPUTLIST:
+						{
+							if (HIWORD(wParam) == LBN_SELCHANGE) {
+								Connection_CurSelPos = SendMessage((HWND) lParam, LB_GETCURSEL, 0, 0);
+
+								// force a refresh on selection change
+								lastMode[Connection_CurSelPos] = -1;
+
+								// do checks to see if we need to update the error state of the tab items
+								if (IsWindow(outTabWnd)) {
+									RECT r = {0};
+									for (int i = 0; i < MAX_OUTWNDS; i++) {
+										TabCtrl_GetItemRect(outTabWnd, i, &r);
+										InvalidateRect(outTabWnd, &r, 0);
+									}
+
+									TabCtrl_GetItemRect(GetDlgItem(hMainDLG, IDC_TAB), 1, &r);
+									InvalidateRect(GetDlgItem(hMainDLG, IDC_TAB), &r, 0);
+								}
+
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								MY_T_OUTPUT * OutEnc = &Output[Connection_CurSelPos];
+								int sc2mode = (LOBYTE(Out->protocol) != 1);
+								// Output page 1
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_ADDRESS, EM_SETLIMITTEXT, ARRAYSIZE(Out->Address) - 1, 0);
+								SetDlgItemText(out_wnd[0].hWnd, IDC_ADDRESS, Out->Address);
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_STATIONID, EM_SETLIMITTEXT, 10, 0);
+								SetDlgItemText(out_wnd[0].hWnd, IDC_STATIONID, Out->StationID);
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_USERID, EM_SETLIMITTEXT, ARRAYSIZE(Out->UserID) - 1, 0);
+								SetDlgItemText(out_wnd[0].hWnd, IDC_USERID, Out->UserID);
+								SetDlgItemInt(out_wnd[0].hWnd, IDC_PORT, Out->Port, 0);
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_PASSWORD, EM_SETLIMITTEXT, ARRAYSIZE(Out->Password) - 1, 0);
+								SetDlgItemText(out_wnd[0].hWnd, IDC_PASSWORD, Out->Password);
+								int encval = OutEnc->Encoder;
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_RECONNECT, BM_SETCHECK, Out->AutoRecon ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK, OutEnc->AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
+
+								SetDlgItemInt(out_wnd[0].hWnd, IDC_TIMEOUT, Out->ReconTime, 0);
+
+								EnableWindowDlgItem(out_wnd[0].hWnd, IDC_STATIONID, sc2mode);
+								SendDlgItemMessage(out_wnd[0].hWnd, IDC_PROTOCOL, CB_SETCURSEL, (HIBYTE(Out->protocol) ? 0 : (sc2mode ? 1 : 2)), 0);
+
+
+								// Output page 2
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_PUBLIC, BM_SETCHECK, Out->Public ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_DESCRIPTION, EM_SETLIMITTEXT, ARRAYSIZE(Out->Description) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_DESCRIPTION, Out->Description);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_SERVERURL, EM_SETLIMITTEXT, ARRAYSIZE(Out->ServerURL) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_SERVERURL, Out->ServerURL);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_GENRE, EM_SETLIMITTEXT, ARRAYSIZE(Out->Genre) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_GENRE, Out->Genre);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_AIM, EM_SETLIMITTEXT, ARRAYSIZE(Out->AIM) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_AIM, Out->AIM);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_ICQ, EM_SETLIMITTEXT, ARRAYSIZE(Out->ICQ) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_ICQ, Out->ICQ);
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_IRC, EM_SETLIMITTEXT, ARRAYSIZE(Out->IRC) - 1, 0);
+								SetDlgItemText(out_wnd[1].hWnd, IDC_IRC, Out->IRC);
+
+								SendDlgItemMessage(out_wnd[1].hWnd, IDC_AUTOCONNECT, BM_SETCHECK, OutEnc->AutoConnect ? BST_CHECKED : BST_UNCHECKED, 0);
+
+								// setup the handling of the encoder saving options
+								SendDlgItemMessage(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->stationArtPath) - 1, 0);
+								SetDlgItemTextW(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO_EDIT, OutEnc->saveEncodedPath);
+								SendDlgItemMessage(out_wnd[2].hWnd, IDC_SAVE_ENCODED_AUDIO, BM_SETCHECK, OutEnc->saveEncoded ? BST_CHECKED : BST_UNCHECKED, 0);
+
+								// setup the handling of the titles options
+								SendDlgItemMessage(out_wnd[3].hWnd, IDC_TITLE, EM_SETLIMITTEXT, ARRAYSIZE(Out->Now) - 1, 0);
+								SetDlgItemText(out_wnd[3].hWnd, IDC_TITLE, Out->Now);
+								SendDlgItemMessage(out_wnd[3].hWnd, IDC_NEXT, EM_SETLIMITTEXT, ARRAYSIZE(Out->Next) - 1, 0);
+								SetDlgItemText(out_wnd[3].hWnd, IDC_NEXT, Out->Next);
+								CheckRadioButton(out_wnd[3].hWnd, IDC_NOTITLES, IDC_MANUALTITLE, (Out->doTitleUpdate ? (OutEnc->AutoTitle ? IDC_AUTOTITLE : IDC_MANUALTITLE) : IDC_NOTITLES));
+								SendDlgItemMessage(out_wnd[3].hWnd, IDC_SENDNEXTTITLES, BM_SETCHECK, OutEnc->NextTitles ? BST_CHECKED : BST_UNCHECKED, 0);
+								UpdateTitleControls();
+
+								// setup the handling of the artwork options
+								SendDlgItemMessage(out_wnd[4].hWnd, IDC_ART_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->stationArtPath) - 1, 0);
+								SetDlgItemTextW(out_wnd[4].hWnd, IDC_ART_EDIT, OutEnc->stationArtPath);
+								SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART, BM_SETCHECK, OutEnc->useArt ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, BM_SETCHECK, OutEnc->usePlayingArt ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[4].hWnd, IDC_USE_ART_STREAM, BM_SETCHECK, OutEnc->useStreamArt ? BST_CHECKED : BST_UNCHECKED, 0);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_PLAYING, OutEnc->useArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_USE_ART_STREAM, OutEnc->useArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_EDIT, OutEnc->useArt && OutEnc->useStreamArt);
+								EnableWindowDlgItem(out_wnd[4].hWnd, IDC_ART_BROWSE, OutEnc->useArt && OutEnc->useStreamArt);
+								UpdateArtworkMessage();
+
+								// setup the handling of the next track logging option
+								SendDlgItemMessage(out_wnd[5].hWnd, IDC_LOGGING, BM_SETCHECK, OutEnc->Logging ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[5].hWnd, IDC_CLEAR_ON_STARTUP, BM_SETCHECK, OutEnc->LogCOS ? BST_CHECKED : BST_UNCHECKED, 0);
+
+								SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_LOG, BM_SETCHECK, OutEnc->nextTrackLog ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, BM_SETCHECK, OutEnc->nextTrackLogXML ? BST_CHECKED : BST_UNCHECKED, 0);
+								SendDlgItemMessage(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, EM_SETLIMITTEXT, ARRAYSIZE(OutEnc->nextTrackPath) - 1, 0);
+								SetDlgItemTextW(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, OutEnc->nextTrackPath);
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_XML, OutEnc->nextTrackLog);
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_EDIT, OutEnc->nextTrackLog);
+								EnableWindowDlgItem(out_wnd[5].hWnd, IDC_NEXT_TRACK_BROWSE, OutEnc->nextTrackLog);
+
+								// this is sent to the encoders tab so it will update the selection for the current instance
+								// note: this is a change in build 009 to remove the prior listbox and reduce ui inconsistency
+								SendMessage(out_wnd[2].hWnd, WM_COMMAND, MAKEWPARAM(IDC_ENCODERLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(wnd[2].hWnd, IDC_ENCODERLIST));
+
+								ini_modified = 1;
+							}
+						}
+						break;
+
+					case IDC_INPUTSETUP:
+						{
+							if (HIWORD(wParam) == CBN_SELCHANGE) {
+								if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
+									Crossfader->SetChannels(LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].nch);
+									Crossfader->SetSampleRate(LineInputAttribs[(InputDevice == 0 ? 3 : Input_CurSelPos)].srate);
+									ReleaseMutex(cf_mutex);
+								}
+
+								int attrib = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
+								if (attrib != Input_CurSelPos) {
+									SuspendThread(hthread);
+									Soundcard.Close();
+									if (InputDevice == 1) {
+										Input_CurSelPos = attrib;
+									}
+									for (int i = 0; i < NUM_ENCODERS; i++) {
+										if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
+											C_ENCODER *Enc = Encoder[i].GetEncoder();
+											if (Enc) {
+												int infosize = sizeof (T_EncoderIOVals);
+												T_EncoderIOVals *encset = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
+												if (encset && infosize) {
+													T_EncoderIOVals *EncSettings = (T_EncoderIOVals *) malloc(infosize);
+													memcpy(EncSettings, encset, infosize);
+
+													if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
+														((T_ENCODER_MP3_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_MP3_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) {
+														((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) {
+														((T_ENCODER_AACP_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_AACP_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													}
+#ifdef USE_OGG
+													else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) {
+														((T_ENCODER_OGG_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_OGG_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													}
+#endif // USE_OGG
+													Enc->ChangeSettings(EncSettings);
+													free(EncSettings);
+												}
+											}
+											ReleaseMutex(Enc_mutex[i]);
+										}
+									}
+									Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
+									ResumeThread(hthread);
+									ini_modified = 1;
+								}
+							}
+						}
+						break;
+
+					case IDC_INPUT_WINAMP:
+					case IDC_INPUT_SOUNDCARD:
+						{
+							// update the input mode from the summary page options
+							HWND inputCtrl = GetDlgItem(wnd[2].hWnd, IDC_INPUTDEVICE);
+							SendMessage(inputCtrl, CB_SETCURSEL, (LOWORD(wParam) - IDC_INPUT_WINAMP), 0);
+							SendMessage(wnd[2].hWnd, WM_COMMAND, MAKEWPARAM(IDC_INPUTDEVICE,CBN_SELCHANGE), (LPARAM)inputCtrl);
+						}
+						break;
+
+					case IDC_INPUTDEVICE:
+						{
+							if (HIWORD(wParam) == CBN_SELCHANGE) {
+								int this_device = SendMessage((HWND) lParam, CB_GETCURSEL, 0, 0);
+								if (InputDevice != this_device) {
+									SuspendThread(hthread);
+									Soundcard.Close();
+									InputDevice = this_device;
+									if (InputDevice == 0) { // winamp
+										SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MUSSLIDER));
+										SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MUS2SLIDER));
+										SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MICSLIDER));
+										SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_FADESLIDER));
+										SendMessage(in_wnd[this_device].hWnd, WM_HSCROLL, 0, (LPARAM) GetDlgItem(in_wnd[this_device].hWnd, IDC_MICFADESLIDER));
+									}
+									for (int i = 0; i < NUM_ENCODERS; i++) {
+										if (WaitForSingleObject(Enc_mutex[i], INFINITE) == WAIT_OBJECT_0) {
+											C_ENCODER *Enc = Encoder[i].GetEncoder();
+											if (Enc) {
+												int infosize = sizeof (T_EncoderIOVals);
+												T_EncoderIOVals *encset = (T_EncoderIOVals *) Enc->GetExtInfo(&infosize);
+												if (encset && infosize) {
+													T_EncoderIOVals *EncSettings = (T_EncoderIOVals *) malloc(infosize);
+													memcpy(EncSettings, encset, infosize);
+
+													if (strcmp(Enc->GetName(), "MP3 Encoder") == 0) {
+														((T_ENCODER_MP3_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_MP3_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													} else if (strcmp(Enc->GetName(), "Fraunhofer Encoder") == 0) {
+														((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_FHGAAC_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													} else if (strcmp(Enc->GetName(), "AAC+ Encoder") == 0) {
+														((T_ENCODER_AACP_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_AACP_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													}
+#ifdef USE_OGG
+													else if (strcmp(Enc->GetName(), "OGG Vorbis Encoder") == 0) {
+														((T_ENCODER_OGG_INFO *) EncSettings)->input_numChannels = (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch);
+														((T_ENCODER_OGG_INFO *) EncSettings)->input_sampleRate = (InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate);
+													}
+#endif // USE_OGG
+													Enc->ChangeSettings(EncSettings);
+													free(EncSettings);
+												}
+											}
+											ReleaseMutex(Enc_mutex[i]);
+										}
+									}
+									Soundcard.Create((InputDevice == 0 ? InputConfig.srate : LineInputAttribs[Input_CurSelPos].srate), (InputDevice == 0 ? InputConfig.nch : LineInputAttribs[Input_CurSelPos].nch));
+
+									DisplayDeviceName();
+									CheckRadioButton(wnd[0].hWnd, IDC_INPUT_WINAMP, IDC_INPUT_SOUNDCARD, (IDC_INPUT_WINAMP + InputDevice));
+
+									peak_vu_l = peak_vu_r = -90;
+									ResumeThread(hthread);
+									ini_modified = 1;
+								}
+								SendDlgItemMessage(hDlg, IDC_INPUTSETUP, CB_RESETCONTENT, 0, 0);
+								if (InputDevice == 1) {
+									wchar_t temp[128];
+									int num_input_items = ARRAYSIZE(LineInputAttribs);
+									for (int i = 0; i < num_input_items; i++) {
+										wchar_t tmp[32];
+										StringCchPrintfW(temp, ARRAYSIZE(temp), LocalisedString(IDS_X_HZ_X, tmp, 32), LineInputAttribs[i].srate, LocalisedString(LineInputAttribs[i].nch == 1 ? IDS_MONO : IDS_STEREO, NULL, 0));
+										SendDlgItemMessageW(hDlg, IDC_INPUTSETUP, CB_ADDSTRING, 0, (LPARAM) temp);
+									}
+									SendDlgItemMessage(hDlg, IDC_INPUTSETUP, CB_SETCURSEL, Input_CurSelPos, 0);
+								}
+								for (int i = 0; i < num_inwnds; i++) ShowWindow(in_wnd[i].hWnd, i == InputDevice && curtab == 2 ? SW_SHOW : SW_HIDE);
+								SendMessage(hDlg, WM_COMMAND, MAKEWPARAM(IDC_INPUTSETUP, CBN_SELCHANGE), (LPARAM) GetDlgItem(hDlg, IDC_INPUTSETUP));
+								ShowWindowDlgItem(hDlg, IDC_INPUTSETUPSTATIC, InputDevice == 1);
+								ShowWindowDlgItem(hDlg, IDC_INPUTSETUP, InputDevice == 1);
+							}
+						}
+						break;
+
+						// server box
+					case IDC_ADDRESS:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								GetWindowText((HWND) lParam, Out->Address, ARRAYSIZE(Out->Address));
+								ini_modified = 1;
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+						// stream ID box
+					case IDC_STATIONID:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								BOOL success = FALSE;
+								int value = GetDlgItemInt(hDlg, LOWORD(wParam), &success, TRUE);
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								GetWindowText((HWND) lParam, Out->StationID, ARRAYSIZE(Out->StationID));
+								// check and set the default as required
+								if (!Out->StationID[0] || (success && value < 1 || !success && value == 0)) {
+									SetWindowTextW((HWND) lParam, L"1");
+									lstrcpyn(Out->StationID, "1", ARRAYSIZE(Out->StationID));
+								} else if (Out->StationID[0] && (success && value > 2147483647)) {
+									SetWindowTextW((HWND) lParam, L"2147483647");
+									lstrcpyn(Out->StationID, "2147483647", ARRAYSIZE(Out->StationID));
+								}
+								ini_modified = 1;
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_USERID:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								GetWindowText((HWND) lParam, Out->UserID, ARRAYSIZE(Out->UserID));
+								ini_modified = 1;
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+						// server port
+					case IDC_PORT:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								BOOL success = FALSE;
+								int value = GetDlgItemInt(hDlg, LOWORD(wParam), &success, TRUE);
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								// check and set the default as required
+								if ((success && value < 1 || !success && value == 0)) {
+									SetWindowTextW((HWND) lParam, L"8000");
+									Out->Port = 8000;
+								} else if ((success && value > 65535)) {
+									SetWindowTextW((HWND) lParam, L"65535");
+									Out->Port = 65535;
+								} else {
+									Out->Port = value;
+								}
+
+								ini_modified = 1;
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+						// password
+					case IDC_PASSWORD:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								T_OUTPUT_CONFIG *Out = &Output[Connection_CurSelPos].Config;
+								GetWindowText((HWND) lParam, Out->Password, ARRAYSIZE(Out->Password));
+								ini_modified = 1;
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_SEND:
+						{
+							EnableWindowDlgItem(hDlg, IDC_SEND, FALSE);
+							MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+							if (Out->Encoder != -1 && Out->Handle != -1) {
+								wchar_t title[1024] = {0}, next[1024] = {0};
+								SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+								GetWindowTextW(GetDlgItem(out_wnd[3].hWnd, IDC_TITLE), title, ARRAYSIZE(title));
+								GetWindowTextW(GetDlgItem(out_wnd[3].hWnd, IDC_NEXT), next, ARRAYSIZE(next));
+								ini_modified = 1;
+								if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+									std::vector<std::wstring> nextList;
+									std::vector<int> nextListIdx;
+									nextList.clear();
+									nextListIdx.clear();
+									if (((Out->AutoTitle == 1 && Out->NextTitles) || Out->AutoTitle == 0) && next[0]) {
+										nextList.push_back(next);
+										nextListIdx.push_back(-1);
+									}
+
+									if (Out->nextTrackLog) {
+										WriteNextTracks(Connection_CurSelPos, module.hwndParent, nextListIdx, nextList, !!Out->nextTrackLogXML);
+									}
+
+									// check if in v2 mode and have a next title specified so as to change the send flag
+									Enc->UpdateTitle(title, nextList, Out->Handle, !!nextList.size(), false);
+									ReleaseMutex(Enc_mutex[Out->Encoder]);
+								}
+							}
+						}
+						break;
+
+					case IDC_TITLE:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								int length = GetWindowTextLength((HWND)lParam);
+								EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, (length > 0));
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								EnableWindowDlgItem(out_wnd[3].hWnd, IDC_NEXT,
+													(length > 0 && (LOBYTE(Out->Config.protocol) != 1)));
+
+								char temp[sizeof(Out->Config.Now)];
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.Now) != 0) {
+									lstrcpyn(Out->Config.Now, temp, ARRAYSIZE(Out->Config.Now));
+									ini_modified = 1;
+								}
+							}
+						}
+						break;
+
+					case IDC_NEXT:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								EnableWindowDlgItem(out_wnd[3].hWnd, IDC_SEND, TRUE);
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+
+								char temp[sizeof(Out->Config.Next)];
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.Next) != 0) {
+									lstrcpyn(Out->Config.Next, temp, ARRAYSIZE(Out->Config.Next));
+									ini_modified = 1;
+								}
+							}
+						}
+						break;
+
+					case IDC_TIMEOUT:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[128] = {0};
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+
+								int rt = atoi(temp);
+								if (rt < 1) {
+									rt = 5;
+									SetDlgItemInt(out_wnd[0].hWnd, IDC_TIMEOUT, 5, 0);
+								}
+
+								if (Out->Config.ReconTime != rt) {
+									Out->Config.ReconTime = rt;
+									if (Out->Encoder) {
+										if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+											Encoder[Out->Encoder].UpdateOutput(Out->Handle);
+											ReleaseMutex(Enc_mutex[Out->Encoder]);
+										}
+									}
+									ini_modified = 1;
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					// these will reconnect the Output on edit
+					case IDC_PUBLIC:
+						{
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								Out->Config.Public = SendMessage((HWND) lParam, BM_GETCHECK, 0, 0) == BST_CHECKED;
+
+								// force a refresh on selection change
+								lastMode[Connection_CurSelPos] = -1;
+
+								ini_modified = 1;
+								if (Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							}
+						}
+						break;
+
+					case IDC_GENRES:
+						{
+							// build up a menu to allow the user to select only supported genres for use with YP
+							if (HIWORD(wParam) == BN_CLICKED) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								HMENU hmenu = CreatePopupMenu(), submenu = 0;
+								RECT r;
+								GetWindowRect((HWND)lParam, &r);
+
+								for (unsigned int i = 0; i < ARRAYSIZE(genres); i++) {
+									MENUITEMINFO mii = {sizeof(mii), MIIM_ID | MIIM_STATE | MIIM_TYPE, MFT_STRING, 0, 1+i, 0, 0, 0, 0, 0, 0};
+									bool reAdd = false;
+
+									// fix up genres with & in it to work around menu accelerator display quirks
+									std::string str = genres[i].name;
+									if (str.find("&") != std::string::npos)
+										str.replace(str.find("&"),1,"&&");
+									mii.dwTypeData = (LPSTR)str.c_str();
+
+									if (genres[i].parent) {
+										if (genres[i].children) {
+											reAdd = true;
+											mii.fMask |= MIIM_SUBMENU;
+											submenu = mii.hSubMenu = CreatePopupMenu();
+										}
+									}
+
+									if (reAdd == false && !strcmpi(Out->Config.Genre, genres[i].name)) {
+										mii.fState = MFS_CHECKED;
+									}
+
+									InsertMenuItem((genres[i].parent ? hmenu : submenu), i, TRUE, &mii);
+
+									if (reAdd == true) {
+										mii.fMask -= MIIM_SUBMENU;
+										if (!strcmpi(Out->Config.Genre, genres[i].name)) {
+											mii.fState = MFS_CHECKED;
+										}
+										InsertMenuItem(submenu, i, TRUE, &mii);
+									}
+								}
+
+								int ret = TrackPopupMenu(hmenu, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RETURNCMD, r.left, r.bottom, 0, (HWND)hDlg, NULL);
+								if (ret > 0) {
+									int update = 0;
+									ret -= 1;
+									if (strcmp(genres[ret].name, Out->Config.Genre) != 0) {
+										update = 1;
+										SetDlgItemText(hDlg, IDC_GENRE, genres[ret].name);
+										lstrcpyn(Out->Config.Genre, genres[ret].name, ARRAYSIZE(Out->Config.Genre));
+										ini_modified = 1;
+									}
+									if (update && Out->Encoder != -1 && Out->Handle != -1) {
+										SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+										if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+											Enc->DisconnectOutput(Out->Handle, 1, 5);
+											ReleaseMutex(Enc_mutex[Out->Encoder]);
+										}
+									}
+								}
+
+								DestroyMenu(hmenu);
+							}
+						}
+						break;
+
+					case IDC_DESCRIPTION:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[sizeof (Out->Config.Description)];
+								int update = 0;
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.Description) != 0) {
+									update = 1;
+									lstrcpyn(Out->Config.Description, temp, ARRAYSIZE(Out->Config.Description));
+									ini_modified = 1;
+								}
+								if (update && Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_SERVERURL:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[sizeof (Out->Config.ServerURL)];
+								int update = 0;
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.ServerURL) != 0) {
+									update = 1;
+									lstrcpyn(Out->Config.ServerURL, temp, ARRAYSIZE(Out->Config.ServerURL));
+									ini_modified = 1;
+								}
+								if (update && Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_AIM:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[sizeof (Out->Config.AIM)];
+								int update = 0;
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.AIM) != 0) {
+									update = 1;
+									lstrcpyn(Out->Config.AIM, temp, ARRAYSIZE(Out->Config.AIM));
+									ini_modified = 1;
+								}
+								if (update && Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_ICQ:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[sizeof (Out->Config.ICQ)];
+								int update = 0;
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.ICQ) != 0) {
+									update = 1;
+									lstrcpyn(Out->Config.ICQ, temp, ARRAYSIZE(Out->Config.ICQ));
+									ini_modified = 1;
+								}
+								if (update && Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+
+					case IDC_IRC:
+						{
+							if (HIWORD(wParam) == EN_UPDATE) {
+								MY_T_OUTPUT *Out = &Output[Connection_CurSelPos];
+								char temp[sizeof (Out->Config.IRC)];
+								int update = 0;
+								GetWindowText((HWND) lParam, temp, ARRAYSIZE(temp));
+								if (strcmp(temp, Out->Config.IRC) != 0) {
+									update = 1;
+									lstrcpyn(Out->Config.IRC, temp, ARRAYSIZE(Out->Config.IRC));
+									ini_modified = 1;
+								}
+								if (update && Out->Encoder != -1 && Out->Handle != -1) {
+									SHOUTCAST_OUTPUT *Enc = &Encoder[Out->Encoder];
+									if (WaitForSingleObject(Enc_mutex[Out->Encoder], INFINITE) == WAIT_OBJECT_0) {
+										Enc->DisconnectOutput(Out->Handle, 1, 5);
+										ReleaseMutex(Enc_mutex[Out->Encoder]);
+									}
+								}
+							} else if (HIWORD(wParam) == EN_SETFOCUS) {
+								PostMessage((HWND)lParam, EM_SETSEL, 0, (LPARAM)-1);
+							}
+						}
+						break;
+				}
+			}
+			break;
+
+		case WM_CTLCOLORSTATIC:
+			{
+				// this is used to update the header text of the options which need to be checked if there is a config error...
+				int id = GetDlgCtrlID((HWND)lParam);
+				if (id == IDC_ADDRESS_HEADER || id == IDC_PASSWORD_HEADER || id == IDC_NAME_HEADER || id == IDC_ENCODER_HEADER) {
+					int header_id[] = {0, 0, 0, IDC_ADDRESS_HEADER, IDC_PASSWORD_HEADER, IDC_NAME_HEADER, IDC_ENCODER_HEADER, 0};
+					if (lastMode[Connection_CurSelPos] >= 3 && lastMode[Connection_CurSelPos] <= 6 &&
+						header_id[lastMode[Connection_CurSelPos]] == id) {
+						SetTextColor((HDC)wParam, RGB(255,0,0));
+					}
+				}
+			}
+			break;
+
+		case WM_NOTIFY:
+			{
+				LPNMHDR pnmh = (LPNMHDR) lParam;
+				switch (LOWORD(wParam)) {
+					case IDC_TAB:
+						if (pnmh->code == TCN_SELCHANGE) {
+							int i;
+							KillTimer(hDlg, wnd[curtab].id);
+							curtab = SendMessage(pnmh->hwndFrom, TCM_GETCURSEL, 0, 0);
+
+							// send this to update the tab just incase we're showing invalid items
+							InvalidateRect(pnmh->hwndFrom, 0, 0);
+
+							ini_modified = 1;
+							if (wnd[curtab].timer_freq != 0) SetTimer(hDlg, wnd[curtab].id, wnd[curtab].timer_freq, NULL);
+							for (i = 0; i < num_tabwnds; i++) ShowWindow(wnd[i].hWnd, curtab == i ? SW_SHOW : SW_HIDE);
+							for (i = 0; i < num_inwnds; i++) ShowWindow(in_wnd[i].hWnd, i == InputDevice && curtab == 2 ? SW_SHOW : SW_HIDE);
+							for (i = 0; i < num_outwnds; i++) ShowWindow(out_wnd[i].hWnd, i == curouttab && curtab == 1 ? SW_SHOW : SW_HIDE);
+							// update the summary details when going back to it
+							if (curtab == 0) {
+								UpdateSummaryDetails(ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED));
+							} else if(curtab == 1) {
+								// force a refresh on selection change
+								lastMode[Connection_CurSelPos] = -1;
+							}
+						}
+						break;
+
+					case IDC_CONTAB:
+						if (pnmh->code == TCN_SELCHANGE) {
+							int i;
+							KillTimer(hDlg, out_wnd[curouttab].id);
+							curouttab = SendMessage(pnmh->hwndFrom, TCM_GETCURSEL, 0, 0);
+
+							// send this to update the tab just incase we're showing invalid items
+							InvalidateRect(pnmh->hwndFrom, 0, 0);
+
+							ini_modified = 1;
+							if (out_wnd[curouttab].timer_freq != 0) SetTimer(hDlg, out_wnd[curouttab].id, out_wnd[curouttab].timer_freq, NULL);
+							for (i = 0; i < num_outwnds; i++) ShowWindow(out_wnd[i].hWnd, i == curouttab ? SW_SHOW : SW_HIDE);
+							bool enable = (LOBYTE(Output[Connection_CurSelPos].Config.protocol) == 1);
+							EnableWindowDlgItem(out_wnd[1].hWnd, IDC_AIM, enable);
+							EnableWindowDlgItem(out_wnd[1].hWnd, IDC_IRC, enable);
+							EnableWindowDlgItem(out_wnd[1].hWnd, IDC_ICQ, enable);
+						}
+						break;
+
+					case IDC_METALIST:
+						if (pnmh->code == NM_DBLCLK) {
+							LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam;
+							if (lpnmitem->iItem != -1 && WASABI_API_EXPLORERFINDFILE) {
+								wchar_t fn[MAX_PATH]= {0};
+								lstrcpynW(fn, lastFile, MAX_PATH);
+								if (!PathIsURLW(fn)) {
+									// this will attempt to find the path of the parent folder of the file selected
+									// as spc files in a rsn archive can display album art (with the compatibility
+									// wrapper) and so it should cope with such scenarios...
+									wchar_t *filews = fn + lstrlenW(fn) - 1;
+									while(filews && *filews && (*filews != L'.') && (filews != fn)){filews = CharPrevW(fn,filews);}
+									while(filews && *filews && (*filews != L',' && *filews != L':')){filews = CharNextW(filews);}
+									if (filews) *filews = 0;
+
+									filews = wcsstr(fn,L".rsn\\");
+									if(filews) {
+										*(filews+4) = 0;
+									}
+
+									WASABI_API_EXPLORERFINDFILE->AddFile(fn);
+									WASABI_API_EXPLORERFINDFILE->ShowFiles();
+								}
+							}
+						}
+						break;
+
+					case IDC_OUTPUTSTATUS:
+						// on double-click go to the output tab and select the output we used as the currently shown
+						if (pnmh->code == NM_DBLCLK) {
+							LPNMITEMACTIVATE lpnmitem = (LPNMITEMACTIVATE) lParam;
+							if (lpnmitem->iItem != -1 && lpnmitem->iSubItem != 0) {
+								// only change the viewed output mode if it is different, otherwise just switch tab
+								if (Connection_CurSelPos != lpnmitem->iItem) {
+									Connection_CurSelPos = lpnmitem->iItem;
+
+									// force a refresh on selection change
+									lastMode[Connection_CurSelPos] = -1;
+
+									SendDlgItemMessage(wnd[1].hWnd, IDC_OUTPUTLIST, LB_SETCURSEL, Connection_CurSelPos, 0);
+									SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_OUTPUTLIST, LBN_SELCHANGE), (LPARAM) GetDlgItem(wnd[1].hWnd, IDC_OUTPUTLIST));
+									SetFocus(GetDlgItem(wnd[1].hWnd, IDC_OUTPUTLIST));
+								}
+								SetTab(1, hMainDLG, IDC_TAB);
+							}
+						} else if (pnmh->code == LVN_ITEMCHANGED) {
+ 							// on single-click / keyboard change, show some information about the stream such as most, encoder, etc (makes the page useful)
+							LPNMLISTVIEW lpnmitem = (LPNMLISTVIEW) lParam;
+							if (lpnmitem->iItem != -1) {
+								UpdateSummaryDetails(lpnmitem->iItem);
+							}
+						} else if(pnmh->code == LVN_KEYDOWN) {
+							LPNMLVKEYDOWN pnkd = (LPNMLVKEYDOWN) lParam;
+							// toggle state in the output list via 'space'
+							if (pnkd->wVKey == VK_SPACE) {
+								int item = ListView_GetNextItem(GetDlgItem(wnd[0].hWnd, IDC_OUTPUTSTATUS), -1, LVNI_SELECTED);
+								if (lastEnable[item]) {
+									int oldCurSelPos = Connection_CurSelPos;
+									Connection_CurSelPos = item;
+									SendMessage(wnd[1].hWnd, WM_COMMAND, MAKEWPARAM(IDC_CONNECT, BN_CLICKED), (LPARAM)GetDlgItem(wnd[1].hWnd, IDC_CONNECT));
+									Connection_CurSelPos = oldCurSelPos;
+								}
+							}
+						}
+					break;
+				}
+			}
+			break;
+
+		case WM_HSCROLL:
+			{
+				int curpos = SendMessage((HWND) lParam, TBM_GETPOS, 0, 0);
+				if (GetDlgItem(hDlg, IDC_MUSSLIDER) == (HWND) lParam) {
+					MusVol = curpos;
+					if (InputDevice == 1 && !FadeOut) setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, MusVol * 10);
+					wchar_t tmp[256] = {0};
+					if (curpos != 0) {
+						wchar_t temp[32] = {0};
+						int volume = (int) (20 * log10(curpos * 3276.));
+						StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
+					} else {
+						LocalisedString(IDS_INF_DB, tmp, 256);
+					}
+					SetDlgItemTextW(hDlg, IDC_MUSLEV1_TEXT, tmp);
+				} else if (GetDlgItem(hDlg, IDC_MUS2SLIDER) == (HWND) lParam) {
+					Mus2Vol = curpos;
+					if (InputDevice == 1 && FadeOut) setlev(MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT, Mus2Vol * 10);
+					wchar_t tmp[256] = {0};
+					if (curpos != 0) {
+						wchar_t temp[32] = {0};
+						int volume = (int) (20 * log10(curpos * 3276.));
+						StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
+					} else {
+						LocalisedString(IDS_INF_DB, tmp, 256);
+					}
+					SetDlgItemTextW(hDlg, IDC_MUSLEV2_TEXT, tmp);
+				} else if (GetDlgItem(hDlg, IDC_MICSLIDER) == (HWND) lParam) {
+					MicVol = curpos;
+					int micsrc = Input_Device_ID  >= 1 ? MIXERLINE_COMPONENTTYPE_SRC_LINE : MIXERLINE_COMPONENTTYPE_SRC_MICROPHONE;
+					// changed this so it will only change the capture device level if PTT is pressed
+					if (InputDevice == 1 && FadeOut) setlev(micsrc, MicVol *10);
+					wchar_t tmp[256] = {0};
+					if (curpos != 0) {
+						wchar_t temp[32] = {0};
+						int volume = (int) (20 * log10(curpos * 3276.));
+						StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_DB, temp, 32), volume - 90);
+					} else {
+						LocalisedString(IDS_INF_DB, tmp, 256);
+					}
+					SetDlgItemTextW(hDlg, IDC_MICLEV_TEXT, tmp);
+				} else if (GetDlgItem(hDlg, IDC_FADESLIDER) == (HWND) lParam) {
+					FadeTime = curpos;
+					wchar_t tmp[256] = {0}, temp[32] = {0};
+					StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_MS, temp, 32), curpos * 100);
+					SetDlgItemTextW(hDlg, IDC_FADETIME_TEXT, tmp);
+				} else if (GetDlgItem(hDlg, IDC_MICFADESLIDER) == (HWND) lParam) {
+					MicFadeTime = curpos;
+					wchar_t tmp[256] = {0}, temp[32] = {0};
+					StringCchPrintfW(tmp, ARRAYSIZE(tmp), LocalisedString(IDS_X_MS, temp, 32), curpos * 100);
+					SetDlgItemTextW(hDlg, IDC_MICFADETIME_TEXT, tmp);
+				}
+			}
+			break;
+	}
+
+	if (FALSE != DirectMouseWheel_ProcessDialogMessage(hDlg, uMsg, wParam, lParam)) {
+		return TRUE;
+	}
+	return 0;
+}
+
+LRESULT CALLBACK CallWndProc(int nCode, WPARAM wParam, LPARAM lParam) {
+	if (nCode == HC_ACTION) {
+	LPCWPSTRUCT msg = (LPCWPSTRUCT)lParam;
+		// catch the new file playing message and update the cached metadata
+		if (msg->message == WM_WA_IPC) {
+			if (msg->lParam == IPC_PLAYING_FILEW) {
+			DWORD diff = GetTickCount();
+				was_paused = 0;
+				play_duration = 0;
+				play_diff = diff;
+				was_playing = 1;
+				if (wcsnicmp(lastFile, (wchar_t*)msg->wParam, MAX_PATH)) {
+					PostMessage(hMainDLG, WM_USER, 0, nowPlayingID);
+				}
+			}
+		}
+	}
+	return (nowPlayingHook ? CallNextHookEx(nowPlayingHook, nCode, wParam, lParam) : 0);
+}
+
+LRESULT CALLBACK GetMsgProc(int nCode, WPARAM wParam, LPARAM lParam) {
+	if (nCode == HC_ACTION) {
+	LPMSG msg = (LPMSG)lParam;
+		// catch the new file playing message and update the cached metadata
+		if (msg->message == WM_WA_IPC) {
+			if (msg->lParam == IPC_CB_MISC && msg->wParam == IPC_CB_MISC_STATUS) {
+				isplaying = SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_ISPLAYING);
+				ProcessPlayingStatusUpdate();
+			} else if (msg->lParam == IPC_UPDTITLE) {
+				// attempt to keep a track of other title updates
+				// e.g. the re-streaming an already playing stream
+				wchar_t currentFile[MAX_PATH] = {0};
+				wchar_t *file=(wchar_t*)SendMessage(module.hwndParent, WM_WA_IPC,
+													SendMessage(module.hwndParent, WM_WA_IPC, 0, IPC_GETLISTPOS),
+													IPC_GETPLAYLISTFILEW);
+				wcsncpy(currentFile, (file ? file : L""), MAX_PATH);
+				if (!wcsnicmp(currentFile, lastFile, MAX_PATH)) {
+					// do a 1 second delay since it's likely Winamp will send
+					// this a few times so we reset the timer everytime so we
+					// only do a proper title update once everything settles
+					KillTimer(hMainDLG, 1337);
+					SetTimer(hMainDLG, 1337, 1000, NULL);
+				}
+			}
+		}
+	}
+	return (nowPlayingHook2 ? CallNextHookEx(nowPlayingHook2, nCode, wParam, lParam) : 0);
+}
+
+VOID CALLBACK TimerProc2(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
+{
+	KillTimer(hwnd, idEvent);
+	SetForegroundWindow(hMainDLG);
+}
+
+void doConfig(HWND hwndParent) {
+	if (WASABI_API_SVC) {
+		if (!IsWindow(hMainDLG)) {
+			if (AGAVE_API_CONFIG) {
+				if (AGAVE_API_CONFIG->GetUnsigned(playbackConfigGroupGUID, L"bits", 16) > 16) {
+					wchar_t title[128] = {0}, message[512] = {0};
+					StringCchPrintfW(title, ARRAYSIZE(title), LocalisedString(IDS_PLUGIN_NAME, NULL, 0), APP_VersionW);
+					StringCchPrintfW(message, ARRAYSIZE(message), LocalisedString(IDS_24BIT_MODE_DETECTED, NULL, 0));
+					MessageBoxW(module.hwndParent, message, title, MB_ICONWARNING);
+					return;
+				}
+			}
+
+			// using this to lessen issues with new track events with higher bitrates leading to failures
+			if (!nowPlayingHook) {
+				nowPlayingHook = SetWindowsHookExW(WH_CALLWNDPROC, CallWndProc, instance, GetCurrentThreadId());
+			}
+			if (!nowPlayingHook2) {
+				nowPlayingHook2 = SetWindowsHookExW(WH_GETMESSAGE, GetMsgProc, instance, GetCurrentThreadId());
+			}
+			if (nowPlayingID == -1) {
+				nowPlayingID = SendMessage(hwndParent, WM_WA_IPC, (WPARAM)&"dsp_sc_np", IPC_REGISTER_WINAMP_IPCMESSAGE);
+			}
+
+			HWND hwnd = LocalisedCreateDialog(instance, IDD_DIALOG, hwndParent, DialogFunc, IDD_DIALOG);
+			SetWindowPos(hwnd, HWND_TOP, mainrect.left, mainrect.top, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOSENDCHANGING);
+			SetTimer(hMainDLG, 999, 1, TimerProc2);
+		} else {
+			if (IsIconic(hMainDLG)) {
+				DialogFunc(hMainDLG, WM_SIZE, SIZE_RESTORED, 0);
+				ShowWindow(hMainDLG, SW_RESTORE);
+				ShowWindow(hMainDLG, SW_SHOW);
+				SetActiveWindow(hMainDLG);
+			}
+			SetForegroundWindow(hMainDLG);
+		}
+	}
+}
+
+VOID CALLBACK TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
+{
+	KillTimer(hwnd, idEvent);
+	doConfig(hwnd);
+}
+
+void Config(winampDSPModule *this_mod) {
+	// this will hold back opening the config dialog on loading until Winamp is in a ready state
+	// this resolves a partial fail to load i've often been seeing (plus from some users afaict)
+	SetTimer(this_mod->hwndParent, 999, 1, TimerProc);
+}
+
+int Init(winampDSPModule *this_mod) {
+	instance = this_mod->hDllInstance;
+
+	// this will hold back opening the config dialog on loading until Winamp is in a ready state
+	// this resolves a partial fail to load i've often been seeing (plus from some users afaict)
+	SetTimer(this_mod->hwndParent, 999, 1, TimerProc);
+	return 1;
+}
+
+int ModifySamples(winampDSPModule *this_mod, short int *samples, int numsamples, int bps, int nch, int srate) {
+	int numorig = numsamples;
+
+	//connect but only if we're meant to be i.e. there's at least 1 active output
+	if (InputDevice == 0) {
+		if (WaitForSingleObject(cf_mutex, INFINITE) == WAIT_OBJECT_0) {
+			// CT> Resample into the desired srate and nch if needed
+			// TODO check out the handling of this for 24-bit output
+			short cf_buf[256 * 1024] = {0};
+			if (srate != InputConfig.srate || nch != InputConfig.nch) {
+				char *s = (char *) samples;
+				int ns = numsamples * 2;
+				if (InputConfig.nch == 1) {
+					if (nch != 1 || bps != 16 || srate != (int) InputConfig.srate) {
+						if (nch == 2) {
+							int x;
+							int nns = MulDiv(numsamples, InputConfig.srate, srate);
+							int r = 0;
+							int dr = MulDiv(numsamples, 1 << 12, nns);
+							if (bps == 16)
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x] = samples[(r >> 12)*2] / 2 + samples[(r >> 12)*2 + 1] / 2;
+									r += dr;
+								}
+							}
+							else
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x] = ((((char *) samples)[(r >> 12)*2]^128) << 8) / 2 +
+										((((char *) samples)[(r >> 12)*2 + 1]^128) << 8) / 2;
+									r += dr;
+								}
+							}
+							ns = nns * 2;
+						} else {
+							int x;
+							int nns = MulDiv(numsamples, InputConfig.srate, srate);
+							int r = 0;
+							int dr = MulDiv(numsamples, 1 << 12, nns);
+							if (bps == 16)
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x] = samples[r >> 12];
+									r += dr;
+								}
+							}
+							else
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x] = (((char *) samples)[r >> 12]^128) << 8;
+									r += dr;
+								}
+							}
+							ns = nns * 2;
+						}
+						s = (char *) cf_buf;
+					}
+				} else {
+					if (nch != 2 || bps != 16 || srate != (int) InputConfig.srate) {
+						if (nch == 2) { 
+							int x;
+							int nns = MulDiv(numsamples, InputConfig.srate, srate);
+							int r = 0;
+							int dr = MulDiv(numsamples, 1 << 12, nns);
+							if (bps == 16)
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x * 2] = samples[(r >> 12)*2];
+									cf_buf[x * 2 + 1] = samples[(r >> 12)*2 + 1];
+									r += dr;
+								}
+							}
+							else
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x * 2] = (((char *) samples)[(r >> 12)*2]^128) << 8;
+									cf_buf[x * 2 + 1] = (((char *) samples)[(r >> 12)*2 + 1]^128) << 8;
+									r += dr;
+								}
+								ns = nns * 4;
+							}
+						} else {
+							int x;
+							int nns = MulDiv(numsamples, InputConfig.srate, srate);
+							int r = 0;
+							int dr = MulDiv(numsamples, 1 << 12, nns);
+							if (bps == 16)
+							{
+								for (x = 0; x < nns; x++) {
+									cf_buf[x * 2] = cf_buf[x * 2 + 1] = samples[r >> 12];
+									r += dr;
+								}
+							}
+							else
+							{
+								for (x = 0; x < nns; x++)
+								{
+									cf_buf[x * 2] = cf_buf[x * 2 + 1] = (((char *) samples)[r >> 12]^128) << 8;
+									r += dr;
+								}
+								ns = nns * 4;
+							}
+						}
+
+						s = (char *) cf_buf;
+					}
+					else ns *= 2;
+				}
+				samples = (short *) s;
+				numsamples = ns / (InputConfig.nch * 2);
+			}
+
+			if (!VU.update) {
+				for (int j = 0; j < numsamples; j++) {
+					if (VU.vu_l < samples[j]) VU.vu_l = samples[j];
+					if (InputConfig.nch == 2) {
+						if (VU.vu_r < samples[j + 1]) VU.vu_r = samples[j + 1];
+						j++;
+					}
+				}
+				if (InputConfig.nch == 1) VU.vu_r = VU.vu_l;
+				VU.update = 1;
+			}
+			Crossfader->put(samples, numsamples);
+			ReleaseMutex(cf_mutex);
+		}
+	}
+	return numorig;
+}
+
+
+void Quit(winampDSPModule *this_mod) {
+	doQuit();
+}
\ No newline at end of file