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);
notify_main_thread(g_session);
queue_go_next(g_session);
}
/**
* 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;
}
}
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;
}
/**
* 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();
}
}
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 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;
}
}
/**
* 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);
}
static gboolean
rbspotifysrc_start (GstBaseSrc *bsrc)
{
RBSpotifySrc *src = RBSPOTIFYSRC (bsrc);
// sp_error err;
sp_link* link;
audio_fifo_t *af = &g_audio_fifo;
// sp_track* track;
// int timeout;
fprintf(stderr, "Playing %s\n", src->uri);
link = sp_link_create_from_string(src->uri);
if (!link)
{
fprintf(stderr, "Couldn't open file");
return FALSE;
}
src->track = sp_link_as_track(link);
if (!src->track)
{
fprintf(stderr, "Couldn't turn link to track %s", src->uri);
return FALSE;
}
sp_track_add_ref(src->track);
sp_link_release(link);
src->tloaded = FALSE;
src->played = 0;
src->curoffset = 0;
audio_fifo_flush(af);
return TRUE;
}
