winamp/Src/Plugins/DSP/dsp_sc/main.cpp

// 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();
}