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;
}
