steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Encoder/enc_wma/config.cpp

648 lines
21 KiB
C++
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink