HSTREAM LoadFile(const musik::Core::String& filename)
{
WmaDecoder* decoder = new WmaDecoder(filename.c_str());
HSTREAM stream = NULL;
if (decoder->CanPlay())
{
stream = BASS_StreamCreate(
decoder->GetSampleRate(),
decoder->GetChannels(),
BASS_STREAM_AUTOFREE,
WMA_Decode_Proc,
NULL);
}
if (stream == NULL)
{
delete decoder;
}
else
{
CriticalSection cs(::g_Mutex);
::g_DecoderMap[stream] = decoder;
}
return stream;
}
BASS_AudioInterface::BASS_AudioInterface(TheoraVideoClip* owner,int nChannels,int freq) :
TheoraAudioInterface(owner,nChannels,freq), TheoraTimer(), mTempBuffer(0)
{
mStream = BASS_StreamCreate(freq, nChannels, BASS_SAMPLE_FLOAT, STREAMPROC_PUSH, this);
mMaxBuffSize=freq*mNumChannels*2;
mTempBuffer = new float[mMaxBuffSize];
owner->setTimer(this);
}
AudioClip::AudioClip(unsigned char *data)
{
pan = 0.0f;
volume = 1.0f;
pitch = 0.0f;
loop = false;
play_once = false;
oshot = false;
hm = BASS_StreamCreate(44100, 2, BASS_STREAM_DECODE, 0, (void*)data);
hm = BASS_FX_TempoCreate(hm, BASS_FX_FREESOURCE);
}
static BOOL Initialize()
{
BASS_INFO bi;
// initialize output, get latency
if (!BASS_Init(-1,44100,BASS_DEVICE_LATENCY,win,NULL)) {
Error("Can't initialize output");
return FALSE;
}
BASS_GetInfo(&bi);
if (bi.dsver<8) { // no DX8, so disable effect buttons
EnableWindow(GetDlgItem(win,20),FALSE);
EnableWindow(GetDlgItem(win,21),FALSE);
EnableWindow(GetDlgItem(win,22),FALSE);
EnableWindow(GetDlgItem(win,23),FALSE);
}
// create a stream to play the recording
chan=BASS_StreamCreate(44100,2,0,STREAMPROC_PUSH,0);
// start recording with 10ms period
if (!BASS_RecordInit(-1) || !(rchan=BASS_RecordStart(44100,2,MAKELONG(0,10),RecordingCallback,0))) {
BASS_RecordFree();
BASS_Free();
Error("Can't initialize recording");
return FALSE;
}
{ // get list of inputs
int c;
const char *i;
for (c=0;i=BASS_RecordGetInputName(c);c++) {
float level;
MESS(10,CB_ADDSTRING,0,i);
if (!(BASS_RecordGetInput(c,&level)&BASS_INPUT_OFF)) { // this 1 is currently "on"
input=c;
MESS(10,CB_SETCURSEL,input,0);
MESS(11,TBM_SETPOS,TRUE,level*100); // set level slider
}
}
}
{ // prebuffer at least "minbuf" amount of data before starting playback
DWORD prebuf=BASS_ChannelSeconds2Bytes(chan,bi.minbuf/1000.f);
while (BASS_ChannelGetData(chan,NULL,BASS_DATA_AVAILABLE)<prebuf)
Sleep(1);
}
BASS_ChannelPlay(chan,FALSE);
return TRUE;
}
HFX CALLBACK SetCustFX (DWORD chan, DWORD type, int priority) {
if (type!=CUST_FX_TYPE_ID) return NULL;
BASS_CHANNELINFO info;
BASS_ChannelGetInfo(chan, &info);
HCustFX* hc = malloc(sizeof(HCustFX));
if (!hc) return NULL;
hc->flags = info.flags&( BASS_SAMPLE_FLOAT | BASS_SAMPLE_8BITS );
hc->push = BASS_StreamCreate(info.freq, info.chans, hc->flags | BASS_STREAM_DECODE, STREAMPROC_PUSH, NULL);
hc->pitch = BASS_FX_TempoCreate(hc->push, BASS_STREAM_DECODE);
HFX hfx = bassfunc->SetFX(chan, CustFXDSPProc, hc, priority, &CustFXFuncs);
if (hfx&&hc->pitch&&hc->push) return hfx;
if (hfx) BASS_ChannelRemoveFX(chan, hfx);
if (hc->pitch) BASS_StreamFree(hc->pitch);
if (hc->push) BASS_StreamFree(hc->push);
free(hc);
return NULL;
}
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);
//
}
//
// Util use in BeginLoadingMedia
//
HSTREAM CBassAudio::ConvertFileToMono(const SString& strPath)
{
HSTREAM decoder = BASS_StreamCreateFile ( false, strPath, 0, 0, BASS_STREAM_DECODE | BASS_SAMPLE_MONO ); // open file for decoding
if ( !decoder )
return 0; // failed
DWORD length = static_cast <DWORD> ( BASS_ChannelGetLength ( decoder, BASS_POS_BYTE ) ); // get the length
void *data = malloc ( length ); // allocate buffer for decoded data
BASS_CHANNELINFO ci;
BASS_ChannelGetInfo ( decoder, &ci ); // get sample format
if ( ci.chans > 1 ) // not mono, downmix...
{
HSTREAM mixer = BASS_Mixer_StreamCreate ( ci.freq, 1, BASS_STREAM_DECODE | BASS_MIXER_END ); // create mono mixer
BASS_Mixer_StreamAddChannel ( mixer, decoder, BASS_MIXER_DOWNMIX | BASS_MIXER_NORAMPIN | BASS_STREAM_AUTOFREE ); // plug-in the decoder (auto-free with the mixer)
decoder = mixer; // decode from the mixer
}
length = BASS_ChannelGetData ( decoder, data, length ); // decode data
BASS_StreamFree ( decoder ); // free the decoder/mixer
HSTREAM stream = BASS_StreamCreate ( ci.freq, 1, BASS_STREAM_AUTOFREE, STREAMPROC_PUSH, NULL ); // create stream
BASS_StreamPutData ( stream, data, length ); // set the stream data
free ( data ); // free the buffer
return stream;
}
int main(int argc, char* argv[])
{
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;
}
// initialize GUI
glade=glade_xml_new(GLADE_PATH"synth.glade",NULL,NULL);
if (!glade) return 0;
win=GetWidget("window1");
if (!win) return 0;
glade_xml_signal_autoconnect(glade);
BASS_GetInfo(&info);
stream=BASS_StreamCreate(info.freq,2,BASS_SAMPLE_FLOAT,(STREAMPROC*)WriteStream,0); // create a stream (stereo for effects)
BASS_ChannelSetAttribute(stream,BASS_ATTRIB_NOBUFFER,1); // no buffering for minimum latency
BASS_ChannelPlay(stream,FALSE); // start it
g_signal_connect(win,"key-press-event",G_CALLBACK(KeyHandler),NULL);
g_signal_connect(win,"key-release-event",G_CALLBACK(KeyHandler),NULL);
gtk_main();
BASS_Free();
return 0;
}
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;
}
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();
}
BOOL CALLBACK dialogproc(HWND h,UINT m,WPARAM w,LPARAM l)
{
switch (m) {
case WM_COMMAND:
switch (LOWORD(w)) {
case IDCANCEL:
DestroyWindow(h);
return 1;
case 10:
{
char file[MAX_PATH]="";
ofn.lpstrFilter="playable files\0*.mo3;*.xm;*.mod;*.s3m;*.it;*.mtm;*.mp3;*.mp2;*.mp1;*.ogg;*.wav\0All files\0*.*\0\0";
ofn.lpstrFile=file;
if (GetOpenFileName(&ofn)) {
memcpy(path,file,ofn.nFileOffset);
path[ofn.nFileOffset-1]=0;
// 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,floatable?BASS_SAMPLE_FLOAT:0))
&& !(chan=BASS_MusicLoad(FALSE,file,0,0,BASS_MUSIC_LOOP|BASS_MUSIC_RAMP|(floatable?BASS_MUSIC_FLOAT:0)))) {
// 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;
}
if (BASS_ChannelGetFlags(chan)&BASS_SAMPLE_MONO) {
// mono = not allowed
MESS(10,WM_SETTEXT,0,"click here to open a file...");
BASS_MusicFree(chan);
BASS_StreamFree(chan);
Error("mono sources are not supported");
break;
}
MESS(10,WM_SETTEXT,0,file);
// setup DSPs on new channel
SendMessage(win,WM_COMMAND,11,0);
SendMessage(win,WM_COMMAND,12,0);
SendMessage(win,WM_COMMAND,13,0);
// play both MOD and stream, it must be one of them!
BASS_MusicPlay(chan);
BASS_StreamPlay(chan,0,BASS_SAMPLE_LOOP);
}
}
return 1;
case 11: // toggle "rotate"
if (MESS(11,BM_GETCHECK,0,0)) {
rotpos=0.7853981f;
rotdsp=BASS_ChannelSetDSP(chan,&Rotate,0);
} 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);
} 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);
} else
BASS_ChannelRemoveDSP(chan,fladsp);
break;
}
break;
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.lpstrInitialDir=path;
ofn.Flags=OFN_HIDEREADONLY|OFN_EXPLORER;
// initialize - default device, 44100hz, stereo, 16 bits, floating-point DSP
if (!BASS_Init(-1,44100,BASS_DEVICE_FLOATDSP,win)) {
Error("Can't initialize device");
DestroyWindow(win);
return 1;
}
BASS_Start();
// check for floating-point capability
floatable=BASS_StreamCreate(44100,BASS_SAMPLE_FLOAT,NULL,0);
if (floatable) BASS_StreamFree(floatable); // woohoo!
return 1;
}
return 0;
}
void Player::start(int sampleRate) {
_output = BASS_StreamCreate(sampleRate, 1, 0, STREAMPROC_PUSH, 0);
setVolume(0);
//setPaused(false);
BASS_ChannelPlay(_output, TRUE);
}
void Player::start(int sampleRate) {
_output = BASS_StreamCreate(sampleRate, 1, 0, STREAMPROC_PUSH, 0);
setVolume(0);
setPaused(false);
_pos = 0;
}
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();
}
// Load a record onto the record player
void Crecord_playerApp::load_record(int a_index)
{
// Verify valid input
if (a_index < 0 || a_index >= NUM_RECORDS) return;
if (stream) { BASS_ChannelStop(stream); Sleep(100); }
int restart_haptics = 0;
if (haptics_enabled) {
restart_haptics = 1;
toggle_haptics();
}
pos = 0;
LoadAudioFile(g_audio_files[a_index]);
stream=BASS_StreamCreate(info.freq,info.chans,0,&MyStreamWriter,0);
// delete existing record
if (m_recordMesh) { world->removeChild(m_recordMesh); delete m_recordMesh; }
// create new record
m_recordMesh = new cMesh(world);
createTexCoords(m_recordMesh, 0.33);
cTexture2D *record = new cTexture2D();
bool result = record->loadFromFile(g_flag_files[a_index]);
m_recordMesh->setTexture(record);
m_recordMesh->useTexture(true, true);
// Compute object size
m_recordMesh->computeBoundaryBox(true);
// Build a collision-detector for this object, so
// the proxy will work nicely when haptics are enabled.
m_recordMesh->createAABBCollisionDetector(true, true);
// set size of frame
m_recordMesh->setFrameSize(0.3, 1.0, true);
// update global position
m_recordMesh->computeGlobalPositions();
// add object to world and translate
world->addChild(m_recordMesh);
m_recordMesh->translate(-0.1, 0, -0.21);
// set stiffness
double stiffness = (double)35;
if (m_recordMesh)
m_recordMesh->setStiffness(stiffness, true);
// set static and dynamic friction
double staticFriction = (double)100 / 100.0;
double dynamicFriction = (double)100 / 100.0;
if (m_recordMesh)
m_recordMesh->setFriction(staticFriction, dynamicFriction, true);
m_rotVel = 0.0;
if (restart_haptics) toggle_haptics();
}
void main(int argc, char **argv)
{
BUFSTUFF b,b2;
BASS_3DVECTOR p={0,0,0};
printf("BASS 2 stereo channels on 4 speakers example : MOD/MPx/OGG/WAV\n"
"--------------------------------------------------------------\n"
" Set your soundcard's output to 4 or 5.1 speakers\n");
/* check that BASS 1.6 was loaded */
if (BASS_GetVersion()!=MAKELONG(1,6)) {
printf("BASS version 1.6 was not loaded\n");
return;
}
if (argc!=3) {
printf("\tusage: 4speaker <file1> <file2>\n");
return;
}
/* setup output - default device, 44100hz, stereo, 16 bits */
if (!BASS_Init(-1,44100,BASS_DEVICE_3D,0))
Error("Can't initialize device");
/* try initializing the 1st (front) file */
if (!(b.dstr=BASS_StreamCreateFile(FALSE,argv[1],0,0,BASS_STREAM_DECODE)))
if (!(b.dstr=BASS_MusicLoad(FALSE,argv[1],0,0,BASS_MUSIC_DECODE|BASS_MUSIC_RAMPS)))
Error("Can't play the 1st file");
if (BASS_ChannelGetFlags(b.dstr)&BASS_SAMPLE_MONO)
Error("The 1st stream is mono!");
/* try initializing the 2nd (rear) file */
if (!(b2.dstr=BASS_StreamCreateFile(FALSE,argv[2],0,0,BASS_STREAM_DECODE)))
if (!(b2.dstr=BASS_MusicLoad(FALSE,argv[2],0,0,BASS_MUSIC_DECODE|BASS_MUSIC_RAMPS)))
Error("Can't play the 2nd file");
if (BASS_ChannelGetFlags(b2.dstr)&BASS_SAMPLE_MONO)
Error("The 2nd stream is mono!");
printf("front : %s\n",argv[1]);
printf("rear : %s\n",argv[2]);
/* Get sample rates and allocate buffers */
BASS_ChannelGetAttributes(b.dstr,&b.freq,0,0);
b.buf=malloc(b.freq*4); // 1 sec buffer
BASS_ChannelGetAttributes(b2.dstr,&b2.freq,0,0);
b2.buf=malloc(b2.freq*4); // 1 sec buffer
/* Create streams to play the 1st decoded data, and link them */
b.lstr=BASS_StreamCreate(b.freq,BASS_SAMPLE_MONO|BASS_SAMPLE_3D,(STREAMPROC*)&stream_left,(DWORD)&b);
b.rstr=BASS_StreamCreate(b.freq,BASS_SAMPLE_MONO|BASS_SAMPLE_3D,(STREAMPROC*)&stream_right,(DWORD)&b);
BASS_ChannelSetLink(b.lstr,b.rstr);
/* Create streams to play the 2nd decoded data, and link them */
b2.lstr=BASS_StreamCreate(b2.freq,BASS_SAMPLE_MONO|BASS_SAMPLE_3D,(STREAMPROC*)&stream_left,(DWORD)&b2);
b2.rstr=BASS_StreamCreate(b2.freq,BASS_SAMPLE_MONO|BASS_SAMPLE_3D,(STREAMPROC*)&stream_right,(DWORD)&b2);
BASS_ChannelSetLink(b2.lstr,b2.rstr);
/* position the streams */
p.z=3; // front
p.x=-1.5; // left
BASS_ChannelSet3DPosition(b.lstr,&p,0,0);
p.x=1.5; // right
BASS_ChannelSet3DPosition(b.rstr,&p,0,0);
p.z=-3; // rear
p.x=-1.5; // left
BASS_ChannelSet3DPosition(b2.lstr,&p,0,0);
p.x=1.5; // right
BASS_ChannelSet3DPosition(b2.rstr,&p,0,0);
BASS_Apply3D();
BASS_Start();
/* start it! */
b.writepos=b.readposl=b.readposr=0;
BASS_StreamPlay(b.lstr,FALSE,0); // start front
b2.writepos=b2.readposl=b2.readposr=0;
BASS_StreamPlay(b2.lstr,FALSE,0); // start rear
while (!_kbhit() && (BASS_ChannelIsActive(b.lstr) || BASS_ChannelIsActive(b2.lstr))) {
/* display some stuff and wait a bit */
printf("pos %09I64d %09I64d - cpu %.1f%% \r",
BASS_ChannelGetPosition(b.lstr)*2,BASS_ChannelGetPosition(b2.lstr)*2,BASS_GetCPU());
Sleep(50);
}
BASS_Free();
free(b.buf);
}
