static int try_play(sp_session *session, sp_track *t,int offset)
{
sp_error err;
fprintf(stderr,"try play\n");
err = sp_session_player_load(session,t);
if( err != SP_ERROR_OK) {
fprintf(stderr,"Load failed %d\n",err);
}
if(!sp_track_is_loaded(t)) {
if(g_track_to_be_played != t) {
if(g_track_to_be_played)
sp_track_release(g_track_to_be_played);
g_track_to_be_played = t; //FIXME: Do I need to addref?
sp_track_add_ref(g_track_to_be_played);
}
} else {
//FIXME: Seek!
// g_current_fifo_idx = (g_current_fifo_idx+1) % 2;
sp_session_player_seek(session,offset);
sp_session_player_play(session,true);
sp_album *album = sp_track_album(t);
if(album) {
const byte *id = sp_album_cover(album);
g_gazify.current_t = t;
if(id) {
sp_image *img = sp_image_create(session,id);
sp_image_add_load_callback(img,&image_loaded,&g_gazify);
}
}
g_track_to_be_played = NULL;
}
return err;
}
static void
Track_dealloc(Track * self)
{
if (self->_track)
sp_track_release(self->_track);
self->ob_type->tp_free(self);
}
/**
* 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);
}
}
}
static void
queue_free_list (queue_t *queue)
{
sp_track *track;
while ((track = queue_get_next (queue)))
sp_track_release (track);
}
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack ( JNIEnv *env, jobject obj, jstring uri)
{
jobject trackInstance;
uint8_t *nativeUri = NULL;
nativeUri = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
sp_link *link = sp_link_create_from_string(nativeUri);
if (!link)
{
// hmm
fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack: Could not create link!\n" );
return JNI_FALSE;
}
sp_track *track = sp_link_as_track(link);
while (!sp_track_is_loaded(track))
{
fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrieveTrack: Waiting for track to be loaded ...\n" );
sleep(1);
}
trackInstance = createJTrackInstance(env, track);
if (track)
sp_track_release(track);
if (link)
sp_link_release(link);
if (nativeUri)
free(nativeUri);
return trackInstance;
}
void queue_remove_tracks(gboolean notif, int idx, int nb) {
int len;
int i;
g_debug("Removing %d tracks from queue, starting at %d.", nb, idx);
if ((idx < 0) || (nb < 0))
return;
len = g_queue_get_length(&g_queue);
if (idx < len) {
if (idx + nb >= len)
nb = len - idx;
for (i=0; i < nb; i++)
sp_track_release(g_queue_pop_nth(&g_queue, idx));
/* Was the current track removed too? */
if (g_current_track >= idx) {
if (g_current_track < idx+nb) {
queue_stop(FALSE);
g_current_track = -1;
}
else
g_current_track -= nb;
}
}
if (g_shuffle) queue_setup_shuffle();
g_shuffle_first = g_current_track;
if (notif) queue_notify();
}
SpotifySong::~SpotifySong()
{
boost::lock_guard<boost::mutex> lock(this->spotify->spotifyApiMutex);
sp_track_release(this->track);
if(this->artist != nullptr)
sp_artist_release(this->artist);
if(this->album != nullptr)
sp_album_release(this->album);
}
/**
* 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 TLSpotify::TTrack::ReleaseTrack()
{
if( m_pTrack )
{
sp_track_release( m_pTrack );
m_pTrack = NULL;
m_Loaded = SyncWait;
UpdateInfo();
}
}
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 queue_add_track(gboolean notif, sp_track* track) {
sp_track_add_ref(track);
if (!sp_track_is_loaded(track)) {
sp_track_release(track);
g_debug("Track not loaded.");
return;
}
if (!track_available(track)) {
sp_track_release(track);
g_debug("Track is not available.");
return;
}
g_debug("Adding track %p to queue.", track);
g_queue_push_tail(&g_queue, track);
if (g_shuffle) queue_setup_shuffle();
g_shuffle_first = g_current_track;
if (notif) queue_notify();
}
/* Restore state */
static gboolean really_restore_state(gpointer data) {
saved_state* s = (saved_state*) data;
sp_track* tr;
/* Check if all tracks are loaded */
size_t i;
for (i=0; i < s->tracks->len; i++) {
tr = g_array_index(s->tracks, sp_track*, i);
if (!sp_track_is_loaded(tr))
return TRUE;
}
/* All tracks are loaded: restore them */
g_debug("savestate: restoring saved state...");
queue_clear(FALSE);
for (i=0; i < s->tracks->len; i++) {
tr = g_array_index(s->tracks, sp_track*, i);
if (track_available(tr))
queue_add_track(FALSE, tr);
else {
g_info("savestate: track %zu is no longer available", i);
if (s->cur_track == i) {
s->cur_track = -1;
s->qs = STOPPED;
}
else if (s->cur_track > i)
s->cur_track -= 1;
}
sp_track_release(tr);
}
queue_set_repeat(FALSE, s->repeat);
queue_set_shuffle(FALSE, s->shuffle);
if (s->cur_track >= 0)
queue_goto(FALSE, s->cur_track, TRUE);
if (s->qs == PLAYING)
queue_play(FALSE);
/* Done! */
queue_notify();
g_array_free(s->tracks, TRUE);
g_free(s);
g_debug("savestate: state restored!");
return FALSE;
}
/************************
*** Queue management ***
************************/
void queue_set_track(gboolean notif, sp_track* track) {
sp_track_add_ref(track);
if (!sp_track_is_loaded(track)) {
sp_track_release(track);
g_debug("Track not loaded.");
return;
}
if (!track_available(track)) {
sp_track_release(track);
g_debug("Track is not available.");
return;
}
g_debug("Setting track %p as queue.", track);
queue_clear(FALSE);
g_queue_push_tail(&g_queue, track);
if (g_shuffle) queue_setup_shuffle();
g_shuffle_first = -1;
if (notif) queue_notify();
}
SP_LIBEXPORT(void) sp_artistbrowse_release(sp_artistbrowse *arb) {
int i;
assert(arb->ref_count > 0);
arb->ref_count--;
if(arb->ref_count)
return;
if(arb->artist) {
DSFYDEBUG("Unreferencing artist at %p\n", arb->artist);
sp_artist_release(arb->artist);
}
for(i = 0; i < arb->num_tracks; i++)
sp_track_release(arb->tracks[i]);
if(arb->num_tracks)
free(arb->tracks);
for(i = 0; i < arb->num_portraits; i++)
free(arb->portraits[i]);
if(arb->num_portraits)
free(arb->portraits);
for(i = 0; i < arb->num_similar_artists; i++)
sp_artist_release(arb->similar_artists[i]);
if(arb->num_similar_artists)
free(arb->similar_artists);
for(i = 0; i < arb->num_albums; i++)
sp_album_release(arb->albums[i]);
if(arb->num_albums)
free(arb->albums);
DSFYDEBUG("Deallocating artistbrowse at %p\n", arb);
free(arb);
}
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 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;
}
}
static void track_browse_try(void)
{
switch (sp_track_error(track_browse)) {
case SP_ERROR_OK:
print_track(track_browse);
break;
case SP_ERROR_IS_LOADING:
return; // Still pending
default:
fprintf(stderr, "Unable to resolve track: %s\n", sp_error_message(sp_track_error(track_browse)));
break;
}
metadata_updated_fn = NULL;
cmd_done();
sp_track_release(track_browse);
}
// 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;
}
SP_LIBEXPORT(void) sp_search_release(sp_search *search) {
int i;
assert(search->ref_count > 0);
search->ref_count--;
if(search->ref_count)
return;
free(search->query);
for(i = 0; i < search->num_albums; i++)
sp_album_release(search->albums[i]);
if(search->num_albums)
free(search->albums);
for(i = 0; i < search->num_artists; i++)
sp_artist_release(search->artists[i]);
if(search->num_artists)
free(search->artists);
for(i = 0; i < search->num_tracks; i++)
sp_track_release(search->tracks[i]);
if(search->num_tracks)
free(search->tracks);
if(search->did_you_mean)
free(search->did_you_mean);
free(search);
}
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);
}
}
void track_get_data(sp_track* track, gchar** name, gchar** artist, gchar** album, gchar** link,
guint* duration, int* popularity) {
sp_artist** art = NULL;
sp_album* alb = NULL;
sp_link* lnk;
int i;
int nb_art = 0;
const char* s;
sp_track_add_ref(track);
if (!sp_track_is_loaded(track)) {
sp_track_release(track);
return;
}
/* Begin loading everything */
if (name) {
*name = g_strdup(sp_track_name(track));
}
if (artist) {
nb_art = sp_track_num_artists(track);
art = (sp_artist**) malloc(nb_art * sizeof(sp_artist*));
if (!art)
g_error("Can't allocate memory.");
for (i=0; i < nb_art; i++) {
art[i] = sp_track_artist(track, i);
sp_artist_add_ref(art[i]);
}
}
if (album) {
alb = sp_track_album(track);
sp_album_add_ref(alb);
}
if (link) {
GString* tmp;
lnk = sp_link_create_from_track(track, 0);
if (!lnk)
g_error("Can't get URI from track.");
tmp = g_string_sized_new(1024);
if (sp_link_as_string(lnk, tmp->str, 1024) < 0)
g_error("Can't render URI from link.");
*link = tmp->str;
g_string_free(tmp, FALSE);
sp_link_release(lnk);
}
if (duration) {
*duration = sp_track_duration(track);
}
if (popularity) {
*popularity = sp_track_popularity(track);
}
/* Now create destination strings */
if (artist) {
GString* tmp = g_string_new("");
for (i=0; i < nb_art; i++) {
if (sp_artist_is_loaded(art[i]))
s = sp_artist_name(art[i]);
else
s = "[artist not loaded]";
if (i != 0)
g_string_append(tmp, ", ");
g_string_append(tmp, s);
sp_artist_release(art[i]);
}
*artist = tmp->str;
g_string_free(tmp, FALSE);
}
if (album) {
if (sp_album_is_loaded(alb))
*album = g_strdup(sp_album_name(alb));
else
*album = g_strdup("[album not loaded]");
sp_album_release(alb);
}
sp_track_release(track);
}
SxTrack::~SxTrack() {
if (m_thumb) ThumbStore::getInstance()->removeThumb(m_thumb);
delete m_uri;
sp_track_release(m_spTrack);
}
static void discard_track_tokens(struct track_tokens_t *src) {
for (int i = 0; i < src->num_tracks; i++)
sp_track_release(src->tracks[i]);
}
/************************************************************
*** Callback functions, to be called from a foreach loop ***
************************************************************/
void cb_queue_track_release(gpointer data, gpointer user_data) {
sp_track_release((sp_track*) data);
}
jobject createJPlaylist(JNIEnv *env, sp_playlist *playlist)
{
jclass jClass;
jobject playlistInstance;
jmethodID jMethod;
jClass = (*env)->FindClass(env, "jahspotify/media/Playlist");
if (jClass == NULL)
{
fprintf(stderr,"jahspotify::createJPlaylist: could not load jahnotify.media.Playlist\n");
return NULL;
}
playlistInstance = (*env)->AllocObject(env,jClass);
if (!playlistInstance)
{
fprintf(stderr,"jahspotify::createJPlaylist: could not create instance of jahspotify.media.Playlistt\n");
return NULL;
}
sp_link *playlistLink = sp_link_create_from_playlist(playlist);
if (playlistLink)
{
jobject playlistJLink = createJLinkInstance(env,playlistLink);
setObjectObjectField(env,playlistInstance,"id","Ljahspotify/media/Link;",playlistJLink);
sp_link_release(playlistLink);
}
setObjectStringField(env,playlistInstance,"name",sp_playlist_name(playlist));
sp_user *owner = sp_playlist_owner(playlist);
if (owner)
{
setObjectStringField(env,playlistInstance,"author",sp_user_display_name(owner));
sp_user_release(owner);
}
// Lookup the method now - saves us looking it up for each iteration of the loop
jMethod = (*env)->GetMethodID(env,jClass,"addTrack","(Ljahspotify/media/Link;)V");
if (jMethod == NULL)
{
fprintf(stderr,"jahspotify::createJPlaylist: could not load method addTrack(track) on class Playlist\n");
return NULL;
}
int numTracks = sp_playlist_num_tracks(playlist);
int trackCounter = 0;
for (trackCounter = 0 ; trackCounter < numTracks; trackCounter++)
{
sp_track *track = sp_playlist_track(playlist,trackCounter);
if (track)
{
sp_track_add_ref(track);
sp_link *trackLink = sp_link_create_from_track(track, 0);
if (trackLink)
{
sp_link_add_ref(trackLink);
jobject trackJLink = createJLinkInstance(env,trackLink);
// Add it to the playlist
(*env)->CallVoidMethod(env,playlistInstance,jMethod,trackJLink);
sp_link_release(trackLink);
}
sp_track_release(track);
}
}
return playlistInstance;
}
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_playTrack (JNIEnv *env, jobject obj, jstring uri)
{
uint8_t *nativeURI = NULL;
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Initiating play\n");
nativeURI = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: uri: %s\n", nativeURI);
if (!g_audio_initialized)
{
audio_init(&g_audiofifo);
g_audio_initialized = JNI_TRUE;
}
// For each track, read out the info and populate all of the info in the Track instance
sp_link *link = sp_link_create_from_string(nativeURI);
if (link)
{
sp_track *t = sp_link_as_track(link);
if (!t)
{
fprintf(stderr,"No track from link\n");
return;
}
while (!sp_track_is_available(g_sess,t))
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Waiting for track ...\n");
sleep(1);
}
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Error with track: %s\n",sp_error_message(sp_track_error(t)));
return;
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: name: %s duration: %d\n",sp_track_name(t),sp_track_duration(t));
if (g_currenttrack == t)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Same track!\n");
return;
}
// If there is one playing, unload that now
if (g_currenttrack && t != g_currenttrack)
{
// audio_fifo_flush(&g_audiofifo);
// Unload the current track now
sp_session_player_unload(g_sess);
sp_link *currentTrackLink = sp_link_create_from_track(g_currenttrack,0);
char *currentTrackLinkStr = NULL;
if (currentTrackLink)
{
currentTrackLinkStr = malloc ( sizeof ( char ) * ( 100 ) );
sp_link_as_string(currentTrackLink,currentTrackLinkStr,100);
sp_link_release(currentTrackLink);
}
signalTrackEnded(currentTrackLinkStr, JNI_TRUE);
if (currentTrackLinkStr)
{
free(currentTrackLinkStr);
}
sp_track_release(g_currenttrack);
g_currenttrack = NULL;
}
else
{
// audio_fifo_flush(&g_audiofifo);
// audio_close();
// audio_init(&g_audiofifo);
}
sp_track_add_ref(t);
sp_error result = sp_session_player_load(g_sess, t);
if (sp_track_error(t) != SP_ERROR_OK)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Issue loading track: %s\n", sp_error_message((sp_track_error(t))));
}
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Track loaded: %s\n", (result == SP_ERROR_OK ? "yes" : "no"));
// Update the global reference
g_currenttrack = t;
// Start playing the next track
sp_session_player_play(g_sess, 1);
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Playing track\n");
sp_link_release(link);
signalTrackStarted(nativeURI);
return 0;
}
else
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_play: Unable to load link at this point\n");
}
return 1;
}
void Track::Unload()
{
sp_track_release( m_pTrack );
m_pTrack = NULL;
}
Track::~Track()
{
if(this->isValid())
sp_track_release(m_spTrack);
}
