void *OpenURL(char *url)
{
DWORD c,r;
pthread_mutex_lock(&lock); // make sure only 1 thread at a time can do the following
r=++req; // increment the request counter for this request
pthread_mutex_unlock(&lock);
RemoveEventLoopTimer(prebuftimer); // stop prebuffer monitoring
BASS_StreamFree(chan); // close old stream
PostCustomEvent('open',0,0);
c=BASS_StreamCreateURL(url,0,BASS_STREAM_BLOCK|BASS_STREAM_STATUS|BASS_STREAM_AUTOFREE,StatusProc,0);
free(url); // free temp URL buffer
pthread_mutex_lock(&lock);
if (r!=req) { // there is a newer request, discard this stream
pthread_mutex_unlock(&lock);
if (c) BASS_StreamFree(c);
return;
}
chan=c; // this is now the current stream
pthread_mutex_unlock(&lock);
if (!chan) {
PostCustomEvent('end ',0,0);
// Error("Can't play the stream");
} else
InstallEventLoopTimer(GetMainEventLoop(),kEventDurationNoWait,kEventDurationSecond/20,NewEventLoopTimerUPP(PrebufTimerProc),0,&prebuftimer); // start prebuffer monitoring
return NULL;
}
void CBassAudio::PlayStreamIntern ( void* arguments )
{
CBassAudio* pBassAudio = LockCallbackId( arguments );
if ( pBassAudio )
{
pBassAudio->m_pVars->criticalSection.Lock ();
SString strURL = pBassAudio->m_pVars->strURL;
long lFlags = pBassAudio->m_pVars->lFlags;
pBassAudio->m_pVars->criticalSection.Unlock ();
UnlockCallbackId();
// This can take a while
HSTREAM pSound = BASS_StreamCreateURL ( strURL, 0, lFlags, NULL, NULL );
CBassAudio* pBassAudio = LockCallbackId( arguments );
if ( pBassAudio )
{
pBassAudio->m_pVars->criticalSection.Lock ();
pBassAudio->m_pVars->bStreamCreateResult = true;
pBassAudio->m_pVars->pSound = pSound;
pBassAudio->m_pVars->criticalSection.Unlock ();
}
else
{
// Deal with unwanted pSound
g_pClientGame->GetManager()->GetSoundManager()->QueueChannelStop( pSound );
}
}
UnlockCallbackId();
}
void MainWindow::radioOpenURLThread(string url) {
radioStatus_currentMetadata = "";
KillTimer(window, bufferTimerId);
KillTimer(window, metaTimerId);
if (currentStream != 0) {
BASS_ChannelStop(currentStream);
BASS_StreamFree(currentStream);
}
radioStatus = INETR_RS_Connecting;
updateStatusLabel();
HSTREAM tempStream = BASS_StreamCreateURL(url.c_str(), 0, 0, nullptr,
0);
if (currentStreamURL != url || radioStatus != INETR_RS_Connecting) {
BASS_StreamFree(tempStream);
return;
}
currentStream = tempStream;
if (currentStream != 0) {
SetTimer(window, bufferTimerId, 50, nullptr);
} else {
radioStatus = INETR_RS_ConnectionError;
updateStatusLabel();
}
}
void *OpenURL(char *url)
{
DWORD c,r;
g_static_mutex_lock(&lock); // make sure only 1 thread at a time can do the following
r=++req; // increment the request counter for this request
g_static_mutex_unlock(&lock);
if (prebuftimer) {
g_source_remove(prebuftimer); // stop prebuffer monitoring
prebuftimer=0;
}
BASS_StreamFree(chan); // close old stream
gdk_threads_enter();
gtk_label_set_text(GTK_LABEL(GetWidget("status1")),"");
gtk_label_set_text(GTK_LABEL(GetWidget("status2")),"connecting...");
gtk_label_set_text(GTK_LABEL(GetWidget("status3")),"");
gdk_threads_leave();
c=BASS_StreamCreateURL(url,0,BASS_STREAM_BLOCK|BASS_STREAM_STATUS|BASS_STREAM_AUTOFREE,StatusProc,0);
free(url); // free temp URL buffer
g_static_mutex_lock(&lock);
if (r!=req) { // there is a newer request, discard this stream
g_static_mutex_unlock(&lock);
if (c) BASS_StreamFree(c);
return NULL;
}
chan=c; // this is now the current stream
g_static_mutex_unlock(&lock);
if (!chan) {
gdk_threads_enter();
gtk_label_set_text(GTK_LABEL(GetWidget("status2")),"not playing");
Error("Can't play the stream");
gdk_threads_leave();
} else
prebuftimer=g_timeout_add(50,PrebufTimerProc,NULL); // start prebuffer monitoring
return NULL;
}
void CClientSound::PlayStreamIntern ( void* arguments )
{
thestruct* pArgs = static_cast <thestruct*> ( arguments );
// Try to load the sound file
HSTREAM pSound = BASS_StreamCreateURL ( pArgs->strURL, 0, pArgs->lFlags, NULL, NULL );
pArgs->pClientSound->ThreadCallback( pSound );
delete arguments;
}
void Player::play(QString stationId) {
stop();
if( !playList.contains(stationId))
{
return;
}
HSTREAM stream = BASS_StreamCreateURL(playList.value(stationId).toStdString().c_str(),0,BASS_STREAM_BLOCK|BASS_STREAM_STATUS|BASS_STREAM_AUTOFREE,MyDownload,0);
BASS_Start();
if( stream)
{
bool buffering = true;
while(buffering)
{
QWORD progress = BASS_StreamGetFilePosition(stream,BASS_FILEPOS_BUFFER)*100/BASS_StreamGetFilePosition(stream,BASS_FILEPOS_END);
webView()->page()->mainFrame()->evaluateJavaScript(QString("PlayerHud.updateBufforStatus("+ QString::number(progress) +")"));
if( progress>=100)
{
buffering = false;
webView()->page()->mainFrame()->evaluateJavaScript("PlayerHud.clearBufforStatus()");
}
}
const char *meta=BASS_ChannelGetTags(stream,BASS_TAG_META);
if( !meta)
{
meta = BASS_ChannelGetTags(stream,BASS_TAG_OGG);
}
if( meta)
{
qDebug() << meta;
QRegularExpression rx("StreamTitle='(.+)';StreamUrl");
QRegularExpressionMatch match = rx.match(QString(meta));
if (match.hasMatch()) {
qDebug() << match.captured(1);
webView()->page()->mainFrame()->evaluateJavaScript("setRadiostationTag('"+ match.captured(1) +"')");
}
}
BASS_ChannelPlay(stream,FALSE);
playStatus = true;
}
else
{
qDebug() << BASS_ErrorGetCode();
return;
}
return;
}
static void __cdecl openUrl(char* url) {
if (chan != NULL) {
BASS_StreamFree(chan);
}
chan = BASS_StreamCreateURL(url, 0, BASS_STREAM_BLOCK|BASS_STREAM_STATUS|BASS_STREAM_AUTOFREE, statusProc, 0);
free(url);
if (!chan) {
// TODO: tell the user failed to open stream
} else {
}
cthread = 0;
}
void InitAudio(const char *pFilename)
{
DWORD chan,act,time,level;
QWORD pos;
printf("--- MIDISYS-ENGINE: InitAudio()\n");
if (!BASS_Init(-1,44100,0,0,NULL)) BassError("InitAudio() - can't initialize device");
printf("\tInitAudio() - loading soundtrack from file \"%s\"\n", pFilename);
int success = 0;
if ((chan=BASS_StreamCreateFile(FALSE,pFilename,0,0,BASS_STREAM_PRESCAN))
|| (chan=BASS_StreamCreateURL(pFilename,0,BASS_STREAM_PRESCAN,0,0))) {
pos=BASS_ChannelGetLength(chan,BASS_POS_BYTE);
if (BASS_StreamGetFilePosition(chan,BASS_FILEPOS_DOWNLOAD)!=-1) {
// streaming from the internet
if (pos!=-1)
{
printf("\tInitAudio() - streaming internet file [%I64u bytes]\n",pos);
success = 1;
}
else
{
printf("\tstreaming internet file\n");
success = 1;
}
} else
{
printf("\tstreaming file [%I64u bytes]\n",pos);
success = 1;
}
}
if (success == 1)
{
music_channel = chan;
}
else
{
printf("InitAudio() error! could not load file.");
exit(1);
}
}
bool CAudio::Load()
{
if(m_dwChannel == 0)
{
// Create BASS stream
if(m_bIsOnlineStream)
m_dwChannel = BASS_StreamCreateURL(m_strStreamName, 0, (BASS_STREAM_BLOCK | BASS_STREAM_STATUS | BASS_STREAM_AUTOFREE), 0, 0);
else
m_dwChannel = BASS_StreamCreateFile(FALSE, m_strStreamName, 0, 0, BASS_STREAM_PRESCAN);
// stream create check
if(m_dwChannel != 0)
{
BASS_ChannelSetAttribute(m_dwChannel, BASS_ATTRIB_VOL, (m_fVolume * 0.01f));
return true;
}
}
return false;
}
void main(int argc, char **argv)
{
DWORD chan,act,time,level;
BOOL ismod;
QWORD pos;
int a;
printf("Simple console mode BASS example : MOD/MPx/OGG/WAV player\n"
"---------------------------------------------------------\n");
// check the correct BASS was loaded
if (HIWORD(BASS_GetVersion())!=BASSVERSION) {
printf("An incorrect version of BASS was loaded");
return;
}
if (argc!=2) {
printf("\tusage: contest <file>\n");
return;
}
// setup output - default device
if (!BASS_Init(-1,44100,0,0,NULL))
Error("Can't initialize device");
// try streaming the file/url
if ((chan=BASS_StreamCreateFile(FALSE,argv[1],0,0,BASS_SAMPLE_LOOP))
|| (chan=BASS_StreamCreateURL(argv[1],0,BASS_SAMPLE_LOOP,0,0))) {
pos=BASS_ChannelGetLength(chan,BASS_POS_BYTE);
if (BASS_StreamGetFilePosition(chan,BASS_FILEPOS_DOWNLOAD)!=-1) {
// streaming from the internet
if (pos!=-1)
#ifdef _WIN32
printf("streaming internet file [%I64u bytes]",pos);
#else
printf("streaming internet file [%llu bytes]",pos);
#endif
else
printf("streaming internet file");
} else
bool CAudio::Load()
{
// Are we not already loaded?
if(m_dwChannel == 0)
{
// Create our BASS stream
if(m_bIsOnlineStream)
m_dwChannel = BASS_StreamCreateURL(m_strStreamName, 0, (BASS_STREAM_BLOCK | BASS_STREAM_STATUS | BASS_STREAM_AUTOFREE), 0, 0);
else
m_dwChannel = BASS_StreamCreateFile(FALSE, m_strStreamName, 0, 0, 0);
// Did our stream create successfully?
if(m_dwChannel != 0)
{
BASS_ChannelSetAttribute(m_dwChannel, BASS_ATTRIB_VOL, (m_fVolume * 0.01f));
return true;
}
}
// Already loaded
return false;
}
bool BassDecoder::_open(const string_t& filename)
{
_mod=false;
#if defined(LIBTOOLS_WINDOWS) && !defined(BASS_H)
if (BASS_MusicLoad &&
BASS_StreamCreateFile &&
BASS_StreamCreateURL &&
BASS_ChannelGetInfo)
{
#endif
//std::wcerr << "Try loading: " << filename.toWideString() << std::endl;
bass_unicode_string_t bass_unicode_str=string_t_to_bass_unicode_string_t(filename);
void* unicode_filename=(void*)bass_unicode_str.c_str();
if (_music=BASS_MusicLoad(FALSE,
unicode_filename, 0,0,
BASS_MUSIC_PRESCAN |
BASS_MUSIC_DECODE |
BASS_SAMPLE_FLOAT |
BASS_UNICODE,
Signal::frequency))
{
_mod=true;
}
else if (_music=BASS_StreamCreateFile(FALSE,
unicode_filename, 0,0,
BASS_STREAM_PRESCAN |
BASS_STREAM_DECODE |
BASS_SAMPLE_FLOAT |
BASS_UNICODE));
else if (_music=BASS_StreamCreateURL((const char *)unicode_filename,0,
BASS_STREAM_DECODE |
BASS_SAMPLE_FLOAT |
BASS_UNICODE,
(DOWNLOADPROC*) 0,
(void*)0));
if (_music)
{
BASS_ChannelGetInfo((DWORD)_music,&_infos);
_bytesFrame= sizeof(float)*Signal::size*_infos.chans;
_samplesForSignals = (float*) realloc(_samplesForSignals,_bytesFrame);
_sampleRate=_infos.freq;
if (_sampleRate != Signal::frequency)
{
#ifndef NDEBUG
std::cout << "warning : file rate (" << _sampleRate << "Hz) is different of " << Signal::frequency << "Hz" << std::endl;
#endif
}
_ended=false;
if (prepareDecode()) {
decodeID3v1();
decodeOGGTag();
}
}
#if defined(LIBTOOLS_WINDOWS) && !defined(BASS_H)
} else {
#ifndef NDEBUG
std::cerr << "Error missing bass fonctions in DLL " << std::endl;
#endif
}
#endif
return (_music);
}
HSTREAM bmx_bass_streamcreateurl( char *url, DWORD offset, DWORD flags, void *user) {
return BASS_StreamCreateURL(url, offset, flags, &bmx_bass_dlstreamcallback, user);
}
HSTREAM bmx_bass_streamcreateurlncb( char *url, DWORD offset, DWORD flags, void *user) {
return BASS_StreamCreateURL(url, offset, flags, NULL, user);
}
