winamp/Src/Plugins/Encoder/enc_wma/config.cpp

#include <windows.h>

// LGIVEN Mods 4-10-05
#include "main.h"
#include <wmsdk.h>
#include "../nu/AutoWide.h"
#include "../nu/ns_wc.h"
#include "../Agave/Language/api_language.h"
#include <MMSystem.h>
#include <assert.h>

#define MAX_PASSES 1 // limited to 1pass encoding until we work out some code for 2pass encoding

// LGIVEN Mods 4-10-05
void readconfig(char *configfile, configtype *cfg)
{
	cfg->config_bitrate = 0;
	cfg->config_bitsSample = 0;
	cfg->config_nch = 0;
	cfg->config_samplesSec = 0;
	cfg->config_encoder = 0;
	cfg->config_vbr = 0;
	cfg->config_passes = 1;
	if (configfile)
	{
		GetPrivateProfileStructA("audio_wma", "conf", cfg, sizeof(configtype), configfile);
	}
}

void writeconfig(char *configfile, configtype *cfg)
{
	if (configfile)
	{
		WritePrivateProfileStructA("audio_wma", "conf", cfg, sizeof(configtype), configfile);
	}
}

// New global table for channels,samplerates and bitrates
static EncoderType* encs = NULL;     // Pointer to the TABLE with all config data
// Globals store current selections from Config Dialog
// Number of encoders
static int encNumbs = 0;    // Total number of encoders installed WMA

// New routine to read all config info from WMA encoder and load tables

static BOOL loadWMATables()
{
	IWMProfileManager *profileManager;
	IWMProfileManager2 *profileManager2;
	IWMCodecInfo3 *codecInfo;
	WAVEFORMATEX *pwave;
	HRESULT hr;
	int legalFormats = 0;

	WMCreateProfileManager(&profileManager);
	profileManager->QueryInterface(&profileManager2);
	profileManager2->SetSystemProfileVersion(WMT_VER_9_0);

	profileManager->QueryInterface(&codecInfo);
	// Get the number of AUDIO Codecs
	DWORD numCodecs = 0;
	codecInfo->GetCodecInfoCount(WMMEDIATYPE_Audio, &numCodecs);
	// If there are no encoders, just return
	if (numCodecs == 0)
	{
		return false;
	}
	// Allocate structs for codecs and zero them all
	encs = (EncoderType *) calloc(numCodecs * 4, sizeof(struct EncoderType));
	if (encs != NULL)
	{
		encNumbs = numCodecs * 4;
	}
	else
	{
		wchar_t titleStr[32] = {0};
		MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_ALLOCATE_MEM),
				    WASABI_API_LNGSTRINGW_BUF(IDS_WMA_ENCODER_ERROR,titleStr,32), MB_OK);
		return false;
	}
	// Now cycle through the codecs
	EncoderType* encp = encs;
	for (BOOL isVBR = 0;isVBR != 2;isVBR++)
		for (DWORD numPasses = 1;numPasses <= MAX_PASSES;numPasses++)
			for (DWORD i = 0;i != numCodecs;i++)
			{
				wchar_t codecName[5000] = {0};
				DWORD codecNameSize = 5000;

				codecInfo->SetCodecEnumerationSetting(WMMEDIATYPE_Audio, i, g_wszVBREnabled, WMT_TYPE_BOOL, (BYTE *)&isVBR, sizeof(BOOL));
				codecInfo->SetCodecEnumerationSetting(WMMEDIATYPE_Audio, i, g_wszNumPasses, WMT_TYPE_DWORD, (BYTE *)&numPasses, sizeof(DWORD));
				codecInfo->GetCodecName(WMMEDIATYPE_Audio, i, codecName, &codecNameSize);
				// Get the number of formats for this codec
				DWORD formatCount = 0;
				hr = codecInfo->GetCodecFormatCount( WMMEDIATYPE_Audio, i, &formatCount );
				if (FAILED(hr))
				{
					continue;
				}
				else if (formatCount == 0)
				{
					continue;
				}
				else
				{
					// Fill the EncoderType struct and allocate structs for format info
					// First allocate the space for all the formatType structs
					encp->formats = (formatType *) malloc(formatCount * sizeof(struct formatType));
					if (encp->formats == NULL)
					{
						wchar_t titleStr[32] = {0};
						MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_ALLOCATE_MEM),
								    WASABI_API_LNGSTRINGW_BUF(IDS_WMA_ENCODER_ERROR,titleStr,32), MB_OK);
						return false;
					}
					// Now fill the EncoderType struct with name and info
					encp->encoderName = _wcsdup(codecName);
					encp->numFormats = formatCount;
					encp->offset = i;
					encp->vbr = isVBR;
					encp->numPasses = numPasses;
				}
				// Now cycle through the formats for this codec
				legalFormats = 0;
				formatType *fmts = encp->formats;
				for (DWORD f = 0;f != formatCount;f++)
				{
					wchar_t fDesc[5000] = {0};
					DWORD size = 5000;
					// Get the config info for this encoding format in string format
					IWMStreamConfig *streamConfig;
					codecInfo->GetCodecFormatDesc(WMMEDIATYPE_Audio, i, f, &streamConfig, fDesc, &size);
					// Now get the config info
					IWMMediaProps *props;
					streamConfig->QueryInterface(&props);
					// Get the bitrate
					//DWORD bitRate;
					//streamConfig->GetBitrate(&bitRate);
					// Get the Media Encoder type
					DWORD mediaTypeSize;
					props->GetMediaType(0, &mediaTypeSize);
					WM_MEDIA_TYPE *mediaType = (WM_MEDIA_TYPE *)new char[mediaTypeSize];
					props->GetMediaType(mediaType, &mediaTypeSize);
					// Go get the WAVEFORMATEX Struct from the
					if (mediaType->cbFormat >= sizeof(WAVEFORMATEX))
					{
						pwave = (WAVEFORMATEX*)mediaType->pbFormat;
						if (pwave != NULL)
						{
							// Check to see if this is an A/V codec format
							// If so, do not save it

							/*
							if ((pwave->nAvgBytesPerSec / pwave->nBlockAlign) ==
							    ((pwave->nAvgBytesPerSec >= 3995) ? 5 : 3))
							{
								delete(mediaType);
								props->Release();
								streamConfig->Release();
								continue;
							}*/

							// old way of checking
							if ((wcsstr(fDesc, L"A/V")) != NULL)
							{
								delete[] (mediaType);
								props->Release();
								streamConfig->Release();
								continue;
							}
							// Load the format name
							fmts->formatName = _wcsdup(fDesc);
							// Load all the format values and the offset
							if ((pwave->nAvgBytesPerSec & 0x7FFFFF00) == 0x7FFFFF00)
							{
								fmts->bitrate = (pwave->nAvgBytesPerSec & 0x000000FF);
								fmts->vbr = 1;
							}
							else
							{
								fmts->bitrate = (pwave->nAvgBytesPerSec * 8);
								fmts->vbr = 0;
							}
							fmts->bitsSample = pwave->wBitsPerSample;
							fmts->nChannels = pwave->nChannels;
							fmts->samplesSec = pwave->nSamplesPerSec;
							fmts->offset = f;
						}
						else
						{
							wchar_t titleStr[32] = {0};
							MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_GET_STRUCTURE),
									    WASABI_API_LNGSTRINGW_BUF(IDS_WMA_ENCODER_ERROR,titleStr,32), MB_OK);
							return false;
						}
					}
					else
					{
						wchar_t titleStr[32] = {0};
						MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_GET_ENCODER4_INFO),
									WASABI_API_LNGSTRINGW_BUF(IDS_WMA_ENCODER_ERROR,titleStr,32), MB_OK);
						return false;
					}
					// Set the media type value in the EncoderType struct on first legal format
					if (f == 0)
					{
						encp->mediaType = mediaType->subtype;
					}
					// Now point to the next table block and inc the legal formats count
					fmts++;
					legalFormats++;
					// And release the props and streams structs
					delete[] (mediaType);
					props->Release();
					streamConfig->Release();

				}
				// If there are no legal formats for this codec then skip it
				if (legalFormats == 0)
				{
					delete[] encp->encoderName;
					encp->encoderName = NULL;
					encp->numFormats = legalFormats;
					encp->offset = 0;
				}
				// Else load number of legal formats and save it
				else
				{
					encp->numFormats = legalFormats;
					encp++;
				}
			}
	return true;
}

static int FindFormatNumber(formatType *formats, int numFormats, configtype *cfg)
{
	for (int i = 0;i < numFormats;i++, formats++)
	{
		if (formats->bitrate == cfg->config_bitrate
		        && formats->bitsSample == cfg->config_bitsSample
		        && formats->nChannels == cfg->config_nch
		        && formats->samplesSec == cfg->config_samplesSec)
			return formats->offset;
	}

	return 0;
}

static VOID dumpProfile(char *configfile, BOOL isVBR, DWORD numPasses, int encNumb, int fmtNumb)
{
	// Create a Profile and dump it
	IWMProfileManager *pmgr = NULL;
	IWMProfile *prof = NULL;
	IWMStreamConfig *sconf = NULL;
	IWMCodecInfo3 *cinfo = NULL;
	DWORD ssize;
	wchar_t errorTitle[128] = {0};
	WASABI_API_LNGSTRINGW_BUF(IDS_WMA_CONFIG_FILE_ERROR,errorTitle,128);

	HRESULT hr = WMCreateProfileManager(&pmgr);
	if (!FAILED(hr))
	{
		hr = pmgr->CreateEmptyProfile(WMT_VER_9_0, &prof);
		if (!FAILED(hr))
		{
			hr = pmgr->QueryInterface(&cinfo);
			if (!FAILED(hr))
			{
				cinfo->SetCodecEnumerationSetting(WMMEDIATYPE_Audio, encNumb, g_wszVBREnabled, WMT_TYPE_BOOL, (BYTE *)&isVBR, sizeof(BOOL));
				cinfo->SetCodecEnumerationSetting(WMMEDIATYPE_Audio, encNumb, g_wszNumPasses, WMT_TYPE_DWORD, (BYTE *)&numPasses, sizeof(DWORD));
				cinfo->GetCodecFormat(WMMEDIATYPE_Audio, encNumb, fmtNumb, &sconf);
				sconf->SetConnectionName(L"enc_wma");
				sconf->SetStreamName(L"enc_wma");
				sconf->SetStreamNumber(1);
				hr = prof->AddStream(sconf);
				if (!FAILED(hr))
				{
					hr = pmgr->SaveProfile(prof, NULL, &ssize);
					if (!FAILED(hr))
					{
						WCHAR* pstring = new WCHAR[ssize];
						if (pstring != NULL)
						{
							hr = pmgr->SaveProfile(prof, pstring, &ssize);
							if (!FAILED(hr))
							{
								wchar_t cstring[4000] = {0};
								wcsncpy(cstring, pstring, 4000 - 1);
								WritePrivateProfileStructW(L"audio_wma", L"profile", cstring, sizeof(cstring) / sizeof(*cstring), AutoWide(configfile));
							}
							else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_SAVE_PROFILE_READ_ERROR), errorTitle, MB_OK); }
						}
						else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_MEM_ALLOCATION_ERROR), errorTitle, MB_OK); }
					}
					else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_PROFILE_SAVE_SIZE_ERROR), errorTitle, MB_OK); }
				}
				else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_READ_AUDIO_STREAM), errorTitle, MB_OK); }
			}
			else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_GET_CODEC_INFO), errorTitle, MB_OK); }
		}
		else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_CREATE_A_PROFILE), errorTitle, MB_OK); }
	}
	else{ MessageBoxW(NULL, WASABI_API_LNGSTRINGW(IDS_CANNOT_CREATE_PROFILE_MANAGER), errorTitle, MB_OK); }
	pmgr->Release();
	prof->Release();
	sconf->Release();
	cinfo->Release();
}

static bool Has(HWND hwndDlg, int item, int data)
{
	int numChoices = SendDlgItemMessage(hwndDlg, item, CB_GETCOUNT, 0, 0);
	for (int i = 0;i < numChoices;i++)
	{
		if (SendDlgItemMessage(hwndDlg, item, CB_GETITEMDATA, i, 0) == data)
			return true;
	}
	return false;
}

static int EncodeSampleFormat(int bps, int numChannels, int sampleRate)
{
	// 20 bits sampleRate
	assert((sampleRate & 0xFFFFF) == sampleRate);
	// 6 bits numChannels
	assert((numChannels & 0x3F) == numChannels);
	// 6 bits bps
	assert((bps & 0x3F) == bps);

	return (sampleRate << 12) | (numChannels << 6) | (bps);
}

static void DecodeSampleFormat(int data, int &bps, int &numChannels, int &sampleRate)
{
	bps = data & 0x3F;
	data >>= 6;
	numChannels = data & 0x3F;
	data >>= 6;
	sampleRate = data;
}

static int EncodeVBR(BOOL isVBR, DWORD numPasses)
{
	// 1 bits VBR
	assert((isVBR & 0x1) == isVBR);
	// 15 bits numPasses
	assert((numPasses & 0x7FFF) == numPasses);

	return (isVBR << 15) | (numPasses);
}

static void DecodeVBR(int data, BOOL &isVBR, DWORD &numPasses)
{
	numPasses = data & 0x7FFF;
	data >>= 15;
	isVBR = data & 0x1;
}

static void AutoSelect(HWND hwndDlg, int dlgItem)
{
	if (SendDlgItemMessage(hwndDlg, dlgItem, CB_GETCURSEL, 0, 0) == CB_ERR)
		SendDlgItemMessage(hwndDlg, dlgItem, CB_SETCURSEL, 0, 0);
}

static EncoderType *FindEncoder(int encoderNumber, BOOL isVBR, DWORD numPasses)
{
	EncoderType* enc = encs;
	for (int i = 0;i < encNumbs;i++, enc++)
	{
		if (enc->encoderName == NULL)
			return 0; //WTF?
		if (enc->offset == encoderNumber && enc->vbr == isVBR && enc->numPasses == numPasses)
			return enc;
	}
	return 0; //WTF?
}

#define MASK_ENCODER 0x1
#define MASK_VBR 0x2
#define MASK_SAMPLE_FORMAT 0x4
#define MASK_BITRATE 0x8
#define MASK_ALL 0xF

static void ResetConfig(HWND hwndDlg, EncoderType *encs, configtype *cfg, int mask)
{
	wchar_t buf1[100] = {0};
	EncoderType* enc = encs;

	if (mask & MASK_ENCODER)	SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_RESETCONTENT, 0, 0);
	if (mask & MASK_SAMPLE_FORMAT)	SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_RESETCONTENT, 0, 0);
	if (mask & MASK_BITRATE)	SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_RESETCONTENT, 0, 0);
	if (mask & MASK_VBR)	SendDlgItemMessage(hwndDlg, IDC_VBR, CB_RESETCONTENT, 0, 0);

	// reset encoders
	int thisVBR = EncodeVBR(cfg->config_vbr, cfg->config_passes);
	for (int i = 0;i < encNumbs;i++, enc++)
	{
		if (enc->encoderName == NULL)
			break;
		else if ((mask & MASK_ENCODER) && !Has(hwndDlg, IDC_ENCODER, enc->offset))
		{
			int newpos = SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_ADDSTRING, 0, (LPARAM)enc->encoderName);
			SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_SETITEMDATA, newpos, enc->offset);

			if (cfg->config_encoder == enc->offset)
			{
				SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_SETCURSEL, newpos, 0);
			}
		}
		int data = EncodeVBR(enc->vbr, enc->numPasses);
		if ((mask & MASK_VBR) && cfg->config_encoder == enc->offset && !Has(hwndDlg, IDC_VBR, data))
		{
			int newpos = CB_ERR;
			if (enc->vbr == FALSE && enc->numPasses == 1)
				newpos = SendDlgItemMessageW(hwndDlg, IDC_VBR, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_CBR));
			else if (enc->vbr == FALSE && enc->numPasses == 2)
				newpos = SendDlgItemMessageW(hwndDlg, IDC_VBR, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_2_PASS_CBR));
			else if (enc->vbr == TRUE && enc->numPasses == 1)
				newpos = SendDlgItemMessageW(hwndDlg, IDC_VBR, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_VBR));
			else if (enc->vbr == TRUE && enc->numPasses == 2)
				newpos = SendDlgItemMessageW(hwndDlg, IDC_VBR, CB_ADDSTRING, 0, (LPARAM)WASABI_API_LNGSTRINGW(IDS_ABR));

			SendDlgItemMessage(hwndDlg, IDC_VBR, CB_SETITEMDATA, newpos, data);

			if (thisVBR == data)
				SendDlgItemMessage(hwndDlg, IDC_VBR, CB_SETCURSEL, newpos, 0);
		}
	}

	AutoSelect(hwndDlg, IDC_ENCODER);
	AutoSelect(hwndDlg, IDC_VBR);
	int pos = SendDlgItemMessage(hwndDlg, IDC_VBR, CB_GETCURSEL, 0, 0);
	int data = SendDlgItemMessage(hwndDlg, IDC_VBR, CB_GETITEMDATA, pos, 0);
	DecodeVBR(data, cfg->config_vbr, cfg->config_passes);

	pos = SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_GETCURSEL, 0, 0);
	data = SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_GETITEMDATA, pos, 0);
	cfg->config_encoder = data;

	// Now set up for dialog fill
	enc = FindEncoder(cfg->config_encoder, cfg->config_vbr, cfg->config_passes);

	// Fill the current values
	formatType *fmt = enc->formats;

	int thisSampleFormat = EncodeSampleFormat(cfg->config_bitsSample, cfg->config_nch, cfg->config_samplesSec);
	for (int i = 0;i < enc->numFormats;i++, fmt++)
	{
		int data = EncodeSampleFormat(fmt->bitsSample, fmt->nChannels, fmt->samplesSec);
		// Add channels to list
		if ((mask & MASK_SAMPLE_FORMAT) && !Has(hwndDlg, IDC_SAMPLE_FORMAT, data))
		{
			if (fmt->nChannels == 1)
				wsprintfW(buf1, WASABI_API_LNGSTRINGW(IDS_MONO_INFO), fmt->bitsSample, fmt->samplesSec);
			else if (fmt->nChannels == 2)
				wsprintfW(buf1, WASABI_API_LNGSTRINGW(IDS_STEREO_INFO), fmt->bitsSample, fmt->samplesSec);
			else
				wsprintfW(buf1, WASABI_API_LNGSTRINGW(IDS_CHANNELS_INFO), fmt->bitsSample, fmt->nChannels, fmt->samplesSec);

			int newpos;
			if (fmt->bitsSample)
				newpos = SendDlgItemMessageW(hwndDlg, IDC_SAMPLE_FORMAT, CB_ADDSTRING, 0, (LPARAM)buf1);
			else
				newpos = SendDlgItemMessageW(hwndDlg, IDC_SAMPLE_FORMAT, CB_ADDSTRING, 0, (LPARAM)buf1 + 8); // skip "0 bits, "

			SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_SETITEMDATA, newpos, data);
			// Now set current select for number of channels sample
			if (thisSampleFormat == data)
				SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_SETCURSEL, newpos, 0);
		}
	}

	if (SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETCURSEL, 0, 0) == CB_ERR)
	{
		int num = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETCOUNT, 0, 0);
		int defaultSampleFormat = EncodeSampleFormat(16, 2, 44100);
		for (int i = 0;i < num;i++)
		{
			int data = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETITEMDATA, i, 0);
			if (data == defaultSampleFormat)
				SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_SETCURSEL, i, 0);
		}
	}

	AutoSelect(hwndDlg, IDC_SAMPLE_FORMAT);
	pos = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETCURSEL, 0, 0);
	data = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETITEMDATA, pos, 0);
	DecodeSampleFormat(data, cfg->config_bitsSample, cfg->config_nch, cfg->config_samplesSec);

	thisSampleFormat = EncodeSampleFormat(cfg->config_bitsSample, cfg->config_nch, cfg->config_samplesSec);

	// Next Show the Bitrates
	fmt = enc->formats;
	for (int i = 0;i < enc->numFormats;i++, fmt++)
	{
		int data = EncodeSampleFormat(fmt->bitsSample, fmt->nChannels, fmt->samplesSec);
		if (thisSampleFormat == data)
		{
			if ((mask & MASK_BITRATE) && !Has(hwndDlg, IDC_BRATE, fmt->bitrate))
			{
				if (fmt->vbr)
					SetDlgItemTextW(hwndDlg, IDC_STATIC_BITRATE, WASABI_API_LNGSTRINGW(IDS_QUALITY));
				else
					SetDlgItemTextW(hwndDlg, IDC_STATIC_BITRATE, WASABI_API_LNGSTRINGW(IDS_BITRATE));

				wsprintfW(buf1, L"%d", fmt->bitrate);
				int newpos = SendDlgItemMessageW(hwndDlg, IDC_BRATE, CB_ADDSTRING, 0, (LPARAM)buf1);
				SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_SETITEMDATA, newpos, fmt->bitrate);
				// Set the current bit rate
				if (cfg->config_bitrate == fmt->bitrate)
				{
					SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_SETCURSEL, newpos, 0);
				}
			}
		}
	}

	if (SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETCURSEL, 0, 0) == CB_ERR)
	{
		int num = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETCOUNT, 0, 0);

		for (int i = 0;i < num;i++)
		{
			int data = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETITEMDATA, i, 0);
			if (data == 50 || (data / 1000 == 128))
				SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_SETCURSEL, i, 0);
		}
	}

	AutoSelect(hwndDlg, IDC_BRATE);

	pos = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETCURSEL, 0, 0);
	data = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETITEMDATA, pos, 0);
	cfg->config_bitrate = data;
}

BOOL CALLBACK ConfigProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	configwndrec *wc = NULL;
	if (uMsg == WM_INITDIALOG)
	{
		// LGIVEN Mod 4-10-05
#if defined(_WIN64)
		SetWindowLong(hwndDlg, GWLP_USERDATA, lParam);
#else
		SetWindowLong(hwndDlg, GWL_USERDATA, lParam);
#endif
		if (lParam)
		{
			// Get the saved params
			wc = (configwndrec*)lParam;

			loadWMATables();
			ResetConfig(hwndDlg, encs , &wc->cfg, MASK_ALL);
		}
		return 1;
	}
	if (uMsg == WM_DESTROY)
	{
#if defined(_WIN64)
		wc = (configwndrec*)SetWindowLong(hwndDlg, GWLP_USERDATA, 0);
#else
		wc = (configwndrec*)SetWindowLong(hwndDlg, GWL_USERDATA, 0);
#endif
		if (wc)
		{
			EncoderType *encoder=FindEncoder(wc->cfg.config_encoder,wc->cfg.config_vbr, wc->cfg.config_passes);
			int formatNumber = FindFormatNumber(encoder->formats, encoder->numFormats, &wc->cfg);
			// Dump the profile in WMA format
			dumpProfile(wc->configfile, wc->cfg.config_vbr, wc->cfg.config_passes, wc->cfg.config_encoder, formatNumber);
			// Write it to config file
			writeconfig(wc->configfile, &wc->cfg);
			free(wc->configfile);
			free(wc);
		}
		return 0;
	}
	if (uMsg == WM_COMMAND)
	{
		switch (LOWORD(wParam))
		{
		case IDC_VBR:
			if ((HIWORD(wParam) == CBN_SELCHANGE))
			{
#if defined(_WIN64)
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWLP_USERDATA);
#else
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
				int pos = SendDlgItemMessage(hwndDlg, IDC_VBR, CB_GETCURSEL, 0, 0);
				int data = SendDlgItemMessage(hwndDlg, IDC_VBR, CB_GETITEMDATA, pos, 0);
				DecodeVBR(data, wc->cfg.config_vbr, wc->cfg.config_passes);
				ResetConfig(hwndDlg, encs, &wc->cfg, MASK_BITRATE | MASK_SAMPLE_FORMAT);
			}
			break;

		case IDC_SAMPLE_FORMAT:
			if ((HIWORD(wParam) == CBN_SELCHANGE))
			{
#if defined(_WIN64)
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWLP_USERDATA);
#else
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
				int pos = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETCURSEL, 0, 0);
				int data = SendDlgItemMessage(hwndDlg, IDC_SAMPLE_FORMAT, CB_GETITEMDATA, pos, 0);
				DecodeSampleFormat(data, wc->cfg.config_bitsSample, wc->cfg.config_nch, wc->cfg.config_samplesSec);
				ResetConfig(hwndDlg, encs, &wc->cfg, MASK_BITRATE);
			}
			break;

		case IDC_BRATE:
			if ((HIWORD(wParam) == CBN_SELCHANGE))
			{
#if defined(_WIN64)
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWLP_USERDATA);
#else
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
				int pos = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETCURSEL, 0, 0);
				int data = SendDlgItemMessage(hwndDlg, IDC_BRATE, CB_GETITEMDATA, pos, 0);
				wc->cfg.config_bitrate = data;
			}
			break;

		case IDC_ENCODER:
			if ((HIWORD(wParam) == CBN_SELCHANGE))
			{
#if defined(_WIN64)
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWLP_USERDATA);
#else
				wc = (configwndrec*)GetWindowLong(hwndDlg, GWL_USERDATA);
#endif
				if (wc)
				{
					int pos = SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_GETCURSEL, 0, 0);
					int data = SendDlgItemMessage(hwndDlg, IDC_ENCODER, CB_GETITEMDATA, pos, 0);
					wc->cfg.config_encoder = data;
					ResetConfig(hwndDlg, encs, &wc->cfg, MASK_VBR | MASK_SAMPLE_FORMAT | MASK_BITRATE);
				}
			}
			break;

		}
	}
	return 0;
}