/**
* A track has ended. Remove it from the playlist.
*
* Called from the main loop when the music_delivery() callback has set g_playback_done.
*/
static void track_ended(void)
{
fprintf(stderr,"jahspotify::track_ended: called\n");
int tracks = 0;
if (g_currenttrack)
{
sp_link *link = sp_link_create_from_track(g_currenttrack,0);
char *trackLinkStr = NULL;
if (link)
{
trackLinkStr = malloc ( sizeof ( char ) * ( 100 ) );
sp_link_as_string(link,trackLinkStr,100);
sp_link_release(link);
}
sp_session_player_unload(g_sess);
sp_track_release(g_currenttrack);
g_currenttrack = NULL;
signalTrackEnded(trackLinkStr,JNI_FALSE);
if (trackLinkStr)
{
free(trackLinkStr);
}
}
}
void Session::Unload( Track* pTrack )
{
if (pTrack && (pTrack == m_pTrack) )
{
sp_session_player_unload( m_pSession );
m_pTrack = NULL;
}
}
static void on_end_of_track(sp_session *session)
{
debug("callback: on_end_of_track");
audio_fifo_flush(&g_audiofifo);
sp_session_player_play(session, 0);
sp_session_player_unload(session);
printf("Done.\n\n");
g_playing = 0;
}
/**
* Notification that some other connection has started playing on this account.
* Playback has been stopped.
*
* @sa sp_session_callbacks#play_token_lost
*/
static void play_token_lost(sp_session *sess)
{
audio_fifo_flush(&g_audiofifo);
if (g_currenttrack != NULL) {
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
}
/*---- Session Callbacks end ----*/
static void track_ended(void) {
int tracks = 0;
if(g_currenttrack) {
g_currenttrack = NULL;
sp_session_player_unload(g_sess);
pop_queue();
try_playback_start();
}
}
/**
* Notification that some other connection has started playing on this account.
* Playback has been stopped.
*
* @sa sp_session_callbacks#play_token_lost
*/
static void play_token_lost ( sp_session *sess )
{
fprintf ( stderr, "jahspotify: play token lost\n" );
if ( g_currenttrack != NULL )
{
sp_session_player_unload ( g_sess );
g_currenttrack = NULL;
}
}
/**
* Notification that some other connection has started playing on this account.
* Playback has been stopped.
*
* @sa sp_session_callbacks#play_token_lost
*/
static void SP_CALLCONV play_token_lost(sp_session *sess)
{
audio_flush();
if (g_currenttrack != NULL) {
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
}
/**
* A track has ended. Remove it from the playlist.
*
* Called from the main loop when the music_delivery() callback has set g_playback_done.
*/
static void track_ended(void)
{
if (g_currenttrack) {
sp_track_release(g_currenttrack);
g_currenttrack = NULL;
sp_session_player_unload(g_sess);
exit(0);
}
}
void Spotify::tryLoadTrack()
{
sp_error err;
if (nextTrack == 0) {
return;
}
if (currentTrack == nextTrack) {
return;
}
err = sp_track_error(nextTrack);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Spotify: track error: %s\n",
sp_error_message(err));
return;
}
err = sp_session_player_unload(sp);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to unload player: 0x%02X %s\n",
(unsigned)err, sp_error_message(err));
return;
}
if (audioThread.isRunning()) {
audioThread.quit();
}
err = sp_session_player_load(sp, nextTrack);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to load URI (%s): 0x%02X %s\n",
currentURI.toLocal8Bit().constData(),
(unsigned)err, sp_error_message(err));
return;
}
err = sp_session_player_play(sp, true);
if (err != SP_ERROR_OK) {
fprintf(stderr, "Failed to play URI (%s): %s\n",
currentURI.toLocal8Bit().constData(),
sp_error_message(err));
return;
}
if (currentTrack) {
sp_track_release(currentTrack);
}
currentTrack = nextTrack;
emit songLoaded(currentURI);
}
void
SpotifyPlayback::endTrack()
{
qDebug() << QThread::currentThreadId() << "And stopping track";
if( !m_iodev.isNull() ) {
qDebug() << "Stopping track and closign iodev! from thread with other:" << QThread::currentThreadId() << "and iodev:" << m_iodev->thread()->currentThreadId();
m_iodev->close();
m_iodev.clear();
sp_session_player_unload(SpotifySession::getInstance()->Session());
}
m_trackEnded = true;
}
Spotify::Error Spotify::Session::stop()
{
Spotify::Error error;
if( m_playing )
{
error = sp_session_player_play( m_session, false );
if( !error.isError() )
{
sp_session_player_unload( m_session );
m_playing = false;
}
}
return error;
}
/**
* Callback from libspotify. Something renamed the playlist.
*
* @param pl The playlist handle
* @param userdata The opaque pointer
*/
static void playlist_renamed(sp_playlist *pl, void *userdata)
{
const char *name = sp_playlist_name(pl);
if (!strcasecmp(name, g_listname)) {
g_jukeboxlist = pl;
g_track_index = 0;
try_jukebox_start();
} else if (g_jukeboxlist == pl) {
printf("jukebox: current playlist renamed to \"%s\".\n", name);
g_jukeboxlist = NULL;
g_currenttrack = NULL;
sp_session_player_unload(g_sess);
}
}
/**
* A track has ended. Remove it from the playlist.
*
* Called from the main loop when the music_delivery() callback has set g_playback_done.
*/
static void track_ended(void)
{
int tracks = 0;
if (g_currenttrack) {
g_currenttrack = NULL;
sp_session_player_unload(g_sess);
if (g_remove_tracks) {
sp_playlist_remove_tracks(g_jukeboxlist, &tracks, 1);
} else {
++g_track_index;
try_jukebox_start();
}
}
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::_stopTrack( )
{
if ( m_current_track != NULL ) {
sp_session_player_unload( m_spotify_session );
m_audio_out->cancel();
m_current_track = NULL;
m_current_track_link.Empty();
m_track_state = TRACK_ENDED;
m_track_length_ms = m_track_seek_ms = 0L;
m_track_timer.stop( );
removeTrackAnalyzer();
}
}
Spotify::Error Spotify::Session::play( Spotify::Track* track )
{
m_playing = false;
m_currentTrack = track;
Spotify::Error error;
// Clean up
audio_fifo_flush(&m_audiofifo);
sp_session_player_unload( m_session );
// Disregard tracks that are not available:
if( !track->isAvailable() )
{
qDebug() << "ERROR: Asked to play back a unavailable track..";
return Spotify::Error( SP_ERROR_TRACK_NOT_PLAYABLE );
}
// Load track:
error = load( track );
if( error.isError() )
{
qDebug() << "ERROR: Could not load track: " << error.toString();
return error;
}
// Disregard unloaded og unavailable tracks:
if( !track->isLoaded() )
{
qDebug() << "ERROR: Asked to play back a unloaded track..";
return Spotify::Error( SP_ERROR_RESOURCE_NOT_LOADED );
}
// Play track:
error = sp_session_player_play( m_session, true );
if( !error.isError() )
{
m_trackPos = 0;
m_playing = true;
}
else
{
qDebug() << "ERROR: Could not play track: " << error.toString();
return error;
}
return Spotify::Error( SP_ERROR_OK );
}
void QSpotifySession::play(std::shared_ptr<QSpotifyTrack> track, bool restart)
{
qDebug() << "QSpotifySession::play";
if (track->error() != QSpotifyTrack::Ok || !track->isAvailable() || (m_currentTrack == track && !restart))
return;
if (m_currentTrack) {
if (m_trackChangedAutomatically) {
// We're done decoding the track, but we might not be done playing it
m_previousTrackRemaining = m_currentTrack->duration() - m_currentTrackPosition;
} else {
m_previousTrackRemaining = 0;
}
sp_session_player_unload(m_sp_session);
m_isPlaying = false;
m_currentTrack.reset();
m_currentTrackPosition = 0;
m_currentTrackPlayedDuration = 0;
// Only discard buffers if the track change was initialized manually
// since we will otherwise potentially discard the end of the just played track
if (!m_trackChangedAutomatically) {
QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(ResetBufferEventType)));
}
} else {
m_previousTrackRemaining = 0;
}
m_trackChangedAutomatically = false;
if (!track->seen())
track->setSeen(true);
sp_error error = sp_session_player_load(m_sp_session, track->m_sp_track);
if (error != SP_ERROR_OK) {
fprintf(stderr, "failed to load track: %s\n",
sp_error_message(error));
return;
}
m_currentTrack = track;
m_currentTrackPosition = 0;
m_currentTrackPlayedDuration = 0;
emit currentTrackChanged();
emit currentTrackPositionChanged();
beginPlayBack();
}
bool Codec::unloadPlayer() {
//make sure there is no music_delivery while we are removing the codec
while (!Session::getInstance()->lock()) {
}
if (m_isPlayerLoaded) {
sp_session_player_play(getSession(), false);
sp_session_player_unload(getSession());
if (m_currentTrack != NULL) {
sp_track_release(m_currentTrack);
}
}
m_currentTrack = NULL;
m_isPlayerLoaded = false;
m_endOfTrack = true;
Session::getInstance()->unlock();
return true;
}
void session_unload() {
session_callback_data scbd;
g_debug("Unloading track.");
/* First call callbacks */
scbd.type = SPOP_SESSION_UNLOAD;
scbd.data = NULL;
g_list_foreach(g_session_callbacks, session_call_callback, &scbd);
/* Then really unload */
sp_session_player_play(g_session, FALSE);
g_audio_delivery_func(NULL, NULL, 0);
sp_session_player_unload(g_session);
cb_notify_main_thread(NULL);
g_audio_samples = 0;
g_audio_time = 0;
}
void end_of_track( sp_session *session )
{
TRACE_2( PLAYERMANAGER , "end_of_track().");
TRACE_3( PLAYERMANAGER , "End of track...");
// LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
TRACE_3( PLAYERMANAGER , "Removing the track which have been played.");
sp_track_release( currentTrack );
// UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
// if( hasNextTrack() == TRUE )
// {
// TRACE_1( PLAYERMANAGER , "Load next music !");
// playMusic( session , "" , currentStreamName );
// }
if( nextTrackInStream( currentStreamName ) == PC_SUCCESS )
{
TRACE_1( PLAYERMANAGER , "Load next music !");
}
else
{
TRACE_WARNING( PLAYERMANAGER , "No more music in the mainplaylist");
audio_fifo_flush( &g_audiofifo );
LOCK_MUTEX( PLAYERMANAGER , &mutexSession );
sp_session_player_play( session , 0 );
sp_session_player_unload( session );
UNLOCK_MUTEX( PLAYERMANAGER , &mutexSession );
playing = FALSE;
}
}
// Loads track if metadata exists, otherwise load the metadata
static void load_track_or_metadata(sp_session *session, sp_track *track, const char *uri) {
if (track != NULL) {
if (s_is_playing)
sp_session_player_play(session, false);
sp_session_player_unload(session);
sp_track_release(track);
}
track = sp_link_as_track(sp_link_create_from_string(uri));
set_track(track);
sp_track_add_ref(track);
s_player_position = 0;
s_current_uri = uri;
// either the track is already cached and can be used or we need to wait for the metadata callback
if (sp_track_is_loaded(track))
load_and_play_track(session, track);
else
s_is_waiting_for_metadata = true;
}
// Stop playback.
void sess_stop()
{
if (g_session.state != SESS_ONLINE || !g_session.current_track || !sp_track_is_loaded(g_session.current_track))
return;
sp_session_player_unload(g_session.spotify);
g_session.current_track = NULL;
g_session.playing = false;
g_session.paused = false;
audio_clear_position();
log_append("Stopped");
// Redraw track info.
ui_dirty(UI_TRACKINFO);
ui_update_post(0);
}
/**
* Called on various events to start playback if it hasn't been started already.
*
* The function simply starts playing the first track of the playlist.
*/
static void try_jukebox_start(void)
{
sp_track *t;
if (!g_jukeboxlist)
return;
if (!sp_playlist_num_tracks(g_jukeboxlist)) {
fprintf(stderr, "jukebox: No tracks in playlist. Waiting\n");
return;
}
if (sp_playlist_num_tracks(g_jukeboxlist) < g_track_index) {
fprintf(stderr, "jukebox: No more tracks in playlist. Waiting\n");
return;
}
t = sp_playlist_track(g_jukeboxlist, g_track_index);
if (g_currenttrack && t != g_currenttrack) {
/* Someone changed the current track */
audio_fifo_flush(&g_audiofifo);
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
if (!t)
return;
if (sp_track_error(t) != SP_ERROR_OK)
return;
if (g_currenttrack == t)
return;
g_currenttrack = t;
printf("jukebox: Now playing \"%s\"...\n", sp_track_name(t));
fflush(stdout);
sp_session_player_load(g_sess, t);
sp_session_player_play(g_sess, 1);
}
static void try_playback_start(void) {
sp_track *t;
if(amtSongs() == 0) {
fprintf(stderr, "Playlist: No tracks in playlist. Waiting\n");
return;
}
t = sp_link_as_track(firstSong->song);
if(g_currenttrack && t != g_currenttrack) {
audio_fifo_flush(&g_audiofifo);
sp_session_player_unload(g_sess);
g_currenttrack = NULL;
}
if(!t) {
printf("Null Song\n");
fflush(stdout);
return;
}
int next_timeout = 0;
sp_session_process_events(g_sess, &next_timeout);
while(sp_track_error(t) != SP_ERROR_OK) {
sp_session_process_events(g_sess, &next_timeout);
printf("Loading Track...\n");
usleep(100000);
}
if(sp_track_error(t) != SP_ERROR_OK) {
printf("SP_ERRoR\n");
printf("%i\n", sp_track_error(t));
fflush(stdout);
return;
}
if(g_currenttrack == t) {
printf("Coninuting same track\n");
fflush(stdout);
return;
}
g_currenttrack = t;
printf("Partyfy: Now playing \"%s\"...\n", sp_track_name(t));
fflush(stdout);
sp_session_player_load(g_sess, t);
sp_session_player_play(g_sess, 1);
}
void QSpotifySession::stop(bool dontEmitSignals)
{
qDebug() << "QSpotifySession::stop";
if (!m_isPlaying && !m_currentTrack)
return;
sp_session_player_unload(m_sp_session);
m_isPlaying = false;
m_currentTrack.reset();
m_currentTrackPosition = 0;
m_currentTrackPlayedDuration = 0;
if (!dontEmitSignals) {
emit isPlayingChanged();
emit currentTrackChanged();
emit currentTrackPositionChanged();
}
QCoreApplication::postEvent(g_audioWorker, new QEvent(QEvent::Type(AudioStopEventType)));
}
static int spfs_open(const char *path, struct fuse_file_info *fi)
{
file_t *file = find_file(path + 1);
if(!file)
return -ENOENT;
if(!track_ended)
sp_session_player_unload(session);
printf("Spotify: Loading %s by %s\n", sp_track_name(file->track), sp_artist_name(sp_track_artist(file->track, 0)));
sp_session_player_load(session, file->track);
sp_session_player_play(session, 1);
write_wav_header(frame_buf);
frame_buf_size = 44;
track_ended = 0;
return 0;
}
/**
* A track has ended. Remove it from the playlist.
*
* Called from the main loop when the music_delivery() callback has set g_playback_done.
*/
static void track_ended(bool startNext) {
printf("track_ended startNext=%d\n", startNext);
int tracks = 0;
if (g_currenttrack) {
printf("track_ended: stopping current track.\n");
g_currenttrack = NULL;
sp_session_player_unload(g_sess);
g_is_playing = 0;
}
audio_fifo_flush(&g_musicfifo);
notify_main_thread(g_sess);
audio_fifo_flush(&g_musicfifo);
usleep(50000);
if (startNext) {
printf("track_ended: play next track.\n");
try_jukebox_start();
usleep(50000);
notify_main_thread(g_sess);
banner_track();
}
}
static PyObject *
Session_unload(PyObject *self)
{
sp_session_player_unload(Session_SP_SESSION(self));
Py_RETURN_NONE;
}
void Spotify::run()
{
int next_timeout = 0;
sp = spotify_ll_init(Spotify_Wrapper::sessionCallbacks());
if (!sp) {
return;
}
bool running = true;
while (running) {
SpotifyEvent_t ev = EVENT_NO_EVENT;
// Get next event (or timeout)
if (next_timeout == 0) {
eq.get(ev);
} else {
if (!eq.get(ev, next_timeout)) {
// Timed out
ev = EVENT_TIMEOUT;
}
}
switch (ev) {
case EVENT_SPOTIFY_MAIN_TICK:
case EVENT_TIMEOUT:
break;
case EVENT_LOGIN_CREDENTIALS_CHANGED:
if (pass.isEmpty()) {
// Try using credential blob
sp_session_login(sp,
user.toLocal8Bit().constData(),
NULL,
false,
blob.constData());
}
else {
sp_session_login(sp,
user.toLocal8Bit().constData(),
pass.toLocal8Bit().constData(),
false,
NULL);
}
break;
case EVENT_LOGGED_IN:
emit loggedIn();
break;
case EVENT_PLAYLIST_CONTAINER_LOADED:
compileNewListOfPlaylists();
break;
case EVENT_LOGGED_OUT:
emit loggedOut();
break;
case EVENT_URI_CHANGED:
changeCurrentlyPlayingSong();
break;
case EVENT_PLAYLIST_IDX_CHANGED:
changeCurrentPlaylist();
break;
case EVENT_METADATA_UPDATED:
tryLoadTrack();
break;
case EVENT_START_PLAYBACK:
if (!audioThread.isRunning()) {
fprintf(stderr, "Spotify: Starting audio worker\n");
SpotifyAudioWorker * audioWorker = new SpotifyAudioWorker(this);
audioWorker->moveToThread(&audioThread);
connect(&audioThread, SIGNAL(started()),
audioWorker, SLOT(startStreaming()));
connect(&audioThread, SIGNAL(finished()),
audioWorker, SLOT(stopStreaming()));
connect(&audioThread, SIGNAL(finished()),
audioWorker, SLOT(deleteLater()));
connect(audioWorker, SIGNAL(streamingFailed()),
this, SIGNAL(audioStreamingFailed()));
audioThread.start();
}
break;
case EVENT_STOP_PLAYBACK:
if (audioThread.isRunning()) {
audioThread.quit();
audioThread.wait();
}
accessMutex.lock();
audioBuffer.close();
readPos = 0;
writePos = 0;
accessMutex.unlock();
break;
case EVENT_END_OF_TRACK:
sp_session_player_unload(sp);
sp_track_release(currentTrack);
currentURI.clear();
nextTrack = 0;
currentTrack = 0;
break;
default:
qDebug() << "Unknown event:" << (int)ev;
break;
}
do {
sp_session_process_events(sp, &next_timeout);
} while (next_timeout == 0);
}
}
/**
* Notification that some other connection has started playing on this account.
* Playback has been stopped.
*
* @sa sp_session_callbacks#play_token_lost
*/
static void play_token_lost(sp_session *sess)
{
sp_session_player_unload(sess);
}
static PyObject *
Session_unload(Session * self)
{
sp_session_player_unload(self->_session);
Py_RETURN_NONE;
}
