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;
}
static void playlist_browse_try(void)
{
int i, tracks;
metadata_updated_fn = playlist_browse_try;
if(!sp_playlist_is_loaded(playlist_browse))
return;
tracks = sp_playlist_num_tracks(playlist_browse);
for(i = 0; i < tracks; i++) {
sp_track *t = sp_playlist_track(playlist_browse, i);
if (!sp_track_is_loaded(t))
return;
}
printf("\tPlaylist and metadata loaded\n");
for(i = 0; i < tracks; i++) {
sp_track *t = sp_playlist_track(playlist_browse, i);
printf(" %5d: ", i + 1);
print_track(t);
}
sp_playlist_remove_callbacks(playlist_browse, &pl_callbacks, NULL);
sp_playlist_release(playlist_browse);
playlist_browse = NULL;
metadata_updated_fn = NULL;
cmd_done();
}
// Start playback.
void sess_play(sp_track *t)
{
if (g_session.state != SESS_ONLINE) {
log_append("Not connected");
return;
}
if (!t || !sp_track_is_available(t) || !sp_track_is_loaded(t)) {
log_append("Track not available");
return;
}
sess_stop();
g_session.current_track = t;
log_append("Playing \"%s\"...", sp_track_name(t));
sp_error err = sp_session_player_load(g_session.spotify, t);
if (err != SP_ERROR_OK)
panic("sp_session_player_load() failed: %s", sp_error_message(err));
err = sp_session_player_play(g_session.spotify, true);
if (err != SP_ERROR_OK)
panic("sp_session_player_play() failed: %s", sp_error_message(err));
g_session.playing = true;
// Redraw track info and progress.
ui_dirty(UI_TRACKINFO);
ui_dirty(UI_TRACKPROGRESS);
ui_update_post(0);
}
PHP_METHOD(Spotify, getTrackByURI)
{
zval *uri, temp, *object = getThis();
int timeout = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) {
return;
}
spotify_object *p = (spotify_object*)zend_object_store_get_object(object TSRMLS_CC);
sp_link *link = sp_link_create_from_string(Z_STRVAL_P(uri));
if (NULL == link) {
RETURN_FALSE;
}
if (SP_LINKTYPE_TRACK != sp_link_type(link)) {
RETURN_FALSE;
}
sp_track *track = sp_link_as_track(link);
while (!sp_track_is_loaded(track)) {
sp_session_process_events(p->session, &timeout);
}
object_init_ex(return_value, spotifytrack_ce);
SPOTIFY_METHOD2(SpotifyTrack, __construct, &temp, return_value, object, track);
sp_link_release(link);
}
bool Track::IsLoading( bool recursive )
{
if (!sp_track_is_loaded(m_pTrack))
return true;
return false;
}
bool Codec::loadPlayer() {
Logger::printOut("load player");
if (!m_isPlayerLoaded) {
//do we have a track at all?
if (m_currentTrack) {
CStdString name;
Logger::printOut("load player 2");
if (sp_track_is_loaded(m_currentTrack)) {
sp_error error = sp_session_player_load(getSession(), m_currentTrack);
CStdString message;
Logger::printOut("load player 3");
message.Format("%s", sp_error_message(error));
Logger::printOut(message);
Logger::printOut("load player 4");
if (SP_ERROR_OK == error) {
sp_session_player_play(getSession(), true);
m_isPlayerLoaded = true;
Logger::printOut("load player 5");
return true;
}
}
} else
return false;
}
return true;
}
void queue_set_playlist(gboolean notif, sp_playlist* pl) {
GArray* tracks;
sp_track* track;
int i;
g_debug("Setting playlist %p as queue.", pl);
tracks = tracks_get_playlist(pl);
if (!tracks) {
g_info("Playlist not loaded.");
return;
}
queue_clear(FALSE);
for (i=0; i < tracks->len; i++) {
track = g_array_index(tracks, sp_track*, i);
if (sp_track_is_loaded(track) && track_available(track))
g_queue_push_tail(&g_queue, track);
}
g_array_free(tracks, TRUE);
if (g_shuffle) queue_setup_shuffle();
g_shuffle_first = -1;
if (notif) queue_notify();
}
SP_LIBEXPORT(sp_error) sp_session_player_load(sp_session *session, sp_track *track) {
void **container;
if(session == NULL || track == NULL) {
return SP_ERROR_INVALID_INDATA;
}
else if(!sp_track_is_loaded(track)) {
return SP_ERROR_RESOURCE_NOT_LOADED;
}
else if(!sp_track_is_available(track)) {
return SP_ERROR_TRACK_NOT_PLAYABLE;
}
/* Unload any previously loaded track */
player_push(session, PLAYER_UNLOAD, NULL, 0);
/* The track will released in player.c when PLAYER_UNLOAD is called */
container = malloc(sizeof(sp_track *));
*container = track;
sp_track_add_ref(track);
player_push(session, PLAYER_LOAD, container, sizeof(sp_track *));
return SP_ERROR_OK;
}
bool SpotifySong::updateMetadata()
{
if(sp_track_is_loaded(this->track))
{
this->duration = sp_track_duration(this->track);
this->title = sp_track_name(this->track);
if(this->artist == nullptr)
{
this->artist = sp_track_artist(this->track,0);
sp_artist_add_ref(this->artist);
}
if(this->album == nullptr)
{
this->album = sp_track_album(this->track);
sp_album_add_ref(this->album);
}
} else
return false;
if(this->artist != nullptr && sp_artist_is_loaded(this->artist))
this->artistName = sp_artist_name(this->artist);
else
return false;
if(this->album != nullptr && sp_album_is_loaded(this->album))
this->albumName = sp_album_name(this->album);
else
return false;
return true;
}
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;
}
void AudioHTTPServer::checkForLoaded()
{
qDebug() << "Checking...";
if( !sp_track_is_loaded( m_savedTrack ) ) {
qWarning() << QThread::currentThreadId() << "uh oh... track not loaded yet! Asked for:" << sp_track_name( m_savedTrack );
QTimer::singleShot( 250, this, SLOT( checkForLoaded() ) );
} else {
startStreamingResponse( m_savedEvent, m_savedTrack );
}
}
/* 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;
}
SxTrack::SxTrack(sp_track *spTrack) {
// Logger::printOut("creating track");
// Logger::printOut(sp_track_name(spSxTrack));
while (!sp_track_is_loaded(spTrack))
;
//Logger::printOut("creating track loaded");
m_references = 1;
m_spTrack = spTrack;
m_name = sp_track_name(spTrack);
m_rating = ceil((float)sp_track_popularity(spTrack) / 10);
m_duration = 0.001 * sp_track_duration(spTrack);
m_trackNumber = sp_track_index(spTrack);
m_albumName = "";
m_albumArtistName = "";
m_year = 0;
m_thumb = NULL;
m_hasTHumb = false;
//load the album and release it when we have harvested all data we need
sp_album * album = sp_track_album(spTrack);
if (sp_album_is_loaded(album)) {
SxAlbum* sAlbum = AlbumStore::getInstance()->getAlbum(sp_track_album(spTrack), false);
m_thumb = sAlbum->getThumb();
m_albumName = sAlbum->getAlbumName();
m_albumArtistName = sAlbum->getAlbumArtistName();
m_year = sAlbum->getAlbumYear();
//release it again
AlbumStore::getInstance()->removeAlbum(sAlbum);
if (m_thumb != NULL) {
m_thumb->addRef();
m_hasTHumb = true;
}
} else
Logger::printOut("no album loaded for track");
m_artistName = sp_artist_name(sp_track_artist(spTrack, 0));
sp_link *link = sp_link_create_from_track(spTrack, 0);
m_uri = new char[256];
sp_link_as_string(link, m_uri, 256);
sp_link_release(link);
}
void
SpotifySearch::addSearchedTrack( sp_search *result, void *userdata)
{
qDebug() << Q_FUNC_INFO;
sp_playlist *playlist = reinterpret_cast<sp_playlist*>(userdata);
if(!sp_playlist_is_loaded( playlist ) )
{
qDebug() << "Search Playlist is not loaded";
return;
}
// Need to pass a ** to add_tracks
sp_track **tracks = static_cast<sp_track **>(malloc(sizeof(sp_track*)));
if( sp_search_num_tracks( result ) > 0 )
{
int num = qMin( sp_search_num_tracks( result ), 1 );
for( int i = 0; i < num; i++ )
{
sp_track *const tr = sp_search_track( result, i );
if( !tr || !sp_track_is_loaded( tr ) ) {
qDebug() << "Got still loading track, skipping";
continue;
}
qDebug() << "Adding track to playlist" << sp_track_name( tr );
*(tracks++) = tr;
sp_error err = sp_playlist_add_tracks(playlist, tracks, 1, sp_playlist_num_tracks( playlist ), SpotifySession::getInstance()->Session());
switch(err) {
case SP_ERROR_OK:
qDebug() << "Added tracks to pos" << sp_playlist_num_tracks( playlist )-1;
break;
case SP_ERROR_INVALID_INDATA:
qDebug() << "Invalid position";
break;
case SP_ERROR_PERMISSION_DENIED:
qDebug() << "Access denied";
break;
default:
qDebug() << "Other error (should not happen)";
break;
}
}
}
delete []tracks;
}
json_t *track_to_json(sp_track *track, json_t *object) {
char uri[kTrackLinkLength];
sp_link *link = sp_link_create_from_track(track, 0);
sp_link_as_string(link, uri, kTrackLinkLength);
sp_link_release(link);
json_object_set_new(object, "uri", json_string_nocheck(uri));
if (!sp_track_is_loaded(track))
return object;
const char *name = sp_track_name(track);
json_object_set_new(object, "title", json_string_nocheck(name));
return object;
}
// 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);
}
Spotify::Error Spotify::Session::pause()
{
Spotify::Error error;
// Is playing:
if( m_playing )
{
error = sp_session_player_play( m_session, false );
if( !error.isError() )
m_playing = false;
}
// Is paused:
else if( !m_playing && m_currentTrack->trackPointer() && sp_track_is_loaded( m_currentTrack->trackPointer() ) )
{
error = sp_session_player_play( m_session, true );
if( !error.isError() )
m_playing = true;
}
return error;
}
// 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;
}
void search_for_tracks_at(sp_session *session, char *buf, size_t len, size_t i, bool (*f)(sp_track *))
{
if(search == NULL)
{
return;
}
buf[0] = '\0';
if(search_is_track(i) && sp_track_is_loaded(sp_search_track(search, i)))
{
f(sp_search_track(search, i));
if(buf != NULL)
{
track_to_str(buf, len, sp_search_track(search, i));
}
}
if(search_is_album(i) && sp_album_is_loaded(sp_search_album(search, i-sp_search_num_tracks(search))))
{
sp_albumbrowse_create(session, sp_search_album(search, i-sp_search_num_tracks(search))
,on_albumbrowse_complete, f);
if(buf != NULL)
{
album_to_str(buf, len, sp_search_album(search, i-sp_search_num_tracks(search)));
}
}
if(search_is_playlist(i))
{
sp_playlist *pl = sp_search_playlist(search,
i-sp_search_num_tracks(search)-sp_search_num_albums(search));
if(sp_playlist_is_loaded(pl))
{
int j;
for(j = 0; j < sp_playlist_num_tracks(pl); ++j)
{
f(sp_playlist_track(pl, j));
}
if(buf != NULL)
{
playlist_to_str(buf, len, pl);
}
}
}
}
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();
}
void AudioHTTPServer::sid( QxtWebRequestEvent* event, QString a )
{
qDebug() << QThread::currentThreadId() << "HTTP" << event->url.toString() << a;
if( !SpotifySession::getInstance()->Playback()->trackIsOver() ) {
SpotifySession::getInstance()->Playback()->endTrack();
}
// the requested track
QString uid = a.replace( ".wav", "");
// qDebug() << QThread::currentThreadId() << "Beginning to stream requested track:" << uid;
if( uid.isEmpty() || !sApp->hasLinkFromTrack( uid ) ) {
qWarning() << "Did not find spotify track UID in our list!" << uid;
sendErrorResponse( event );
return;
}
// get the sp_track
sp_link* link = sApp->linkFromTrack( uid );
sp_track* track = sp_link_as_track( link );
if( !track ) {
qWarning() << QThread::currentThreadId() << "Uh oh... got null track from link :(" << sp_link_type( link );
sendErrorResponse( event );
return;
}
if( !sp_track_is_loaded( track ) ) {
qWarning() << QThread::currentThreadId() << "uh oh... track not loaded yet! Asked for:" << sp_track_name( track );
m_savedEvent = event;
m_savedTrack = track;
QTimer::singleShot( 250, this, SLOT( checkForLoaded() ) );
return;
} else {
startStreamingResponse( event, track );
}
}
void SpotifyGuiController::RefreshPlaylistTracks ( sp_playlist *plist )
{
if ( plist && plist != selected_playlist )
{
if ( trackTree ) trackTree->removeAllItem();
SpotifyUserData *sp_data = (SpotifyUserData *)spotify_userdata;
//ho la playlist, carico le tracce
sp_playlist_add_callbacks(plist, sp_data->playlist_cb, this);
if ( sp_playlist_is_loaded(plist) )
{
//aggiungo tracce
int n_tracks = sp_playlist_num_tracks(plist);
for ( int nt = 0 ; nt < n_tracks ; nt++ )
{
sp_track *track = sp_playlist_track(plist, nt);
if ( track && sp_track_is_loaded(track) )
{
if ( trackTree )
{
TCHAR trackname[1001] = {0};
memset(trackname, 0, sizeof(TCHAR)*1001);
_sntprintf_s(trackname, 1000, TEXT("%hs"), sp_track_name(track));
trackTree->addItemAsLast(NULL, trackname, track, 0);
}
}
}
}
}
}
void TLSpotify::TTrack::UpdateInfo()
{
if ( m_pTrack )
m_Title = sp_track_name( m_pTrack );
// just verify the loaded state
if ( IsReady() && !sp_track_is_loaded( m_pTrack ) )
{
TLDebug_Break("track not loaded");
m_Loaded = SyncFalse;
}
// unknown data
if ( !IsReady() )
{
m_Title = "???";
return;
}
// get info
m_Title = sp_track_name( m_pTrack );
/*
sp_album* pAlbum = sp_track_album( m_pTrack );
m_Album = pAlbum ? pAlbum->
// enum artists
int ArtistCount = sp_track_num_artists( m_pTrack );
if ( ArtistCount == 0 )
m_Artist = "???";
for ( u32 a=0; a<ArtistCount; a++ )
{
sp_artist* pArtist = sp_track_artist( m_pTrack, a );
if ( !pArtist )
m_Artist << "???";
else
m_Artist << pArtist->
*/
}
/************************
*** 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();
}
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);
}
/* Save state */
static gboolean save_state(gpointer data) {
queue_status qs;
gboolean repeat, shuffle;
int cur_track;
GArray* tracks = NULL;
JsonBuilder* jb = NULL;
JsonGenerator* gen = NULL;
gchar* out = NULL;
GError* err = NULL;
g_debug("savestate: starting to save the current state...");
/* Get data about the current state */
qs = queue_get_status(NULL, &cur_track, NULL);
tracks = queue_tracks();
repeat = queue_get_repeat();
shuffle = queue_get_shuffle();
/* Save them in JSON */
jb = json_builder_new();
json_builder_begin_object(jb);
json_builder_set_member_name(jb, "status");
switch (qs) {
case STOPPED:
json_builder_add_string_value(jb, "stopped"); break;
case PLAYING:
json_builder_add_string_value(jb, "playing"); break;
case PAUSED:
json_builder_add_string_value(jb, "paused"); break;
default:
g_warning("savestate: bad queue_status value: %d", qs);
goto savestate_clean;
}
json_builder_set_member_name(jb, "repeat");
json_builder_add_boolean_value(jb, repeat);
json_builder_set_member_name(jb, "shuffle");
json_builder_add_boolean_value(jb, shuffle);
json_builder_set_member_name(jb, "current_track");
json_builder_add_int_value(jb, cur_track);
json_builder_set_member_name(jb, "tracks");
json_builder_begin_array(jb);
int i;
for (i=0; i < tracks->len; i++) {
sp_track* tr = g_array_index(tracks, sp_track*, i);
if (!sp_track_is_loaded(tr)) {
g_warning("savestate: queue track %d is not loaded", i);
goto savestate_clean;
}
sp_link* lnk = sp_link_create_from_track(tr, 0);
gchar uri[1024];
int uri_len = sp_link_as_string(lnk, uri, 1024);
sp_link_release(lnk);
if (uri_len >= 1024) {
g_warning("savestate: URI too long for track %d", i);
goto savestate_clean;
}
json_builder_add_string_value(jb, uri);
}
json_builder_end_array(jb);
json_builder_end_object(jb);
/* Store JSON to file */
gen = json_generator_new();
json_generator_set_root(gen, json_builder_get_root(jb));
out = json_generator_to_data(gen, NULL);
if (g_file_set_contents(g_state_file_path, out, -1, &err))
g_debug("savestate: state saved to %s.", g_state_file_path);
else
g_warning("savestate: unable to dump status to file: %s", err->message);
savestate_clean:
if (tracks)
g_array_free(tracks, TRUE);
if (gen)
g_object_unref(gen);
if (jb)
g_object_unref(jb);
if (out)
g_free(out);
return FALSE;
}
bool Track::isAvailable() const
{
if (m_spTrack && sp_track_is_loaded(m_spTrack)) // && sp_track_is_available(m_spTrack))
return true;
return false;
}
// Toggle playback pause.
void sess_pause()
{
if (g_session.state != SESS_ONLINE || !g_session.playing || !g_session.current_track || !sp_track_is_loaded(g_session.current_track))
return;
g_session.paused = !g_session.paused;
sp_error err = sp_session_player_play(g_session.spotify, !g_session.paused);
if (err != SP_ERROR_OK)
panic("sp_session_player_play() failed: %s", sp_error_message(err));
if (g_session.paused) {
log_append("Paused");
}
else {
// Continue updating track progress.
ui_dirty(UI_TRACKPROGRESS);
log_append("Resuming");
}
}
static int osfy_artistbrowse_load_from_xml(sp_session *session, sp_artistbrowse *arb, ezxml_t root) {
unsigned char id[20];
int disc_number, i;
sp_track *track;
sp_album *album;
ezxml_t node, album_node, loop_node, track_node;
/* Load artist from XML if not yet loaded */
if(sp_artist_is_loaded(arb->artist) == 0)
osfy_artist_load_artist_from_xml(session, arb->artist, root);
assert(sp_artist_is_loaded(arb->artist));
/* Load portraits */
for(loop_node = ezxml_get(root, "bios", 0, "bio", 0, "portraits", 0, "portrait", -1);
loop_node;
loop_node = loop_node->next) {
if((node = ezxml_get(loop_node, "id", -1)) == NULL)
continue;
arb->portraits = realloc(arb->portraits, sizeof(unsigned char *) * (1 + arb->num_portraits));
arb->portraits[arb->num_portraits] = malloc(20);
hex_ascii_to_bytes(node->txt, arb->portraits[arb->num_portraits], 20);
arb->num_portraits++;
}
/* Load biography */
if((node = ezxml_get(root, "bios", 0, "bio", 0, "text", -1)) != NULL)
arb->biography = strdup(node->txt);
else
arb->biography = strdup("");
/* Load similar artists */
for(loop_node = ezxml_get(root, "similar-artists", 0, "artist", -1);
loop_node;
loop_node = loop_node->next) {
if((node = ezxml_get(loop_node, "id", -1)) == NULL)
continue;
arb->similar_artists = realloc(arb->similar_artists, sizeof(sp_artist *) * (1 + arb->num_similar_artists));
hex_ascii_to_bytes(node->txt, id, 16);
arb->similar_artists[arb->num_similar_artists]
= osfy_artist_add(session, id);
sp_artist_add_ref(arb->similar_artists[arb->num_similar_artists]);
if(sp_artist_is_loaded(arb->similar_artists[arb->num_similar_artists]) == 0) {
DSFYDEBUG("Loading similar artist from artistbrowse XML\n");
osfy_artist_load_artist_from_xml(session,
arb->similar_artists[arb->num_similar_artists],
loop_node);
}
assert(sp_artist_is_loaded(arb->similar_artists[arb->num_similar_artists]));
arb->num_similar_artists++;
}
/* Loop over each album listed */
for(album_node = ezxml_get(root, "albums", 0, "album", -1);
album_node;
album_node = album_node->next) {
/* Extract album ID and add it */
if((node = ezxml_get(album_node, "id", -1)) == NULL)
continue;
hex_ascii_to_bytes(node->txt, id, 16);
album = sp_album_add(session, id);
/* Load album if necessary */
if(sp_album_is_loaded(album) == 0)
osfy_album_load_from_album_xml(session, album, album_node);
assert(sp_album_is_loaded(album));
/* Add album to artistbrowse's list of albums */
arb->albums = realloc(arb->albums, sizeof(sp_album *) * (1 + arb->num_albums));
arb->albums[arb->num_albums] = album;
sp_album_add_ref(arb->albums[arb->num_albums]);
arb->num_albums++;
/* Loop over each disc in the album and add tracks */
for(loop_node = ezxml_get(album_node, "discs", 0, "disc", -1);
loop_node;
loop_node = loop_node->next) {
/* Cache disc number */
if((node = ezxml_get(loop_node, "disc-number", -1)) == NULL) {
DSFYDEBUG("BUG: Found no 'disc-numner' under discs -> disc\n");
continue;
}
disc_number = atoi(node->txt);
/* Loop over each track and add it to the artistbrowse tracks list */
for(track_node = ezxml_get(loop_node, "track", -1), i = 1;
track_node;
track_node = track_node->next, i++) {
/* Extract track ID and add it */
if((node = ezxml_get(track_node, "id", -1)) == NULL)
continue;
hex_ascii_to_bytes(node->txt, id, 16);
track = osfy_track_add(session, id);
/* Add album to track */
if(track->album)
sp_album_release(track->album);
track->album = album;
sp_album_add_ref(track->album);
/* Set disc number */
track->disc = disc_number;
/* Set track index on disc */
if(track->index == 0)
track->index = i;
/* Load track details from XML if not already loaded */
if(sp_track_is_loaded(track) == 0)
osfy_track_load_from_xml(session, track, track_node);
assert(sp_track_is_loaded(track));
/* Mark track as available if the album is available and the album has a non-zero duration (i.e, associated files) */
if(!track->is_available && track->duration) {
DSFYDEBUG("Track '%s' marked as not available but has files, force-marking track as %savailable\n",
node->txt, !album->is_available? "not ": "");
track->is_available = album->is_available;
}
/* Add track to artistbrowse and increase the track's ref count */
arb->tracks = realloc(arb->tracks, sizeof(sp_track *) * (1 + arb->num_tracks));
arb->tracks[arb->num_tracks] = track;
sp_track_add_ref(arb->tracks[arb->num_tracks]);
arb->num_tracks++;
}
} /* for each disc in album */
} /* for each album */
return 0;
}
// Load the track if the metadata update was concerning the track
void load_and_play_track_after_metadata_updated(list<int> int_params, list<string> string_params, sp_session *session, sp_track *track) {
if (s_is_waiting_for_metadata == true && sp_track_is_loaded(track)) {
s_is_waiting_for_metadata = false;
load_and_play_track(session, track);
}
}
