int cmd_playlist_add_track(int argc, char **argv) { sp_link *plink, *tlink; sp_track *t; sp_playlist *pl; int i; struct pl_update_work *puw; if(argc < 4) { printf("add [playlist uri] [position] [track uri] <[track uri]>...\n"); return 1; } plink = sp_link_create_from_string(argv[1]); if (!plink) { fprintf(stderr, "%s is not a spotify link\n", argv[1]); return -1; } if(sp_link_type(plink) != SP_LINKTYPE_PLAYLIST) { fprintf(stderr, "%s is not a playlist link\n", argv[1]); sp_link_release(plink); return -1; } puw = malloc(sizeof(struct pl_update_work)); puw->position = atoi(argv[2]); puw->tracks = malloc(sizeof(sp_track *) * argc - 3); puw->num_tracks = 0; for(i = 0; i < argc - 3; i++) { tlink = sp_link_create_from_string(argv[i + 3]); if(tlink == NULL) { fprintf(stderr, "%s is not a spotify link, skipping\n", argv[i + 3]); continue; } if(sp_link_type(tlink) != SP_LINKTYPE_TRACK) { fprintf(stderr, "%s is not a track link, skipping\n", argv[i + 3]); continue; } t = sp_link_as_track(tlink); sp_track_add_ref(t); puw->tracks[puw->num_tracks++] = t; sp_link_release(tlink); } pl = sp_playlist_create(g_session, plink); if(!apply_changes(pl, puw)) { // Changes applied directly, we're done sp_playlist_release(pl); sp_link_release(plink); return 1; } fprintf(stderr, "Playlist not yet loaded, waiting...\n"); sp_playlist_add_callbacks(pl, &pl_update_callbacks, puw); sp_link_release(plink); return 0; }
bool Codec::Init(const CStdString & strFile, unsigned int filecache) { m_bufferSize = 2048 * sizeof(int16_t) * 50; m_buffer = new char[m_bufferSize]; CStdString uri = URIUtils::GetFileName(strFile); CStdString extension = uri.Right(uri.GetLength() - uri.Find('.') - 1); if (extension.Left(12) == "spotifyradio") { //if its a radiotrack the radionumber and tracknumber is secretly encoded at the end of the extension CStdString trackStr = extension.Right( extension.GetLength() - extension.ReverseFind('#') - 1); Logger::printOut(extension); CStdString radioNumber = extension.Left(uri.Find('#')); Logger::printOut(radioNumber); radioNumber = radioNumber.Right( radioNumber.GetLength() - radioNumber.Find('#') - 1); Logger::printOut("loading codec radio"); RadioHandler::getInstance()->pushToTrack(atoi(radioNumber), atoi(trackStr)); } //we have a non legit extension so remove it manually uri = uri.Left(uri.Find('.')); Logger::printOut("trying to load track:"); Logger::printOut(uri); sp_link *spLink = sp_link_create_from_string(uri); m_currentTrack = sp_link_as_track(spLink); sp_track_add_ref(m_currentTrack); sp_link_release(spLink); m_endOfTrack = false; m_bufferPos = 0; m_startStream = false; m_isPlayerLoaded = false; m_TotalTime = sp_track_duration(m_currentTrack); //prefetch the next track! CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC); int nextSong = g_playlistPlayer.GetNextSong(); if (nextSong >= 0 && nextSong < playlist.size()){ CFileItemPtr song = playlist[nextSong]; if (song != NULL){ CStdString uri = song->GetPath(); if (uri.Left(7).Equals("spotify")){ uri = uri.Left(uri.Find('.')); Logger::printOut("prefetching track:"); Logger::printOut(uri); sp_link *spLink = sp_link_create_from_string(uri); sp_track* track = sp_link_as_track(spLink); sp_session_player_prefetch(getSession(), track); sp_link_release(spLink); } } } return true; }
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrievePlaylist ( JNIEnv *env, jobject obj, jstring uri) { jobject playlistInstance; 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_retrievePlaylist: Could not create link!\n" ); return JNI_FALSE; } sp_playlist *playlist = sp_playlist_create(g_sess,link); while (!sp_playlist_is_loaded(playlist)) { fprintf ( stderr, "jahspotify::Java_jahspotify_impl_JahSpotifyImpl_retrievePlaylist: Waiting for playlist to be loaded ...\n" ); sleep(1); } playlistInstance = createJPlaylist(env, playlist); if (playlist) sp_playlist_release(playlist); if (link) sp_link_release(link); if (nativeUri) free(nativeUri); return playlistInstance; }
// ---------------------------------------------------------------------------- // bool DMX_PLAYER_API GetPlaylists( UINT* num_lists, LPSTR playlist_links, size_t buffer_length ) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); PlaylistArray playlists = theApp.m_spotify.getPlaylists( ); UINT link_counter = 0; UINT index = 0; playlist_links[0] = '\0'; buffer_length--; CString spotifyLink; for ( sp_playlist* pl : playlists ) { sp_link * link = sp_link_create_from_playlist( pl ); int size = sp_link_as_string ( link, spotifyLink.GetBuffer( MAX_LINK_SIZE ), MAX_LINK_SIZE ); sp_link_release( link ); spotifyLink.ReleaseBuffer(); if ( (size_t)spotifyLink.GetLength()+1 > buffer_length ) break; strcpy_s( playlist_links, buffer_length, spotifyLink ); playlist_links = &playlist_links[size+1]; *playlist_links = '\0'; buffer_length -= (size+1); link_counter++; } *num_lists = link_counter; return *num_lists == playlists.size(); }
// --------------------------------------------------------------------------- // static size_t getTrackLinks( TrackArray& tracks, LPSTR buffer, size_t buffer_length ) { UINT link_counter = 0; UINT index = 0; buffer[0] = '\0'; buffer_length--; CString spotifyLink; for ( sp_track* track : tracks ) { sp_link * link = sp_link_create_from_track( track, 0 ); UINT size = sp_link_as_string ( link, spotifyLink.GetBuffer(MAX_LINK_SIZE), MAX_LINK_SIZE ); sp_link_release( link ); spotifyLink.ReleaseBuffer(); if ( size >= buffer_length ) break; strcpy_s( buffer, buffer_length, spotifyLink ); buffer = &buffer[size+1]; *buffer = '\0'; buffer_length -= (size+1); link_counter++; } return link_counter; }
//---------------------------------------------- // get track info from URI //---------------------------------------------- TRef TLSpotify::TSession::FindTrack(const TString& URI) { THeapArray<char> UriString; URI.GetAnsi( UriString ); // find link sp_link *link = sp_link_create_from_string( UriString.GetData() ); if (!link) return TRef(); // get track from the link sp_track* pTrack = sp_link_as_track( link ); if ( !pTrack ) { TDebugString Debug_String; Debug_String << "URI " << URI << " is not a track"; TLDebug_Print( Debug_String ); return TRef(); } // create new track info TRef TrackRef = AddTrack( *pTrack ); const char* TrackName = sp_track_name( pTrack ); // The create function will have increased the reference count for us so release sp_link_release(link); return TrackRef; }
JNIEXPORT jobject JNICALL Java_jahspotify_impl_JahSpotifyImpl_retrieveAlbum ( JNIEnv *env, jobject obj, jstring uri) { jobject albumInstance; uint8_t *nativeUri = NULL; nativeUri = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL ); sp_link *link = sp_link_create_from_string(nativeUri); if (link) { sp_album *album= sp_link_as_album(link); if (album) { sp_album_add_ref(album); albumInstance = createJAlbumInstance(env, album); sp_album_release(album); } sp_link_release(link); } if (nativeUri) (*env)->ReleaseStringUTFChars(env, uri,nativeUri); return albumInstance; }
/** * 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 Link_dealloc(Link * self) { if (self->_link) sp_link_release(self->_link); self->ob_type->tp_free(self); }
QString Spotify::songNameFromUri(const QString &uriString) { const char * uri = uriString.toLocal8Bit().constData(); sp_link * link = sp_link_create_from_string(uri); if (!link) { fprintf(stderr, "Spotify: failed to parse URI (%s)\n", uri); return QString(); } sp_track * track; QString song; switch (sp_link_type(link)) { case SP_LINKTYPE_LOCALTRACK: case SP_LINKTYPE_TRACK: track = sp_link_as_track(link); if (!track) { fprintf(stderr, "Link is not a track\n"); break; } song = QString(sp_track_name(track)); break; default: qDebug() << "URI is not a track:" << uriString; break; } sp_link_release(link); return song; }
QString Spotify::uriFromTrack(sp_track *track) { sp_link * link = sp_link_create_from_track(track, 0); if (!link) { fprintf(stderr, "Spotify: failed to create URI for track"); return QString(); } static int bufSize = 128; char * buf = new char[bufSize]; int uriSize = sp_link_as_string(link, buf, bufSize); while (uriSize >= bufSize) { // String truncated, increase buf size and try again bufSize = uriSize + 1; delete [] buf; buf = new char[bufSize]; uriSize = sp_link_as_string(link, buf, bufSize); } bufSize = uriSize + 1; QString uri = QString::fromLocal8Bit(buf, uriSize); delete [] buf; sp_link_release(link); return uri; }
PHP_METHOD(Spotify, getArtistByURI) { 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_ARTIST != sp_link_type(link)) { RETURN_FALSE; } sp_artist *artist = sp_link_as_artist(link); object_init_ex(return_value, spotifyartist_ce); SPOTIFY_METHOD2(SpotifyArtist, __construct, &temp, return_value, object, artist); sp_link_release(link); }
void Spotify::changeCurrentlyPlayingSong() { sp_track * track; const char * uri = currentURI.toLocal8Bit().constData(); fprintf(stderr, "Spotify: Playing %s\n", uri); sp_link * link = sp_link_create_from_string(uri); if (!link) { fprintf(stderr, "Spotify: failed to parse URI (%s)\n", uri); currentURI.clear(); return; } switch (sp_link_type(link)) { case SP_LINKTYPE_LOCALTRACK: case SP_LINKTYPE_TRACK: track = sp_link_as_track(link); if (!track) { fprintf(stderr, "Link is not a track\n"); break; } nextTrack = track; sp_track_add_ref(track); tryLoadTrack(); break; default: qDebug() << "URI is not a track:" << currentURI; break; } sp_link_release(link); }
PHP_METHOD(Spotify, getAlbumByURI) { 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_ALBUM != sp_link_type(link)) { RETURN_FALSE; } sp_album *album = sp_link_as_album(link); while (!sp_album_is_loaded(album)) { sp_session_process_events(p->session, &timeout); } object_init_ex(return_value, spotifyalbum_ce); SPOTIFY_METHOD2(SpotifyAlbum, __construct, &temp, return_value, object, album); sp_link_release(link); }
/** * Print the given track title together with some trivial metadata * * @param track The track object */ void print_track(sp_track *track) { int duration = sp_track_duration(track); char url[256]; sp_link *l; #if WIN32 printf(" %s ", sp_track_is_starred(track) ? "*" : " "); #else printf(" %s ", sp_track_is_starred(track) ? "★" : "☆"); #endif printf("Track %s [%d:%02d] has %d artist(s), %d%% popularity", sp_track_name(track), duration / 60000, (duration / 1000) / 60, sp_track_num_artists(track), sp_track_popularity(track)); if(sp_track_disc(track)) printf(", %d on disc %d", sp_track_index(track), sp_track_disc(track)); printf("\n"); l = sp_link_create_from_track(track, 0); sp_link_as_string(l, url, sizeof(url)); printf("\t\t%s\n", url); sp_link_release(l); }
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; }
/** * 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) */ }
int cmd_browse(int argc, char **argv) { sp_link *link; if (argc != 2) { browse_usage(); return -1; } link = sp_link_create_from_string(argv[1]); if (!link) { fprintf(stderr, "Not a spotify link\n"); return -1; } switch(sp_link_type(link)) { default: fprintf(stderr, "Can not handle link"); sp_link_release(link); return -1; case SP_LINKTYPE_ALBUM: sp_albumbrowse_create(g_session, sp_link_as_album(link), browse_album_callback, NULL); break; case SP_LINKTYPE_ARTIST: sp_artistbrowse_create(g_session, sp_link_as_artist(link), browse_artist_callback, NULL); break; case SP_LINKTYPE_TRACK: track_browse = sp_link_as_track(link); metadata_updated_fn = track_browse_try; sp_track_add_ref(track_browse); track_browse_try(); break; case SP_LINKTYPE_PLAYLIST: browse_playlist(sp_playlist_create(g_session, link)); break; } sp_link_release(link); return 0; }
/** * Callback from libspotify, telling us the rootlist is fully synchronized * * @param pc The playlist container handle * @param userdata The opaque pointer */ static void container_loaded ( sp_playlistcontainer *pc, void *userdata ) { char *folderName = malloc ( sizeof ( char ) * ( MAX_LENGTH_FOLDER_NAME ) ); int i; if ( folderName == NULL ) { fprintf ( stderr, "jahspotify: Could not allocate folder name variable)\n" ); return; } // fprintf ( stderr, "jahspotify: Rootlist synchronized (%d playlists)\n",sp_playlistcontainer_num_playlists ( pc ) ); signalSynchStarting(sp_playlistcontainer_num_playlists (pc)); for ( i = 0; i < sp_playlistcontainer_num_playlists ( pc ); ++i ) { sp_playlist *pl = sp_playlistcontainer_playlist ( pc, i ); sp_playlist_add_callbacks ( pl, &pl_callbacks, NULL ); sp_link *link = sp_link_create_from_playlist(pl); char *linkStr = malloc(sizeof(char) * 100); if (link) { sp_link_add_ref(link); sp_link_as_string(link,linkStr,100); } else { strcpy(linkStr,"N/A\0"); } switch ( sp_playlistcontainer_playlist_type ( pc,i ) ) { case SP_PLAYLIST_TYPE_PLAYLIST: signalPlaylistSeen(sp_playlist_name ( pl ),linkStr); break; case SP_PLAYLIST_TYPE_START_FOLDER: sp_playlistcontainer_playlist_folder_name ( pc,i,folderName, MAX_LENGTH_FOLDER_NAME); signalStartFolderSeen(folderName, sp_playlistcontainer_playlist_folder_id(pc,i)); break; case SP_PLAYLIST_TYPE_END_FOLDER: sp_playlistcontainer_playlist_folder_name ( pc,i,folderName,MAX_LENGTH_FOLDER_NAME); signalEndFolderSeen(); break; case SP_PLAYLIST_TYPE_PLACEHOLDER: fprintf ( stderr,"jahspotify: placeholder\n"); } if (link) sp_link_release(link); free(linkStr); } signalSynchCompleted(); free ( folderName ); }
int createTrackFromUri( char *uri , char *name ) { TRACE_2( PLAYERMANAGER , "createTrackFromUri( %s , __track__ )" , uri ); sp_link *link; sp_error error; if( playing == FALSE && hasNextTrack() == FALSE ) createFile( name ); TRACE_1( PLAYERMANAGER , "Creating URI : %s" , uri ); link = sp_link_create_from_string( uri ); if( link == NULL ) { TRACE_ERROR( PLAYERMANAGER , "Fail to create link."); return PC_ERROR; } else { TRACE_1( PLAYERMANAGER , "Success to create link."); } TRACE_3( PLAYERMANAGER , "Construct track..."); currentTrack = sp_link_as_track( link ); if( currentTrack == NULL ) { TRACE_ERROR( PLAYERMANAGER , "Fail to create track."); return PC_ERROR; } else { TRACE_1( PLAYERMANAGER , "Success to create track."); } error = sp_track_add_ref( currentTrack ); if( error != SP_ERROR_OK ) { TRACE_ERROR( PLAYERMANAGER , "Cannot add ref track, reason: %s" , sp_error_message( error ) ); return PC_ERROR; } sp_link_release( link ); running = TRUE; // playing = FALSE; return PC_SUCCESS; }
bool Codec::Init(const CStdString & strFile, unsigned int filecache) { m_bufferSize = 2048 * sizeof(int16_t) * 50; m_buffer = new char[m_bufferSize]; CStdString uri = URIUtils::GetFileName(strFile); CStdString extension = uri.Right(uri.GetLength() - uri.Find('.') - 1); //we have a non legit extension so remove it manually uri = uri.Left(uri.Find('.')); Logger::printOut("trying to load track:"); Logger::printOut(uri); sp_link *spLink = sp_link_create_from_string(uri); m_currentTrack = sp_link_as_track(spLink); sp_track_add_ref(m_currentTrack); sp_link_release(spLink); m_endOfTrack = false; m_bufferPos = 0; m_startStream = false; m_isPlayerLoaded = false; m_TotalTime = sp_track_duration(m_currentTrack); //prefetch the next track! CPlayList& playlist = g_playlistPlayer.GetPlaylist(PLAYLIST_MUSIC); int nextSong = g_playlistPlayer.GetNextSong(); if (nextSong >= 0 && nextSong < playlist.size()){ CFileItemPtr song = playlist[nextSong]; if (song != NULL){ CStdString uri = song->GetPath(); if (uri.Left(7).Equals("spotify")){ uri = uri.Left(uri.Find('.')); Logger::printOut("prefetching track:"); Logger::printOut(uri); sp_link *spLink = sp_link_create_from_string(uri); sp_track* track = sp_link_as_track(spLink); sp_session_player_prefetch(getSession(), track); sp_link_release(spLink); } } } return true; }
PHP_METHOD(SpotifyPlaylist, getURI) { char uri[256]; spotifyplaylist_object *p = (spotifyplaylist_object*)zend_object_store_get_object(getThis() TSRMLS_CC); sp_link *link = sp_link_create_from_playlist(p->playlist); sp_link_as_string(link, uri, 256); sp_link_release(link); RETURN_STRING(uri, 1); }
PHP_METHOD(SpotifyArtist, getURI) { char uri[256]; zval *object = getThis(); spotifyartist_object *p = (spotifyartist_object*)zend_object_store_get_object(object TSRMLS_CC); sp_link *link = sp_link_create_from_artist(p->artist); sp_link_as_string(link, uri, 256); sp_link_release(link); RETURN_STRING(uri, 1); }
static void print_artist(int index, sp_artist *artist) { sp_link *l; char url[200]; printf(" Artist %3d: \"%s\"\n", index, sp_artist_name(artist)); l = sp_link_create_from_artist_portrait(artist); if(l != NULL) { sp_link_as_string(l, url, sizeof(url)); printf(" Portrait: %s\n", url); sp_link_release(l); } }
static void _spotify_play(sp_session *session, std::string uri) { assert(pthread_equal(pthread_self(),g_spotify_tid)); sp_link *l = sp_link_create_from_string(uri.c_str()); sp_error err; int offset; if(!l || sp_link_type(l) != SP_LINKTYPE_TRACK) { return; } sp_track *t = sp_link_as_track_and_offset(l,&offset); try_play(session,t,offset); sp_link_release(l); return; }
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); }
bool QSpotifyAlbum::updateData() { bool updated = false; bool isAvailable = sp_album_is_available(m_sp_album); sp_artist *a = sp_album_artist((m_sp_album)); QString artist; if (a) artist = QString::fromUtf8(sp_artist_name(a)); QString name = QString::fromUtf8(sp_album_name(m_sp_album)); int year = sp_album_year(m_sp_album); Type type = Type(sp_album_type(m_sp_album)); // Get cover const byte *album_cover_id = sp_album_cover(m_sp_album, SP_IMAGE_SIZE_NORMAL); if (album_cover_id != 0 && m_coverId.isEmpty()) { sp_link *link = sp_link_create_from_album_cover(m_sp_album, SP_IMAGE_SIZE_NORMAL); if (link) { char buffer[200]; int uriSize = sp_link_as_string(link, &buffer[0], 200); m_coverId = QString::fromUtf8(&buffer[0], uriSize); sp_link_release(link); updated = true; } } if (isAvailable != m_isAvailable) { m_isAvailable = isAvailable; updated = true; } if (artist != m_artist) { m_artist = artist; updated = true; } if (name != m_name) { m_name = name; updated = true; } if (year != m_year) { m_year = year; updated = true; } if (type != m_type) { m_type = type; updated = true; } return updated; }
static void playlist_update_in_progress ( sp_playlist *pl, bool done, void *userdata ) { const char *name = sp_playlist_name ( pl ); char *playListlinkStr; char *trackLinkStr; sp_link *link; int trackCounter; // fprintf ( stderr,"jahspotify: playlist update in progress: %s (done: %s)\n",name, (done ? "yes" : "no")); if (done) { link = sp_link_create_from_playlist(pl); if (link) { playListlinkStr = malloc ( sizeof ( char ) * ( 100 ) ); sp_link_as_string(link,playListlinkStr,100); sp_link_release(link); signalPlaylistSeen(name,playListlinkStr); } //sp_link_release(link); // int numTracks = sp_playlist_num_tracks(pl); // fprintf ( stderr,"jahspotify: playlist: %s num tracks: %d id: %s\n",name,numTracks,playListlinkStr); // for (trackCounter = 0 ; trackCounter < numTracks; trackCounter++) // { // sp_track *track = sp_playlist_track(pl,trackCounter); // if (sp_track_is_loaded(track)) // { // link = sp_link_create_from_track(track,0); // trackLinkStr = malloc ( sizeof ( char ) * ( 100 ) ); // sp_link_as_string(link,trackLinkStr,100); // fprintf ( stderr,"jahspotify: track name: %s track id: %s\n",sp_track_name(track),trackLinkStr); // sp_link_release(link); // if (trackLinkStr) (trackLinkStr); // } // sp_track_release(track); // } // // if (playListlinkStr) free(playListlinkStr); // } } }
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; }
// ---------------------------------------------------------------------------- // sp_linktype SpotifyEngine::getTrackLink( sp_track* track, CString& spotify_link ) { spotify_link.Empty(); sp_link* link = sp_link_create_from_track( track, 0 ); if ( link == NULL ) return SP_LINKTYPE_INVALID; LPSTR spotify_link_ptr = spotify_link.GetBufferSetLength( 512 ); sp_link_as_string ( link, spotify_link_ptr, 512 ); sp_linktype link_type = sp_link_type( link ); sp_link_release( link ); return link_type; }