/** * This callback is called when an attempt to login has succeeded or failed. * * @sa sp_session_callbacks#logged_in */ static void logged_in(sp_session *sess, sp_error error) { sp_link *link; if (SP_ERROR_OK != error) { fprintf(stderr, "Login failed: %s\n", sp_error_message(error)); exit(2); } printf("Loading track\n"); link = sp_link_create_from_string("spotify:track:5W3cjX2J3tjhG8zb6u0qHn"); sp_track_add_ref(g_currenttrack = sp_link_as_track(link)); sp_link_release(link); if (sp_track_error(g_currenttrack) == SP_ERROR_OK) { printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack)); fflush(stdout); sp_session_player_load(g_sess, g_currenttrack); sp_session_player_play(g_sess, 1); } /* Track not loaded? Then we need to wait for the metadata to load before we can start playback (see below) */ }
SyncBool TLSpotify::TTrack::Initialise() { if ( !m_pTrack ) { m_Loaded = SyncFalse; return m_Loaded; } // check track state if ( m_Loaded == SyncWait ) { sp_error Error = sp_track_error( m_pTrack ); if ( Error == SP_ERROR_OK ) { m_Loaded = SyncTrue; UpdateInfo(); } else if ( Error == SP_ERROR_IS_LOADING ) { m_Loaded = SyncWait; } else { m_pTrack = NULL; m_Loaded = SyncFalse; } } return m_Loaded; }
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); }
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 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); }
/** * Callback called when libspotify has new metadata available * * @sa sp_session_callbacks#metadata_updated */ static void metadata_updated(sp_session *sess) { puts("Metadata updated, trying to start playback"); if (sp_track_error(g_currenttrack) != SP_ERROR_OK) return; printf("Now playing \"%s\"...\n", sp_track_name(g_currenttrack)); fflush(stdout); sp_session_player_load(g_sess, g_currenttrack); sp_session_player_play(g_sess, 1); }
/** * 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_jukebox_start(void) { sp_track *t; printf("try_jukebox_start\n"); if (!g_jukeboxlist) return; int nt = sp_playlist_num_tracks(g_jukeboxlist); if (!nt) { fprintf(stderr, "jukebox: No tracks in playlist. Waiting\n"); return; } if (nt > 2) { int tmp = g_track_index; while (tmp == g_track_index) tmp = rand() % nt; g_track_index = tmp; } else { g_track_index = rand() % nt; } printf("play track %d of %d\n", g_track_index, nt); t = sp_playlist_track(g_jukeboxlist, g_track_index); printf("t=%X\n", t); if (g_currenttrack && t != g_currenttrack) { printf("stopping currently playing..\n"); /* Someone changed the current track */ // audio_fifo_flush(&g_musicfifo); // sp_session_player_unload(g_sess); // g_currenttrack = NULL; } if (!t) return; int err = sp_track_error(t); if (err != SP_ERROR_OK /*&& err != SP_ERROR_IS_LOADING*/) { printf("track error? %d\n", err); return; } if (g_currenttrack == t) { printf("not starting the same track.\n"); return; } g_currenttrack = t; printf("jukebox: Now playing \"%s\"...\n", sp_track_name(t)); sp_artist *art = sp_track_artist(t, 0); if (art != NULL) { printf("jukebox: By \"%s\"...\n", sp_artist_name(art)); sprintf( g_last_track_name, "%s by %s", sp_track_name(t), sp_artist_name(art) ); } else { sprintf( g_last_track_name, "%s", sp_track_name(t) ); } fflush(stdout); sp_session_player_load(g_sess, t); usleep(100000); sp_session_player_play(g_sess, 1); usleep(100000); g_is_playing = 1; notify_main_thread(g_sess); printf("after try_jukebox_start\n"); tuner_debug(); }
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; }
static void SP_CALLCONV search_complete(sp_search *search, void *userdata) { JNIEnv *env; jclass classLibspotify = find_class_from_native_thread(&env); string &qid = *static_cast<string*>(userdata); jstring j_qid = env->NewStringUTF(qid.c_str()); bool success = (sp_search_error(search) == SP_ERROR_OK) ? true : false; int count = sp_search_num_tracks(search); jstring j_trackname; jstring j_trackuri; jstring j_albumname; jstring j_artistname; sp_track *track; for (int i=0;i< count;i++){ track = sp_search_track(search, i); if (track != 0 && sp_track_error(track) == SP_ERROR_OK){ const char *temp = sp_track_name(track); if (temp != 0 && strlen(temp) != 0){ j_trackname = env->NewStringUTF(temp); } int trackDuration = sp_track_duration(track); if (sp_track_error(track) != SP_ERROR_OK) log("sp_track_error: %s",sp_error_message(sp_track_error(track))); int trackDiscnumber = sp_track_disc(track); if (sp_track_error(track) != SP_ERROR_OK) log("sp_track_error: %s",sp_error_message(sp_track_error(track))); int trackIndex = sp_track_index(track); if (sp_track_error(track) != SP_ERROR_OK) log("sp_track_error: %s",sp_error_message(sp_track_error(track))); char buffer [64]; sp_link *link = sp_link_create_from_track(track, 0); if (link != 0){ sp_link_as_string(link, buffer, 64); } j_trackuri = env->NewStringUTF(buffer); sp_album *album = sp_track_album(track); if (sp_track_error(track) != SP_ERROR_OK) log("sp_track_error: %s",sp_error_message(sp_track_error(track))); int albumYear = 0; if (album != 0){ temp = sp_album_name(album); albumYear = sp_album_year(album); if (temp != 0 && strlen(temp) != 0){ j_albumname = env->NewStringUTF(temp); } } sp_artist *artist = sp_track_artist(track,0); if (sp_track_error(track) != SP_ERROR_OK) log("sp_track_error: %s",sp_error_message(sp_track_error(track))); if (artist != 0){ temp = sp_artist_name(artist); if (temp != 0 && strlen(temp) != 0){ j_artistname = env->NewStringUTF(temp); } } jmethodID methodIdAddResult = env->GetStaticMethodID(classLibspotify, "addResult", "(Ljava/lang/String;Ljava/lang/String;IIILjava/lang/String;Ljava/lang/String;ILjava/lang/String;)V"); env->CallStaticVoidMethod(classLibspotify, methodIdAddResult, j_qid, j_trackname, trackDuration, trackDiscnumber, trackIndex, j_trackuri, j_albumname, albumYear, j_artistname); if (env->ExceptionCheck()) { env->ExceptionDescribe(); env->ExceptionClear(); } env->DeleteLocalRef(j_trackname); env->DeleteLocalRef(j_trackuri); env->DeleteLocalRef(j_artistname); env->DeleteLocalRef(j_albumname); j_trackname = NULL; j_trackuri = NULL; j_artistname = NULL; j_albumname = NULL; } } jmethodID methodIdOnResolved = env->GetStaticMethodID(classLibspotify, "onResolved", "(Ljava/lang/String;ZLjava/lang/String;Ljava/lang/String;)V"); jstring j_error = env->NewStringUTF(sp_error_message(sp_search_error(search))); jstring j_didyoumean = env->NewStringUTF(sp_search_did_you_mean(search)); env->CallStaticVoidMethod(classLibspotify, methodIdOnResolved, j_qid, success, j_error, j_didyoumean); if (env->ExceptionCheck()) { env->ExceptionDescribe(); env->ExceptionClear(); } env->DeleteLocalRef(classLibspotify); env->DeleteLocalRef(j_qid); env->DeleteLocalRef(j_error); env->DeleteLocalRef(j_didyoumean); log("Finished resolving query:'%s', success'%s', track count:'%d', qid:'%s'", sp_search_query(search), (success?"true":"false"), count, qid.c_str()); sp_search_release(search); delete &qid; }
static PyObject * Track_error(Track * self) { return Py_BuildValue("i", sp_track_error(self->_track)); }