Player::Player(QWidget *parent) :Html5ApplicationViewer(parent) {
QObject::connect(webView()->page()->mainFrame(),
SIGNAL(javaScriptWindowObjectCleared()), SLOT(addToJavaScript()));
api.sync();
playStatus = false;
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
return;
}
if (!BASS_Init(-1,44100,0,NULL,NULL)) {
return;
}
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
BASS_SetConfig(BASS_CONFIG_NET_PREBUF,0); // minimize automatic pre-buffering, so we can do it (and display it) instead
playList.insert("1", "http://mp3.polskieradio.pl:8900/;stream");
playList.insert("2", "http://stream3.polskieradio.pl:8902/;stream");
playList.insert("3", "http://stream3.polskieradio.pl:8904/;stream");
playList.insert("4", "http://mp3.polskieradio.pl:8906/;stream");
playList.insert("antyradio", "http://ant-waw.cdn.eurozet.pl:8602/;stream");
acr.loadSettings();
QObject::connect(&acr, SIGNAL(songFound(QJsonObject)),
this, SLOT(songFound(QJsonObject)));
QObject::connect(&api, SIGNAL(updateReady(QList<Radiostation>)),
this, SLOT(songFound(QList<Radiostation>)));
}
bool Program::initializeAudioDevice()
{
BASS_Free();
if (BASS_Init(-1, 44100, BASS_DEVICE_3D, NULL, NULL))
{
loadPlugins();
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST, 1);
BASS_SetConfig(BASS_CONFIG_NET_TIMEOUT, settings->connectTimeout);
BASS_SetConfig(BASS_CONFIG_WMA_BASSFILE, 1);
BASS_SetEAXParameters(-1, 0.0f, -1.0f, -1.0f);
return true;
}
logText(boost::str(boost::format("Error initializing audio device: %1%") % core->getAudio()->getErrorMessage()));
return false;
}
void net_radio_init(HWND hwnd) {
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
error("An incorrect version of BASS.DLL was loaded");
return;
}
win = hwnd;
// setup output device
if (!BASS_Init(-1,44100,0,win,NULL)) {
error("Can't initialize device");
DestroyWindow(win);
}
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
BASS_SetConfig(BASS_CONFIG_NET_PREBUF,0); // minimize automatic pre-buffering, so we can do it (and display it) instead
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,proxy); // setup proxy server location
}
int main(int argc, char* argv[])
{
IBNibRef nibRef;
OSStatus err;
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// initialize default output device
if (!BASS_Init(-1,44100,0,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
BASS_SetConfig(BASS_CONFIG_NET_PREBUF,0); // minimize automatic pre-buffering, so we can do it (and display it) instead
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,proxy); // setup proxy server location
// Create Window and stuff
err = CreateNibReference(CFSTR("netradio"), &nibRef);
if (err) return err;
err = CreateWindowFromNib(nibRef, CFSTR("Window"), &win);
if (err) return err;
DisposeNibReference(nibRef);
int a;
for (a=10;a<20;a++)
SetupControlHandler(a,kEventControlHit,RadioEventHandler);
SetupControlHandler(41,kEventControlHit,DirectEventHandler);
{
EventTypeSpec etype={'blah','blah'};
InstallApplicationEventHandler(NewEventHandlerUPP(CustomEventHandler),1,&etype,NULL,NULL);
}
ShowWindow(win);
RunApplicationEventLoop();
BASS_Free();
return 0;
}
CPlayer()
{
//return; // multi thread crash
m_this = this;
ZeroMemory(fx, sizeof(fx));
ZeroMemory(vol, sizeof(vol));
ZeroMemory(pos, sizeof(pos));
m_fPosition = 0.0f;
m_fTempo = 120.0f;
m_bPlaying = false;
m_fFreqMultiply = 1.0f;
m_fFreqMultiplyStep = 0.0f;
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION)
{
printf("An incorrect version of BASS.DLL was loaded");
return;
}
BASS_SetConfig(BASS_CONFIG_VISTA_TRUEPOS,0); // allows lower latency on Vista and newer
BASS_SetConfig(BASS_CONFIG_UPDATEPERIOD,10); // 10ms update period
// initialize default output device (and measure latency)
if (!BASS_Init(-1,44100,BASS_DEVICE_LATENCY,0,NULL))
{
printf("Can't initialize device");
return;
}
BASS_GetInfo(&info);
BASS_SetConfig(BASS_CONFIG_BUFFER,10+info.minbuf+1); // default buffer size = update period + 'minbuf' + 1ms extra margin
buflen=BASS_GetConfig(BASS_CONFIG_BUFFER);
if (!info.freq) info.freq=44100; // if the device's output rate is unknown default to 44100 Hz
stream=BASS_StreamCreate(info.freq,2,0,(STREAMPROC*)CPlayer::_WriteStream,0); // create a stream (stereo for effects)
BASS_ChannelPlay(stream,FALSE); // start it
//BASS_ChannelSetFX(stream, BASS_FX_DX8_CHORUS, 0);
//
}
int main(int argc, char* argv[])
{
regex_t fregex;
gtk_init(&argc,&argv);
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// enable floating-point DSP (not really necessary as the channels will be floating-point anyway)
BASS_SetConfig(BASS_CONFIG_FLOATDSP,TRUE);
// initialize default device
if (!BASS_Init(-1,44100,0,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
// initialize GUI
glade=glade_xml_new(GLADE_PATH"dsptest.glade",NULL,NULL);
if (!glade) return 0;
win=GetWidget("window1");
if (!win) return 0;
glade_xml_signal_autoconnect(glade);
{ // initialize file selector
GtkFileFilter *filter;
filesel=gtk_file_chooser_dialog_new("Open File",GTK_WINDOW(win),GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL);
filter=gtk_file_filter_new();
gtk_file_filter_set_name(filter,"Playable files");
regcomp(&fregex,"\\.(mo3|xm|mod|s3m|it|umx|mp[1-3]|ogg|wav|aif)$",REG_ICASE|REG_NOSUB|REG_EXTENDED);
gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex,NULL);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);
filter=gtk_file_filter_new();
gtk_file_filter_set_name(filter,"All files");
gtk_file_filter_add_pattern(filter,"*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);
}
gtk_main();
gtk_widget_destroy(filesel);
regfree(&fregex);
BASS_Free();
return 0;
}
void MainWindow::bassConfig(){
//bass configuration
BASS_SetConfig(BASS_CONFIG_BUFFER, 5000 );
// BASS_SetConfig(BASS_CONFIG_UPDATEPERIOD, 10);
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
// plugin
BASS_PluginFree(0);
QString Path=QCoreApplication::applicationDirPath().toLatin1();
#ifdef Q_OS_UNIX
BASS_PluginLoad(Path.toLatin1() + "/Plugin/libbass_aac.so",0);
BASS_PluginLoad(Path.toLatin1() + "/Plugin/libbassflac.so",0);
#endif
}
void LoadBassLibrary(TCHAR CurrBassPath[MAX_PATH])
{
hBass = LoadLibrary(CurrBassPath);
if (hBass != NULL) {
newBass = (BASS_SetConfig(BASS_CONFIG_DEV_DEFAULT, TRUE) != 0); // will use new "Default" device
DBVARIANT dbv = { 0 };
BASS_DEVICEINFO info;
if (!db_get_ts(NULL, ModuleName, OPT_OUTDEVICE, &dbv))
for (int i = 1; BASS_GetDeviceInfo(i, &info); i++)
if (!mir_tstrcmp(dbv.ptszVal, _A2T(info.name)))
device = i;
db_free(&dbv);
sndLimSnd = db_get_b(NULL, ModuleName, OPT_MAXCHAN, MAXCHAN);
if (sndLimSnd > MAXCHAN)
sndLimSnd = MAXCHAN;
TimeWrd1 = db_get_w(NULL, ModuleName, OPT_TIME1, 0);
TimeWrd2 = db_get_w(NULL, ModuleName, OPT_TIME2, 0);
QuietTime = db_get_b(NULL, ModuleName, OPT_QUIETTIME, 0);
EnPreview = db_get_b(NULL, ModuleName, OPT_PREVIEW, 0);
StatMask = db_get_w(NULL, ModuleName, OPT_STATUS, 0x3ff);
BASS_Init(device, 44100, 0, pcli->hwndContactList, NULL);
Volume = db_get_b(NULL, ModuleName, OPT_VOLUME, 33);
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Volume * 100);
hPlaySound = HookEvent(ME_SKIN_PLAYINGSOUND, OnPlaySnd);
CreateFrame();
}
else {
FreeLibrary(hBass);
hBass = NULL;
}
}
bool initSoundStuff (HWND hwnd) {
if (HIWORD(BASS_GetVersion())!=BASSVERSION)
{
warning (WARNING_BASS_WRONG_VERSION);
return false;
}
if (!BASS_Init(-1,44100,0,hwnd,NULL)) {
warning (WARNING_BASS_FAIL);
return false;
}
int a;
for (a = 0; a < MAX_SAMPLES; a ++) {
soundCache[a].sample = NULL;
soundCache[a].fileLoaded = -1;
}
BASS_SetConfig(BASS_CONFIG_GVOL_MUSIC, 10000);
BASS_SetConfig(BASS_CONFIG_GVOL_SAMPLE, 10000);
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, 10000);
return soundOK = true;
}
int main(int argc, char* argv[])
{
g_thread_init(NULL);
gdk_threads_init();
gtk_init(&argc,&argv);
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// initialize default output device
if (!BASS_Init(-1,44100,0,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
BASS_SetConfig(BASS_CONFIG_NET_PLAYLIST,1); // enable playlist processing
BASS_SetConfig(BASS_CONFIG_NET_PREBUF,0); // minimize automatic pre-buffering, so we can do it (and display it) instead
BASS_SetConfigPtr(BASS_CONFIG_NET_PROXY,proxy); // setup proxy server location
// initialize GUI
glade=glade_xml_new(GLADE_PATH"netradio.glade",NULL,NULL);
if (!glade) return 0;
win=GetWidget("window1");
if (!win) return 0;
glade_xml_signal_autoconnect(glade);
gdk_threads_enter();
gtk_main();
gdk_threads_leave();
BASS_Free();
return 0;
}
HRESULT CBSoundMgr::Initialize()
{
m_SoundAvailable = false;
#ifdef __IPHONEOS__
#define BASS_CONFIG_IOS_MIXAUDIO 34
BASS_SetConfig(BASS_CONFIG_IOS_MIXAUDIO, 6);
#endif
if (HIWORD(BASS_GetVersion()) != BASSVERSION)
{
Game->LOG(0, "An incorrect version of BASS was loaded");
return E_FAIL;
}
#ifdef USE_BASS_FX
if (HIWORD(BASS_FX_GetVersion()) != BASSVERSION)
{
Game->LOG(0, "An incorrect version of BASS FX was loaded");
return E_FAIL;
}
#endif
if (!BASS_Init(-1, 44100, 0, 0, NULL))
{
Game->LOG(0, "Can't initialize sound device");
return E_FAIL;
}
m_VolumeMaster = Game->m_Registry->ReadInt("Audio", "MasterVolume", 100);
m_VolumeSFX = Game->m_Registry->ReadInt("Audio", "SFXVolume", 100);
m_VolumeSpeech = Game->m_Registry->ReadInt("Audio", "SpeechVolume", 100);
m_VolumeMusic = Game->m_Registry->ReadInt("Audio", "MusicVolume", 100);
m_SoundAvailable = true;
SetMasterVolumePercent(m_VolumeMaster);
return S_OK;
}
void KNMusicBackendBass::setGlobalVolume(const int &volume)
{
#ifdef Q_OS_WIN64
float outputVolume=((float)volume)/10000.0;
if(m_wasapiEnabled)
{
//Use the WASAPI function to change the volume.
BASS_WASAPI_SetVolume(BASS_WASAPI_CURVE_WINDOWS,
outputVolume);
}
else
{
#endif
//Change the global volume size of the bass.
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, volume);
#ifdef Q_OS_WIN64
}
#endif
//Emit the volume changed signal.
emit volumeChanged(volume);
}
bool BassPlayer::initOutputDevice(const int & new_device, const int & frequency) {
bool res = BASS_Init(new_device, frequency, 0, NULL, NULL);
if (!res) {
if (BASS_ErrorGetCode() == BASS_ERROR_ALREADY) {
res = true;
} else {
qDebug() << "Init error: " << BASS_ErrorGetCode();
// throw "Cannot initialize device";
}
}
if (res) {
opened_devices.insert(new_device, true);
BASS_SetConfig(BASS_CONFIG_FLOATDSP, TRUE);
// BASS_SetConfig(BASS_CONFIG_NET_PREBUF, 15); // 15 percents prebuf
setOpenTimeOut(Settings::obj().openTimeOut());
}
return res;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int i = 0;
DWORD chan = 0;
DWORD act = 0;
DWORD volume = 100;
wchar_t file[320] = L"";
int argc = 0;
LPWSTR *argv;
int status = 0;
/* Check the correct BASS was loaded */
if(HIWORD(BASS_GetVersion()) != BASSVERSION)
{
usage(1, "Error: An incorrect version of BASS was loaded!");
}
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if(NULL == argv)
{
printf("Error: Could not determine arguments!\n");
exit(1);
}
if(argc > 4)
{
usage(1, "Error: Too many arguments!\n");
}
else
{
for (i = 1; i < argc; i++)
{
if (wcscmp(argv[i], L"-ver") == 0)
{
usage(0, "bassplayer-win version 2.3 by Christopher Brochtrup.\n");
}
else if(wcscmp(argv[i], L"-vol") == 0)
{
i++;
volume = _wtoi(argv[i]);
}
else
{
wcsncpy(file, argv[i], 255);
}
}
}
LocalFree(argv);
if(wcslen(file) == 0)
{
usage(1, "Error: No file provided!\n");
}
status = BASS_Init(-1, 44100, 0, 0, NULL);
if(!status)
{
print_bass_error("BASS_Init()");
}
chan = BASS_StreamCreateFile(FALSE, file, 0, 0, BASS_UNICODE);
if(!chan)
{
print_bass_error("BASS_StreamCreateFile()");
}
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, volume*100); /* Global stream volume (0-10000) */
status = BASS_ChannelPlay(chan, FALSE);
if(!status)
{
print_bass_error("BASS_ErrorGetCode()");
}
/* Wait for file to finish playing */
while(act = BASS_ChannelIsActive(chan))
{
Sleep(50);
}
BASS_Free();
exit(0);
} /* WinMain */
BOOL CALLBACK dialogproc(HWND h,UINT m,WPARAM w,LPARAM l)
{
DWORD a=0;
float freq;
char c[30];
BASS_BFX_PEAKEQ eq; // dsp peaking equalizer
BASS_BFX_PHASER phs; // dsp phaser
switch (m) {
case WM_COMMAND:
switch (LOWORD(w)) {
case ID_OPEN:
{
char file[MAX_PATH]="";
ofn.lpstrFilter="playable files\0*.mo3;*.xm;*.mod;*.s3m;*.it;*.mtm;*.mp3;*.mp2;*.mp1;*.ogg;*.wav;*.aif\0All files\0*.*\0\0";
ofn.lpstrFile=file;
if (GetOpenFileName(&ofn)) {
memcpy(path,file,ofn.nFileOffset);
path[ofn.nFileOffset-1]=0;
// free previous dsp effects & handles
BASS_StreamFree(chan); // free stream
BASS_MusicFree(chan); // free music
if(!(chan=BASS_StreamCreateFile(FALSE, file, 0, 0, BASS_SAMPLE_LOOP|floatable))&&
!(chan=BASS_MusicLoad(FALSE, file, 0, 0, BASS_MUSIC_LOOP|BASS_MUSIC_RAMP|floatable,0))){
// not a WAV/MP3 or MOD
MESS(ID_OPEN,WM_SETTEXT,0,"click here to open a file && play it...");
Error("Selected file couldnt be loaded!");
break;
}
// update the Button to show the loaded file name
MESS(ID_OPEN,WM_SETTEXT,0,GetFileName(file));
// set dsp effects
SendMessage(win,WM_COMMAND,IDC_CHKEQ,l);
SendMessage(win,WM_COMMAND,IDC_CHKPHS,l);
// get current sample rate
BASS_ChannelGetAttribute(chan, BASS_ATTRIB_FREQ, &freq);
oldfreq = freq;
// set the dx sample rate & view
MESS(IDC_DXRATE,TBM_SETRANGEMAX,0,(long)(freq * 1.3f));
MESS(IDC_DXRATE,TBM_SETRANGEMIN,0,(long)(freq * 0.7f));
MESS(IDC_DXRATE,TBM_SETPOS,TRUE,(long)freq);
MESS(IDC_DXRATE,TBM_SETPAGESIZE,0,(long)(freq * 0.01f)); // by 1%
sprintf(c,"DirectX Samplerate = %dHz", (long)freq);
MESS(IDC_SDXRATE,WM_SETTEXT,0,c);
// play it!
BASS_ChannelPlay(chan, FALSE);
}
}
return 1;
case IDC_CHKEQ:
if (MESS(IDC_CHKEQ,BM_GETCHECK,0,0))
SetDSP_EQ(0.0f, 2.5f, 0.0f, 125.0f, 1000.0f, 8000.0f);
else
BASS_ChannelRemoveFX(chan, fxEQ);
return 1;
case IDC_CHKPHS:
if(MESS(IDC_CHKPHS,BM_GETCHECK,0,0)){
fxPhaser=BASS_ChannelSetFX(chan, BASS_FX_BFX_PHASER,0);
BASS_FXGetParameters(fxPhaser, &phs);
phs.fWetMix = (float)MESS(IDC_WETMIX,TBM_GETPOS,0,0) / 1000.0f;
phs.fDryMix = (float)MESS(IDC_DRYMIX,TBM_GETPOS,0,0) / 1000.0f;
phs.fFeedback = (float)MESS(IDC_FEEDBACK,TBM_GETPOS,0,0) / 1000.0f;
phs.fRate = (float)MESS(IDC_RATE,TBM_GETPOS,0,0) / 10.0f;
phs.fRange = (float)MESS(IDC_RANGE,TBM_GETPOS,0,0) / 10.0f;
phs.fFreq = (float)MESS(IDC_FREQ,TBM_GETPOS,0,0) / 10.0f;
BASS_FXSetParameters(fxPhaser, &phs);
}else
BASS_ChannelRemoveFX(chan, fxPhaser);
return 1;
}
return 1;
case WM_VSCROLL:
if(l){
UpdateFX(GetDlgCtrlID((HWND)l)-IDC_SLDEQ1);
}
return 1;
case WM_HSCROLL:
if(!BASS_ChannelIsActive(chan)) break;
switch (GetDlgCtrlID((HWND)l)) {
case IDC_DXRATE:
BASS_ChannelSetAttribute(chan, BASS_ATTRIB_FREQ, (float)MESS(IDC_DXRATE, TBM_GETPOS, 0, 0));
sprintf(c,"DirectX Samplerate = %dHz", MESS(IDC_DXRATE, TBM_GETPOS, 0, 0));
MESS(IDC_SDXRATE,WM_SETTEXT,0,c);
// update all bands fCenters after changing samplerate
{
int i;
for(i=0;i<3;i++){
eq.lBand = i;
BASS_FXGetParameters(fxEQ, &eq);
eq.fCenter = eq.fCenter * (float)MESS(IDC_DXRATE, TBM_GETPOS, 0, 0) / oldfreq;
BASS_FXSetParameters(fxEQ, &eq);
}
oldfreq = (float)MESS(IDC_DXRATE, TBM_GETPOS, 0, 0);
}
break;
case IDC_DRYMIX:
case IDC_WETMIX:
case IDC_FEEDBACK:
case IDC_RATE:
case IDC_RANGE:
case IDC_FREQ:
BASS_FXGetParameters(fxPhaser, &phs);
phs.fWetMix = (float)MESS(IDC_WETMIX,TBM_GETPOS,0,0) / 1000.0f;
phs.fDryMix = (float)MESS(IDC_DRYMIX,TBM_GETPOS,0,0) / 1000.0f;
phs.fFeedback = (float)MESS(IDC_FEEDBACK,TBM_GETPOS,0,0) / 1000.0f;
phs.fRate = (float)MESS(IDC_RATE,TBM_GETPOS,0,0) / 10.0f;
phs.fRange = (float)MESS(IDC_RANGE,TBM_GETPOS,0,0) / 10.0f;
phs.fFreq = (float)MESS(IDC_FREQ,TBM_GETPOS,0,0) / 10.0f;
BASS_FXSetParameters(fxPhaser, &phs);
}
return 1;
case WM_INITDIALOG:
win=h;
GetCurrentDirectory(MAX_PATH,path);
memset(&ofn,0,sizeof(ofn));
ofn.lStructSize=sizeof(ofn);
ofn.hwndOwner=h;
ofn.hInstance=inst;
ofn.nMaxFile=MAX_PATH;
ofn.Flags=OFN_HIDEREADONLY|OFN_EXPLORER;
// enable floating-point DSP
BASS_SetConfig(BASS_CONFIG_FLOATDSP, TRUE);
// setup output - default device, 44100hz, stereo, 16 bits
if (!BASS_Init(-1,44100,0,win,NULL)) {
Error("Can't initialize device");
DestroyWindow(win);
return 1;
}
// check for floating-point capability
floatable = BASS_StreamCreate(44100, 2, BASS_SAMPLE_FLOAT, 0, 0);
if (floatable) {
BASS_StreamFree(floatable); //woohoo!
floatable = BASS_SAMPLE_FLOAT;
}
// initialize dsp eq sliders
MESS(IDC_SLDEQ1,TBM_SETRANGE,FALSE,MAKELONG(0,20));
MESS(IDC_SLDEQ1,TBM_SETPOS,TRUE,10);
MESS(IDC_SLDEQ2,TBM_SETRANGE,FALSE,MAKELONG(0,20));
MESS(IDC_SLDEQ2,TBM_SETPOS,TRUE,10);
MESS(IDC_SLDEQ3,TBM_SETRANGE,FALSE,MAKELONG(0,20));
MESS(IDC_SLDEQ3,TBM_SETPOS,TRUE,10);
// dx rate
MESS(IDC_DXRATE,TBM_SETRANGEMAX,0,(long)(44100.0f*1.3f));
MESS(IDC_DXRATE,TBM_SETRANGEMIN,0,(long)(44100.0f*0.7f));
MESS(IDC_DXRATE,TBM_SETPOS,TRUE,44100);
MESS(IDC_DXRATE,TBM_SETPAGESIZE,0,(long)(44100.0f*0.01f)); // by 1%
// DryMix
MESS(IDC_DRYMIX,TBM_SETRANGE,0,MAKELONG(-2000,2000));
MESS(IDC_DRYMIX,TBM_SETPOS,TRUE,-999);
// WetMix
MESS(IDC_WETMIX,TBM_SETRANGE,0,MAKELONG(-2000,2000));
MESS(IDC_WETMIX,TBM_SETPOS,TRUE,999);
// Feedback
MESS(IDC_FEEDBACK,TBM_SETRANGE,0,MAKELONG(-1000,1000));
MESS(IDC_FEEDBACK,TBM_SETPOS,TRUE,-60);
// Rate
MESS(IDC_RATE,TBM_SETRANGE,0,MAKELONG(0,100));
MESS(IDC_RATE,TBM_SETPOS,TRUE,2);
// Range
MESS(IDC_RANGE,TBM_SETRANGE,0,MAKELONG(0,100));
MESS(IDC_RANGE,TBM_SETPOS,TRUE,60);
// Freq
MESS(IDC_FREQ,TBM_SETRANGE,0,MAKELONG(0,10000));
MESS(IDC_FREQ,TBM_SETPOS,TRUE,1000);
Font=CreateFont(-12,0,0,0,FW_BOLD,FALSE,FALSE,FALSE,ANSI_CHARSET,OUT_STRING_PRECIS,
CLIP_STROKE_PRECIS,DRAFT_QUALITY,DEFAULT_PITCH | FF_DONTCARE,
"MS Sans Serif");
// set the font for check boxes
MESS(IDC_CHKEQ, WM_SETFONT, Font, TRUE);
MESS(IDC_CHKPHS,WM_SETFONT, Font, TRUE);
return 1;
case WM_CLOSE:
EndDialog(h,0);
return 0;
break;
}
return 0;
}
int main(int argc, char **argv)
{
std::cerr << "Start\n";
HANDLE hMapFile = OpenFileMappingA(FILE_MAP_ALL_ACCESS, FALSE, "sc_shared");
if(hMapFile == NULL)
{
return -10;
}
Shared *shared;
shared = (Shared*)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(*shared));
if(shared == NULL)
{
return -11;
}
std::string recDev = getopt(argc, argv, "--recDev=");
//int sc_version = std::stoi(getopt(argc, argv, "--version="));
BASS_SetConfig(BASS_CONFIG_UNICODE, true);
int recDevNo = -1;
BASS_DEVICEINFO info;
for(int i=0; BASS_RecordGetDeviceInfo(i, &info); i++)
{
if(recDev == std::to_string(hash_str(info.name)))
{
recDevNo = i;
break;
}
}
if(!BASS_RecordInit(recDevNo))
{
int code = BASS_ErrorGetCode();
std::string text = "BASS error: " + std::to_string(code);
if(code == 23)
text += "\nProblem with device: \"" + recDev + "\"!";
std::cerr << text << "\n";
return -1;
}
int sampleRate = std::stoi(getopt(argc, argv, "--samplerate="));
int channels = std::stoi(getopt(argc, argv, "--channels="));
recStream = BASS_RecordStart(sampleRate, channels, 0, RecordProc, nullptr);
#ifdef _WIN32
std::string lameBin = "lame.exe";
#else
std::string lameBin = "lame";
#endif
HENCODE encoder = BASS_Encode_Start(recStream,
(lameBin + " -b " + getopt(argc, argv, "--bitrate=") + " -").c_str(),
0,
NULL,
0);
bool ok = BASS_Encode_CastInit(encoder,
getopt(argc, argv, "--url=").c_str(),
getopt(argc, argv, "--password="******"--bitrate=")),
FALSE);
if(!ok)
{
int code = BASS_ErrorGetCode();
std::string text = "BASS error: " + std::to_string(code);
std::cerr << text << "\n";
return -2;
}
std::cerr << "OK\n";
while(!shared->end)
{
if(BASS_Encode_IsActive(encoder) != BASS_ACTIVE_PLAYING)
{
return -3;
}
BASS_CHANNELINFO info;
if(BASS_ChannelGetInfo(recStream, &info))
{
DWORD flags = info.chans == 1 ? BASS_LEVEL_MONO : BASS_LEVEL_STEREO;
BASS_ChannelGetLevelEx(recStream, shared->levels, 0.035f, flags);
}
Sleep(35);
}
std::cerr << "End\n";
UnmapViewOfFile((LPCVOID)shared);
CloseHandle(hMapFile);
return 0;
}
HRESULT CBSoundMgr::SetMasterVolumePercent(BYTE Percent)
{
m_VolumeMaster = Percent;
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, (DWORD)(10000.0f / 100.0f * (float)Percent));
return S_OK;
}
BOOL CALLBACK dialogproc(HWND h,UINT m,WPARAM w,LPARAM l)
{
switch (m) {
case WM_COMMAND:
switch (LOWORD(w)) {
case IDCANCEL:
DestroyWindow(h);
break;
case 10:
{
BASS_CHANNELINFO info;
char file[MAX_PATH]="";
ofn.lpstrFilter="playable files\0*.mo3;*.xm;*.mod;*.s3m;*.it;*.mtm;*.umx;*.mp3;*.mp2;*.mp1;*.ogg;*.wav;*.aif\0All files\0*.*\0\0";
ofn.lpstrFile=file;
if (GetOpenFileName(&ofn)) {
// free both MOD and stream, it must be one of them! :)
BASS_MusicFree(chan);
BASS_StreamFree(chan);
if (!(chan=BASS_StreamCreateFile(FALSE,file,0,0,BASS_SAMPLE_LOOP|floatable))
&& !(chan=BASS_MusicLoad(FALSE,file,0,0,BASS_SAMPLE_LOOP|BASS_MUSIC_RAMPS|floatable,1))) {
// whatever it is, it ain't playable
MESS(10,WM_SETTEXT,0,"click here to open a file...");
Error("Can't play the file");
break;
}
BASS_ChannelGetInfo(chan,&info);
if (info.chans!=2) { // only stereo is allowed
MESS(10,WM_SETTEXT,0,"click here to open a file...");
BASS_MusicFree(chan);
BASS_StreamFree(chan);
Error("only stereo sources are supported");
break;
}
MESS(10,WM_SETTEXT,0,file);
// setup DSPs on new channel and play it
SendMessage(win,WM_COMMAND,11,0);
SendMessage(win,WM_COMMAND,12,0);
SendMessage(win,WM_COMMAND,13,0);
BASS_ChannelPlay(chan,FALSE);
}
}
break;
case 11: // toggle "rotate"
if (MESS(11,BM_GETCHECK,0,0)) {
rotpos=0.7853981f;
rotdsp=BASS_ChannelSetDSP(chan,&Rotate,0,2);
} else
BASS_ChannelRemoveDSP(chan,rotdsp);
break;
case 12: // toggle "echo"
if (MESS(12,BM_GETCHECK,0,0)) {
memset(echbuf,0,sizeof(echbuf));
echpos=0;
echdsp=BASS_ChannelSetDSP(chan,&Echo,0,1);
} else
BASS_ChannelRemoveDSP(chan,echdsp);
break;
case 13: // toggle "flanger"
if (MESS(13,BM_GETCHECK,0,0)) {
memset(flabuf,0,sizeof(flabuf));
flapos=0;
flas=FLABUFLEN/2;
flasinc=0.002f;
fladsp=BASS_ChannelSetDSP(chan,&Flange,0,0);
} else
BASS_ChannelRemoveDSP(chan,fladsp);
break;
}
break;
case WM_INITDIALOG:
win=h;
memset(&ofn,0,sizeof(ofn));
ofn.lStructSize=sizeof(ofn);
ofn.hwndOwner=h;
ofn.nMaxFile=MAX_PATH;
ofn.Flags=OFN_HIDEREADONLY|OFN_EXPLORER;
// enable floating-point DSP
BASS_SetConfig(BASS_CONFIG_FLOATDSP,TRUE);
// initialize - default device
if (!BASS_Init(-1,44100,0,win,NULL)) {
Error("Can't initialize device");
DestroyWindow(win);
break;
}
// check for floating-point capability
floatable=BASS_StreamCreate(44100,2,BASS_SAMPLE_FLOAT,NULL,0);
if (floatable) { // woohoo!
BASS_StreamFree(floatable);
floatable=BASS_SAMPLE_FLOAT;
}
return 1;
case WM_DESTROY:
BASS_Free();
break;
}
return 0;
}
void __cdecl main(int argc, char **argv)
{
HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
int running = 1;
#ifdef WIN32
if (IsDebuggerPresent())
{
// turn on floating-point exceptions
unsigned int prev;
_clearfp();
_controlfp_s(&prev, 0, _EM_ZERODIVIDE|_EM_INVALID);
}
#endif
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion()) != BASSVERSION)
{
fprintf(stderr, "An incorrect version of BASS.DLL was loaded");
return;
}
// set the window title
SetConsoleTitle(TEXT(title_text));
// set the console buffer size
static const COORD bufferSize = { 80, 50 };
SetConsoleScreenBufferSize(hOut, bufferSize);
// set the console window size
static const SMALL_RECT windowSize = { 0, 0, 79, 49 };
SetConsoleWindowInfo(hOut, TRUE, &windowSize);
// clear the window
Clear(hOut);
// hide the cursor
static const CONSOLE_CURSOR_INFO cursorInfo = { 100, FALSE };
SetConsoleCursorInfo(hOut, &cursorInfo);
// set input mode
SetConsoleMode(hIn, 0);
// 10ms update period
const DWORD STREAM_UPDATE_PERIOD = 10;
BASS_SetConfig(BASS_CONFIG_UPDATEPERIOD, STREAM_UPDATE_PERIOD);
// initialize BASS sound library
const DWORD STREAM_FREQUENCY = 48000;
if (!BASS_Init(-1, STREAM_FREQUENCY, BASS_DEVICE_LATENCY, 0, NULL))
Error("Can't initialize device");
// get device info
BASS_GetInfo(&info);
// if the device's output rate is unknown default to stream frequency
if (!info.freq) info.freq = STREAM_FREQUENCY;
// debug print info
DebugPrint("frequency: %d (min %d, max %d)\n", info.freq, info.minrate, info.maxrate);
DebugPrint("device latency: %dms\n", info.latency);
DebugPrint("device minbuf: %dms\n", info.minbuf);
DebugPrint("ds version: %d (effects %s)\n", info.dsver, info.dsver < 8 ? "disabled" : "enabled");
// default buffer size = update period + 'minbuf' + 1ms extra margin
BASS_SetConfig(BASS_CONFIG_BUFFER, STREAM_UPDATE_PERIOD + info.minbuf + 1);
DebugPrint("using a %dms buffer\r", BASS_GetConfig(BASS_CONFIG_BUFFER));
// create a stream, stereo so that effects sound nice
stream = BASS_StreamCreate(info.freq, 2, BASS_SAMPLE_FLOAT, (STREAMPROC*)WriteStream, 0);
// set channel to apply effects
fx_channel = stream;
#ifdef BANDLIMITED_SAWTOOTH
// initialize bandlimited sawtooth tables
InitSawtooth();
#endif
// initialize waves
InitWave();
// enable the first oscillator
osc_config[0].enable = true;
// reset all controllers
Control::ResetAll();
// start playing the audio stream
BASS_ChannelPlay(stream, FALSE);
// get the number of midi devices
UINT midiInDevs = Midi::Input::GetNumDevices();
DebugPrint("MIDI input devices: %d\n", midiInDevs);
// print device names
for (UINT i = 0; i < midiInDevs; ++i)
{
MIDIINCAPS midiInCaps;
if (Midi::Input::GetDeviceCaps(i, midiInCaps) == 0)
{
DebugPrint("%d: %s\n", i, midiInCaps.szPname);
}
}
// if there are any devices available...
if (midiInDevs > 0)
{
// open and start midi input
// TO DO: select device number via a configuration setting
Midi::Input::Open(0);
Midi::Input::Start();
}
// initialize to middle c
note_most_recent = 60;
voice_note[voice_most_recent] = unsigned char(note_most_recent);
DisplaySpectrumAnalyzer displaySpectrumAnalyzer;
DisplayKeyVolumeEnvelope displayKeyVolumeEnvelope;
DisplayOscillatorWaveform displayOscillatorWaveform;
DisplayOscillatorFrequency displayOscillatorFrequency;
DisplayLowFrequencyOscillator displayLowFrequencyOscillator;
DisplayFilterFrequency displayFilterFrequency;
// initialize spectrum analyzer
displaySpectrumAnalyzer.Init(stream, info);
// initialize key display
displayKeyVolumeEnvelope.Init(hOut);
// show output scale and key octave
PrintOutputScale(hOut);
PrintKeyOctave(hOut);
PrintGoToEffects(hOut);
PrintAntialias(hOut);
// show main page
Menu::SetActivePage(hOut, Menu::PAGE_MAIN);
while (running)
{
// if there are any pending input events...
DWORD numEvents = 0;
while (GetNumberOfConsoleInputEvents(hIn, &numEvents) && numEvents > 0)
{
// get the next input event
INPUT_RECORD keyin;
ReadConsoleInput(hIn, &keyin, 1, &numEvents);
if (keyin.EventType == KEY_EVENT)
{
// handle interface keys
if (keyin.Event.KeyEvent.bKeyDown)
{
WORD code = keyin.Event.KeyEvent.wVirtualKeyCode;
DWORD modifiers = keyin.Event.KeyEvent.dwControlKeyState;
if (code == VK_ESCAPE)
{
running = 0;
break;
}
else if (code == VK_OEM_MINUS || code == VK_SUBTRACT)
{
Menu::UpdatePercentageProperty(output_scale, -1, modifiers, 0, 4);
PrintOutputScale(hOut);
}
else if (code == VK_OEM_PLUS || code == VK_ADD)
{
Menu::UpdatePercentageProperty(output_scale, +1, modifiers, 0, 4);
PrintOutputScale(hOut);
}
else if (code == VK_OEM_4) // '['
{
if (keyboard_octave > 1)
{
for (int k = 0; k < KEYS; ++k)
{
if (key_down[k])
NoteOff(k + keyboard_octave * 12);
}
--keyboard_octave;
for (int k = 0; k < KEYS; ++k)
{
if (key_down[k])
NoteOn(k + keyboard_octave * 12);
}
PrintKeyOctave(hOut);
}
}
else if (code == VK_OEM_6) // ']'
{
if (keyboard_octave < 9)
{
for (int k = 0; k < KEYS; ++k)
{
if (key_down[k])
NoteOff(k + keyboard_octave * 12);
}
++keyboard_octave;
for (int k = 0; k < KEYS; ++k)
{
if (key_down[k])
NoteOn(k + keyboard_octave * 12);
}
PrintKeyOctave(hOut);
}
}
else if (code == VK_F12)
{
use_antialias = !use_antialias;
PrintAntialias(hOut);
}
else if (code >= VK_F1 && code < VK_F10)
{
Menu::SetActiveMenu(hOut, code - VK_F1);
}
else if (code == VK_F10)
{
PrintGoToEffects(hOut);
Menu::SetActivePage(hOut, Menu::PAGE_MAIN);
}
else if (code == VK_F11)
{
PrintGoToMain(hOut);
Menu::SetActivePage(hOut, Menu::PAGE_FX);
}
else if (code == VK_TAB)
{
if (modifiers & SHIFT_PRESSED)
Menu::PrevMenu(hOut);
else
Menu::NextMenu(hOut);
}
else if (code == VK_UP || code == VK_DOWN || code == VK_RIGHT || code == VK_LEFT)
{
Menu::Handler(hOut, code, modifiers);
}
}
// handle note keys
for (int k = 0; k < KEYS; k++)
{
if (keyin.Event.KeyEvent.wVirtualKeyCode == keys[k])
{
// key down
bool down = (keyin.Event.KeyEvent.bKeyDown != 0);
// if key down state changed...
if (key_down[k] != down)
{
// update state
key_down[k] = down;
// if pressing the key
if (down)
{
// note on
NoteOn(k + keyboard_octave * 12);
}
else
{
// note off
NoteOff(k + keyboard_octave * 12);
}
}
break;
}
}
}
}
// center frequency of the zeroth semitone band
// (one octave down from the lowest key)
float const freq_min = powf(2, float(keyboard_octave - 6)) * middle_c_frequency;
// update the spectrum analyzer display
displaySpectrumAnalyzer.Update(hOut, stream, info, freq_min);
// update note key volume envelope display
displayKeyVolumeEnvelope.Update(hOut);
if (Menu::active_page == Menu::PAGE_MAIN)
{
// update the oscillator waveform display
displayOscillatorWaveform.Update(hOut, info, voice_most_recent);
// update the oscillator frequency displays
for (int o = 0; o < NUM_OSCILLATORS; ++o)
{
if (osc_config[o].enable)
displayOscillatorFrequency.Update(hOut, voice_most_recent, o);
}
// update the low-frequency oscillator display
displayLowFrequencyOscillator.Update(hOut);
// update the filter frequency display
if (flt_config.enable)
displayFilterFrequency.Update(hOut, voice_most_recent);
}
// show CPU usage
PrintConsole(hOut, { 73, 49 }, "%6.2f%%", BASS_GetCPU());
// sleep for 1/60th of second
Sleep(16);
}
if (midiInDevs)
{
// stop and close midi input
Midi::Input::Stop();
Midi::Input::Close();
}
// clean up spectrum analyzer
displaySpectrumAnalyzer.Cleanup(stream);
// clear the window
Clear(hOut);
BASS_Free();
}
int main(int argc, char* argv[])
{
regex_t fregex[2];
gtk_init(&argc,&argv);
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
Error("An incorrect version of BASS was loaded");
return 0;
}
// Initialize the output device with 3D support
if (!BASS_Init(-1,44100,BASS_DEVICE_3D,NULL,NULL)) {
Error("Can't initialize device");
return 0;
}
{
BASS_INFO i;
BASS_GetInfo(&i);
if (i.speakers>2) {
GtkWidget *dialog=gtk_message_dialog_new(NULL,0,
GTK_MESSAGE_QUESTION,GTK_BUTTONS_YES_NO,"Multiple speakers were detected. Would you like to use them?");
if (gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_NO)
BASS_SetConfig(BASS_CONFIG_3DALGORITHM,BASS_3DALG_OFF);
gtk_widget_destroy(dialog);
}
}
// Use meters as distance unit, real world rolloff, real doppler effect
BASS_Set3DFactors(1,1,1);
// initialize GUI
glade=glade_xml_new(GLADE_PATH"3dtest.glade",NULL,NULL);
if (!glade) return 0;
win=GetWidget("window1");
if (!win) return 0;
glade_xml_signal_autoconnect(glade);
g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(GetWidget("channels"))),"changed",G_CALLBACK(ListSelectionChange),NULL);
{ // setup list
GtkTreeView *list=GTK_TREE_VIEW(GetWidget("channels"));
GtkTreeViewColumn *col=gtk_tree_view_column_new();
gtk_tree_view_append_column(list,col);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col,renderer,TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
GtkListStore *liststore=gtk_list_store_new(1,G_TYPE_STRING);
gtk_tree_view_set_model(list,GTK_TREE_MODEL(liststore));
g_object_unref(liststore);
}
{ // initialize file selector
GtkFileFilter *filter;
filesel=gtk_file_chooser_dialog_new("Open File",GTK_WINDOW(win),GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,GTK_STOCK_OPEN,GTK_RESPONSE_ACCEPT,NULL);
filter=gtk_file_filter_new();
gtk_file_filter_set_name(filter,"Streamable files (wav/aif/mp3/mp2/mp1/ogg)");
regcomp(&fregex[0],"\\.(mp[1-3]|ogg|wav|aif)$",REG_ICASE|REG_NOSUB|REG_EXTENDED);
gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[0],NULL);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);
filter=gtk_file_filter_new();
gtk_file_filter_set_name(filter,"MOD music files (mo3/xm/mod/s3m/it/mtm/umx)");
regcomp(&fregex[1],"\\.(mo3|xm|mod|s3m|it|umx)$",REG_ICASE|REG_NOSUB|REG_EXTENDED);
gtk_file_filter_add_custom(filter,GTK_FILE_FILTER_FILENAME,FileExtensionFilter,&fregex[1],NULL);
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);
filter=gtk_file_filter_new();
gtk_file_filter_set_name(filter,"All files");
gtk_file_filter_add_pattern(filter,"*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filesel),filter);
}
g_timeout_add(TIMERPERIOD,Update,NULL);
UpdateButtons();
gtk_main();
gtk_widget_destroy(filesel);
regfree(&fregex[0]);
regfree(&fregex[1]);
BASS_Free(); // close output
return 0;
}
INT_PTR CALLBACK OptionsProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
{
SYSTEMTIME systime = { 0 };
SendDlgItemMessage(hwndDlg, IDC_MAXCHANNEL, CB_RESETCONTENT, 0, 0);
for (int i = 1; i <= MAXCHAN; i++)
SendDlgItemMessage(hwndDlg, IDC_MAXCHANNEL, CB_ADDSTRING, 0, (LPARAM)_itot(i, tmp, 10));
SendDlgItemMessage(hwndDlg, IDC_MAXCHANNEL, CB_SETCURSEL, sndLimSnd - 1, 0);
SetDlgItemText(hwndDlg, IDC_CURRPATH, CurrBassPath);
hwndOptSlider = GetDlgItem(hwndDlg, IDC_VOLUME);
SendDlgItemMessage(hwndDlg, IDC_VOLUME, TBM_SETRANGE, FALSE, MAKELONG(SLIDER_MIN, SLIDER_MAX));
SendDlgItemMessage(hwndDlg, IDC_VOLUME, TBM_SETPOS, TRUE, Volume);
SendDlgItemMessage(hwndDlg, IDC_VOLUME, TBM_SETPAGESIZE, 0, 5);
systime.wHour = HIBYTE(TimeWrd1);
systime.wMinute = LOBYTE(TimeWrd1);
systime.wYear = 2000;
systime.wMonth = 1;
systime.wDay = 1;
SendDlgItemMessage(hwndDlg, IDC_TIME1, DTM_SETFORMAT, 0, (LPARAM)_T("HH:mm"));
SendDlgItemMessage(hwndDlg, IDC_TIME1, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&systime);
systime.wHour = HIBYTE(TimeWrd2);
systime.wMinute = LOBYTE(TimeWrd2);
SendDlgItemMessage(hwndDlg, IDC_TIME2, DTM_SETFORMAT, 0, (LPARAM)_T("HH:mm"));
SendDlgItemMessage(hwndDlg, IDC_TIME2, DTM_SETSYSTEMTIME, GDT_VALID, (LPARAM)&systime);
CheckDlgButton(hwndDlg, IDC_PREVIEW, EnPreview ? BST_CHECKED : BST_UNCHECKED);
for (int i = IDC_CHECKBOX1; i < IDC_CHECKBOX10 + 1; i++)
if (StatMask & (1 << (i - IDC_CHECKBOX1)))
CheckDlgButton(hwndDlg, i, BST_CHECKED);
if (QuietTime) {
EnableWindow(GetDlgItem(hwndDlg, IDC_TIME1), TRUE);
EnableWindow(GetDlgItem(hwndDlg, IDC_TIME2), TRUE);
CheckDlgButton(hwndDlg, IDC_QUIETTIME, BST_CHECKED);
}
if (hBass == NULL) {
EnableWindow(GetDlgItem(hwndDlg, IDC_VOLUME), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_MAXCHANNEL), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_OUTDEVICE), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_QUIETTIME), FALSE);
EnableWindow(GetDlgItem(hwndDlg, IDC_PREVIEW), FALSE);
for (int i = IDC_CHECKBOX1; i < IDC_CHECKBOX10 + 1; i++)
EnableWindow(GetDlgItem(hwndDlg, i), FALSE);
}
else {
DBVARIANT dbv = { 0 }; BASS_DEVICEINFO info; DWORD bassver = BASS_GetVersion();
mir_sntprintf(tmp, _countof(tmp), TranslateT("un4seen's bass version: %d.%d.%d.%d"), bassver >> 24, (bassver >> 16) & 0xff, (bassver >> 8) & 0xff, bassver & 0xff);
SetDlgItemText(hwndDlg, IDC_BASSVERSION, tmp);
SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_ADDSTRING, 0, (LPARAM)TranslateT("--default device--"));
SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_SETCURSEL, 0, 0);
db_get_ts(NULL, ModuleName, OPT_OUTDEVICE, &dbv);
for (int i = 1; BASS_GetDeviceInfo(i + newBass, &info); i++) {
SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_ADDSTRING, 0, _A2T(info.name));
if (!mir_tstrcmp(dbv.ptszVal, _A2T(info.name)))
SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_SETCURSEL, i, 0);
}
db_free(&dbv);
}
}
return TRUE;
case WM_HSCROLL:
if (hBass != NULL)
if (LOWORD(wParam) == SB_ENDSCROLL || LOWORD(wParam) == SB_THUMBTRACK) {
Volume = SendDlgItemMessage(hwndDlg, IDC_VOLUME, TBM_GETPOS, 0, 0);
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Volume * 100);
SendMessage(hwndSlider, TBM_SETPOS, TRUE, Volume);
Preview = TRUE;
if (EnPreview)
SkinPlaySound("AlertMsg");
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->code) {
case PSN_APPLY:
if (hBass != NULL) {
SYSTEMTIME systime = { 0 };
GetDlgItemText(hwndDlg, IDC_OUTDEVICE, tmp, _countof(tmp));
db_set_ts(NULL, ModuleName, OPT_OUTDEVICE, tmp);
Volume = (DWORD)SendDlgItemMessage(hwndDlg, IDC_VOLUME, TBM_GETPOS, 0, 0);
db_set_b(NULL, ModuleName, OPT_VOLUME, Volume);
sndLimSnd = SendDlgItemMessage(hwndDlg, IDC_MAXCHANNEL, CB_GETCURSEL, 0, 0) + 1;
if (sndLimSnd > MAXCHAN)
sndLimSnd = MAXCHAN;
db_set_b(NULL, ModuleName, OPT_MAXCHAN, sndLimSnd);
QuietTime = IsDlgButtonChecked(hwndDlg, IDC_QUIETTIME) == BST_CHECKED;
db_set_b(NULL, ModuleName, OPT_QUIETTIME, QuietTime);
SendDlgItemMessage(hwndDlg, IDC_TIME1, DTM_GETSYSTEMTIME, 0, (LPARAM)&systime);
TimeWrd1 = MAKEWORD(systime.wMinute, systime.wHour);
db_set_w(NULL, ModuleName, OPT_TIME1, TimeWrd1);
SendDlgItemMessage(hwndDlg, IDC_TIME2, DTM_GETSYSTEMTIME, 0, (LPARAM)&systime);
TimeWrd2 = MAKEWORD(systime.wMinute, systime.wHour);
db_set_w(NULL, ModuleName, OPT_TIME2, TimeWrd2);
EnPreview = IsDlgButtonChecked(hwndDlg, IDC_PREVIEW) == BST_CHECKED;
db_set_b(NULL, ModuleName, OPT_PREVIEW, EnPreview);
StatMask = 0;
for (int i = IDC_CHECKBOX10; i > IDC_CHECKBOX1 - 1; i--) {
StatMask <<= 1;
if (IsDlgButtonChecked(hwndDlg, i) == BST_CHECKED)
StatMask |= 1;
}
db_set_w(NULL, ModuleName, OPT_STATUS, StatMask);
device = SendDlgItemMessage(hwndDlg, IDC_OUTDEVICE, CB_GETCURSEL, 0, 0);
if (device == 0)
device = -1;
else
device += newBass;
}
return 1;
case PSN_RESET:
if (hBass != NULL)
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Volume * 100);
return 1;
case DTN_DATETIMECHANGE:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
return 1;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_QUIETTIME:
{
BOOL b = IsDlgButtonChecked(hwndDlg, IDC_QUIETTIME) == BST_CHECKED;
EnableWindow(GetDlgItem(hwndDlg, IDC_TIME1), b);
EnableWindow(GetDlgItem(hwndDlg, IDC_TIME2), b);
}
case IDC_MAXCHANNEL:
case IDC_OUTDEVICE:
case IDC_CHECKBOX1:
case IDC_CHECKBOX2:
case IDC_CHECKBOX3:
case IDC_CHECKBOX4:
case IDC_CHECKBOX5:
case IDC_CHECKBOX6:
case IDC_CHECKBOX7:
case IDC_CHECKBOX8:
case IDC_CHECKBOX9:
case IDC_CHECKBOX10:
case IDC_PREVIEW:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case IDC_GETBASS:
Utils_OpenUrl("http://www.un4seen.com/");
break;
}
break;
}
return 0;
}
static LRESULT CALLBACK FrameWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
switch (msg) {
case WM_CREATE:
hwndMute = CreateWindow(MIRANDABUTTONCLASS, _T(""), WS_CHILD | WS_VISIBLE, 1, 1, 16, 16, hwnd,
0, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
SendMessage(hwndMute, BUTTONSETASFLATBTN, 1, 0);
SendMessage(hwndMute, BUTTONSETCUSTOMPAINT, 0, (LPARAM)&fnPainter);
EnableFrameIcon(db_get_b(NULL, "Skin", "UseSound", 0) != 0);
hwndSlider = CreateWindow(TRACKBAR_CLASS, _T(""), WS_CHILD | WS_VISIBLE | TBS_NOTICKS | TBS_TOOLTIPS, 21, 1, 100, 20,
hwnd, (HMENU)0, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
SendMessage(hwndSlider, TBM_SETRANGE, FALSE, MAKELONG(SLIDER_MIN, SLIDER_MAX));
SendMessage(hwndSlider, TBM_SETPOS, TRUE, Volume);
mir_subclassWindow(hwndSlider, SliderWndProc);
break;
case WM_COMMAND:
if ((HWND)lParam == hwndMute) {
bool useSound = !db_get_b(NULL, "Skin", "UseSound", 0);
db_set_b(NULL, "Skin", "UseSound", useSound);
EnableFrameIcon(useSound);
}
break;
case WM_HSCROLL:
if (hBass != NULL)
if (LOWORD(wParam) == SB_ENDSCROLL || LOWORD(wParam) == SB_THUMBTRACK) {
Volume = (DWORD)SendMessage(hwndSlider, TBM_GETPOS, 0, 0);
db_set_b(NULL, ModuleName, OPT_VOLUME, Volume);
BASS_SetConfig(BASS_CONFIG_GVOL_STREAM, Volume * 100);
SendMessage(hwndOptSlider, TBM_SETPOS, TRUE, Volume);
Preview = TRUE;
if (EnPreview)
SkinPlaySound("AlertMsg");
}
break;
case WM_SIZE:
GetClientRect(hwnd, &rc);
if (hwndMute)
MoveWindow(hwndMute, rc.right - 20, 2, 16, 16, FALSE);
SetWindowPos(hwndSlider, 0, 1, rc.top + 1 + (20 - 18) / 2, rc.right - rc.left - 1 - 20, 18, SWP_NOZORDER);
InvalidateRect(hwnd, &rc, FALSE);
return 0;
case WM_ERASEBKGND:
GetClientRect(hwnd, &rc);
FillRect((HDC)wParam, &rc, hBkgBrush);
return TRUE;
case WM_CTLCOLORSTATIC:
if ((HWND)lParam == hwndSlider) {
HDC dc = (HDC)wParam;
SetBkColor(dc, clBack);
return (BOOL)hBkgBrush;
}
break;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return TRUE;
}
inline bool KNMusicBackendBass::initialBass(DWORD &channelFlags)
{
//Detect operating system version and enable option for using WASAPI.
#ifdef Q_OS_WIN64
m_wasapiEnabled=m_systemConfigure->data("WASAPI", false).toBool();
#endif
//Get the buffer length.
int bufferLength=m_systemConfigure->data("BufferLength", 500).toInt();
//Check buffer length is valid.
if(bufferLength<10)
{
//For minimum, buffer should be 10ms.
bufferLength=10;
}
else if(bufferLength>5000)
{
//For maximum, buffer should be 5000ms.
bufferLength=5000;
}
//Get the output device index.
QString outputDeviceId="-1";
{
//Check whether the configure has output device.
if(m_systemConfigure->contains("OutputDevice"))
{
//Get the json object.
QJsonObject deviceInfo=
m_systemConfigure->data("OutputDevice").toJsonObject();
//Get the device info Id.
outputDeviceId=deviceInfo.value("Id").toString();
}
}
//Check the bass library version first.
if(HIWORD(BASS_GetVersion()) > BASSVERSION)
{
//Failed to load a higher version bass library.
return false;
}
//Enabled float digital signal processing.
//DON'T MOVE THIS, this should config before bass init.
if(m_systemConfigure->data("Float", false).toBool())
{
//Enable 32-bit floating-point sample data converting.
BASS_SetConfig(BASS_CONFIG_FLOATDSP, TRUE);
}
//Set the buffer length.
BASS_SetConfig(BASS_CONFIG_BUFFER, static_cast<DWORD>(bufferLength));
//Get the setting sample rate.
QString userSampleRate=
m_systemConfigure->data("SampleRate", "None").toString();
//Set a default initial sample rate.
int initialSampleRate=44100;
#ifdef Q_OS_WIN64
if(m_wasapiEnabled)
{
//Prepare the user output device info.
int userOutputDevice=-1;
//Check the user output device selection.
if(outputDeviceId.startsWith("w"))
{
//Get the possible output device.
userOutputDevice=outputDeviceId.mid(1).toInt();
}
//For 64-bit Windows, we will enable WASAPI as the playing API instead
//of using DirectX.
//Find the output device.
BASS_WASAPI_DEVICEINFO deviceInfo;
int deviceCount=0;
QList<int> validDeviceIndex;
for(deviceCount=0;
BASS_WASAPI_GetDeviceInfo(deviceCount, &deviceInfo);
++deviceCount)
{
//Check the device flag.
if((deviceInfo.flags & (BASS_DEVICE_LOOPBACK |
BASS_DEVICE_INPUT))==0)
{
//Check the valid device list.
if((deviceInfo.flags & BASS_DEVICE_DEFAULT)
==BASS_DEVICE_DEFAULT)
{
//Save the default device index.
m_wasapiOutputDevice=deviceCount;
}
//Add the device to the list.
validDeviceIndex.append(deviceCount);
}
}
// Check the device index.
if(validDeviceIndex.isEmpty())
{
//Failed to find the output device.
return false;
}
//Check the user selection is still valid.
if(validDeviceIndex.contains(userOutputDevice))
{
//Set the user selected device as the output device.
m_wasapiOutputDevice=userOutputDevice;
}
//Because we won't playing anything via BASS, so don't need an update
//thread.
BASS_SetConfig(BASS_CONFIG_UPDATETHREADS, 0);
//Setup BASS - "no sound" device with the "mix" sample rate (default for
//MOD music)
BASS_Init(0, deviceInfo.mixfreq, 0, 0, NULL);
}
else
{
#endif
//Check the start data.
DWORD outputDevice=-1;
if(!outputDeviceId.startsWith("w"))
{
//Get the raw output device
int rawOutputDevice=outputDeviceId.toInt();
//Check whether the output device is valid.
QJsonArray allDevices=deviceList();
//Check whether the output device is existed.
if(rawOutputDevice>=-1 && (rawOutputDevice<allDevices.size()-1))
{
//Set the device back to default.
outputDevice=rawOutputDevice;
}
}
//Normal bass initialize.
//Prepare the bass initial flag.
DWORD initFlag=0;
//Check the user sample rate.
if(QString::number(userSampleRate.toInt())==userSampleRate)
{
//Update the initial sample rate.
initialSampleRate=userSampleRate.toInt();
//Add the initial flag.
initFlag |= BASS_DEVICE_FREQ;
}
//Check the preference setting.
if(m_systemConfigure->data("Stereo", false).toBool())
{
//Add stereo flag.
initFlag |= BASS_DEVICE_STEREO;
}
//Initial bass library.
if(!BASS_Init(outputDevice, initialSampleRate, initFlag, NULL, NULL))
{
//Failed to initial the library bass.
return false;
}
#ifdef Q_OS_WIN64
}
#endif
//Clear the channel flags.
channelFlags=0;
//When enabling 32-bit floating converting, check the float support.
if(m_systemConfigure->data("Float", false).toBool())
{
//Check float dsp supporting.
DWORD fdpsCheck=BASS_StreamCreate(initialSampleRate,
2, BASS_SAMPLE_FLOAT, NULL, 0);
//If support the float dsp,
if(fdpsCheck)
{
//Free the check channel, recover the memory.
BASS_StreamFree(fdpsCheck);
//Set fdps support flag.
channelFlags |= BASS_SAMPLE_FLOAT;
}
}
//Load complete.
return true;
}
void main(int argc, char **argv)
{
const char *fxname[9]={"CHORUS","COMPRESSOR","DISTORTION","ECHO",
"FLANGER","GARGLE","I3DL2REVERB","PARAMEQ","REVERB"};
HFX fx[9]={0}; // effect handles
INPUT_RECORD keyin;
DWORD r,buflen;
printf("BASS Simple Sinewave Synth\n"
"--------------------------\n");
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
printf("An incorrect version of BASS.DLL was loaded");
return;
}
// 10ms update period
BASS_SetConfig(BASS_CONFIG_UPDATEPERIOD,10);
// setup output - get latency
if (!BASS_Init(-1,44100,BASS_DEVICE_LATENCY,0,NULL))
Error("Can't initialize device");
BASS_GetInfo(&info);
// default buffer size = update period + 'minbuf' + 1ms extra margin
BASS_SetConfig(BASS_CONFIG_BUFFER,10+info.minbuf+1);
buflen=BASS_GetConfig(BASS_CONFIG_BUFFER);
// if the device's output rate is unknown default to 44100 Hz
if (!info.freq) info.freq=44100;
// create a stream, stereo so that effects sound nice
stream=BASS_StreamCreate(info.freq,2,0,(STREAMPROC*)WriteStream,0);
printf("device latency: %dms\n",info.latency);
printf("device minbuf: %dms\n",info.minbuf);
printf("ds version: %d (effects %s)\n",info.dsver,info.dsver<8?"disabled":"enabled");
printf("press these keys to play:\n\n"
" 2 3 5 6 7 9 0 =\n"
" Q W ER T Y UI O P[ ]\n\n"
"press -/+ to de/increase the buffer\n"
"press spacebar to quit\n\n");
if (info.dsver>=8) // DX8 effects available
printf("press F1-F9 to toggle effects\n\n");
printf("using a %dms buffer\r",buflen);
BASS_ChannelPlay(stream,FALSE);
while (ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE),&keyin,1,&r)) {
int key;
if (keyin.EventType!=KEY_EVENT) continue;
if (keyin.Event.KeyEvent.wVirtualKeyCode==VK_SPACE) break;
if (keyin.Event.KeyEvent.bKeyDown) {
if (keyin.Event.KeyEvent.wVirtualKeyCode==VK_SUBTRACT
|| keyin.Event.KeyEvent.wVirtualKeyCode==VK_ADD) {
// recreate stream with smaller/larger buffer
BASS_StreamFree(stream);
if (keyin.Event.KeyEvent.wVirtualKeyCode==VK_SUBTRACT)
BASS_SetConfig(BASS_CONFIG_BUFFER,buflen-1); // smaller buffer
else
BASS_SetConfig(BASS_CONFIG_BUFFER,buflen+1); // larger buffer
buflen=BASS_GetConfig(BASS_CONFIG_BUFFER);
printf("using a %dms buffer\t\t\r",buflen);
stream=BASS_StreamCreate(info.freq,2,0,(STREAMPROC*)WriteStream,0);
// set effects on the new stream
for (r=0;r<9;r++) if (fx[r]) fx[r]=BASS_ChannelSetFX(stream,BASS_FX_DX8_CHORUS+r,0);
BASS_ChannelPlay(stream,FALSE);
}
if (keyin.Event.KeyEvent.wVirtualKeyCode>=VK_F1
&& keyin.Event.KeyEvent.wVirtualKeyCode<=VK_F9) {
r=keyin.Event.KeyEvent.wVirtualKeyCode-VK_F1;
if (fx[r]) {
BASS_ChannelRemoveFX(stream,fx[r]);
fx[r]=0;
printf("effect %s = OFF\t\t\r",fxname[r]);
} else {
// set the effect, not bothering with parameters (use defaults)
if (fx[r]=BASS_ChannelSetFX(stream,BASS_FX_DX8_CHORUS+r,0))
printf("effect %s = ON\t\t\r",fxname[r]);
}
}
}
for (key=0;key<KEYS;key++)
if (keyin.Event.KeyEvent.wVirtualKeyCode==keys[key]) {
if (keyin.Event.KeyEvent.bKeyDown && vol[key]<MAXVOL) {
pos[key]=0;
vol[key]=MAXVOL+DECAY/2; // start key (setting "vol" slightly higher than MAXVOL to cover any rounding-down)
} else if (!keyin.Event.KeyEvent.bKeyDown && vol[key])
vol[key]-=DECAY; // trigger key fadeout
break;
}
}
BASS_Free();
}
