ClientResponse* SpotifyPlaylistContainer::playPlaylist(PlaylistTask* task) {
StatusResponse* response = new StatusResponse(false,
"Playlist Id is out of range!");
int playlistNum = task->getCommandInfo().playlist;
if (playlistNum >= 0
&& playlistNum
< sp_playlistcontainer_num_playlists(playlistContainer)) {
sp_playlist* playlist = sp_playlistcontainer_playlist(playlistContainer,
playlistNum);
if (sp_playlist_num_tracks(playlist) > 0) {
sp_track* track = sp_playlist_track(playlist, 0);
spotifySession->getSpotifyPlayer()->clearPlayQueue();
spotifySession->getSpotifyPlayer()->playTrack(track);
for (int i = 1; i < sp_playlist_num_tracks(playlist); i++) {
spotifySession->getSpotifyPlayer()->addTrackToQueue(
sp_playlist_track(playlist, i));
}
response->setSuccess(true);
response->setMessage(nullptr);
} else {
response->setMessage("Playlist does not have any tracks");
}
}
return response;
}
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;
}
int cmd_playlist(int argc, char **argv)
{
int index, i;
sp_track *track;
sp_playlist *playlist;
sp_playlistcontainer *pc = sp_session_playlistcontainer(g_session);
if (argc < 1) {
printf("playlist [playlist index]\n");
return 0;
}
index = atoi(argv[1]);
if (index < 0 || index > sp_playlistcontainer_num_playlists(pc)) {
printf("invalid index\n");
return 0;
}
playlist = sp_playlistcontainer_playlist(pc, index);
printf("Playlist %s by %s%s%s\n",
sp_playlist_name(playlist),
sp_user_display_name(sp_playlist_owner(playlist)),
sp_playlist_is_collaborative(playlist) ? " (collaborative)" : "",
sp_playlist_has_pending_changes(playlist) ? " with pending changes" : ""
);
for (i = 0; i < sp_playlist_num_tracks(playlist); ++i) {
track = sp_playlist_track(playlist, i);
printf("%d. %c %s%s %s\n", i,
sp_track_is_starred(g_session, track) ? '*' : ' ',
sp_track_is_local(g_session, track) ? "local" : " ",
sp_track_is_autolinked(g_session, track) ? "autolinked" : " ",
sp_track_name(track));
}
return 1;
}
void SxPlaylist::reLoad() {
Logger::printOut("reload play");
if (m_isValid && !isFolder()) {
m_thumb = NULL;
//TODO fix a thumb, why is it never returning any images?
byte image[20];
if (sp_playlist_get_image(m_spPlaylist, image)) {
m_thumb = ThumbStore::getInstance()->getThumb(image);
}
Logger::printOut("reload play 3");
vector<SxTrack*> newTracks;
for (int index = 0; index < sp_playlist_num_tracks(m_spPlaylist); index++) {
sp_track* spTrack = sp_playlist_track(m_spPlaylist, index);
if (!sp_track_get_availability(Session::getInstance()->getSpSession(), spTrack)) continue;
SxTrack* track = TrackStore::getInstance()->getTrack(spTrack);
if (track) {
newTracks.push_back(track);
//no thumb, lets pick one from the track list
if (m_thumb == NULL)
if (track->getThumb() != NULL)
//no need to add ref to the thumb, when the track disappears the playlist will switch thumb
m_thumb = track->getThumb();
}
}
removeAllTracks();
Logger::printOut("reload play done");
m_tracks = newTracks;
}
Utils::updatePlaylist(m_index);
}
PHP_METHOD(SpotifyPlaylist, addTrack)
{
zval *track, retval, *z_position, *object = getThis();
sp_error error;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|z", &track, spotifytrack_ce, &z_position) == FAILURE) {
return;
}
spotifyplaylist_object *p = (spotifyplaylist_object*)zend_object_store_get_object(object TSRMLS_CC);
sp_track **tracks = (sp_track**)emalloc(sizeof(sp_track*) * 1);
spotifytrack_object *track_obj = (spotifytrack_object*)zend_object_store_get_object(track TSRMLS_CC);
tracks[0] = track_obj->track;
sp_track_add_ref(track_obj->track);
int position;
if (Z_TYPE_P(z_position) == IS_NULL || Z_LVAL_P(z_position) < 0) {
position = sp_playlist_num_tracks(p->playlist);
} else {
position = Z_LVAL_P(z_position);
}
error = sp_playlist_add_tracks(p->playlist, tracks, 1, position, p->session);
efree(tracks);
if (SP_ERROR_OK == error) {
RETURN_TRUE;
} else {
RETURN_FALSE;
}
}
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();
}
ListResponse<TrackInfo*>* SpotifyPlaylistContainer::listTracks(
PlaylistTask* task) {
ListResponse<TrackInfo*>* response = new ListResponse<TrackInfo*>();
response->setListType(ListTypeSong);
ListPlaylistTrackInfo info = task->getCommandInfo().listPlaylistTrackInfo;
int playlistId = info.playlist;
if (playlistId > -1
&& playlistId
< sp_playlistcontainer_num_playlists(playlistContainer)) {
bool sendName = ((info.trackInfoFlags & TrackInfoName) == TrackInfoName);
bool sendArtist = ((info.trackInfoFlags & TrackInfoArtists)
== TrackInfoArtists);
bool sendAlbum = ((info.trackInfoFlags & TrackInfoAlbum)
== TrackInfoAlbum);
bool sendDuration = ((info.trackInfoFlags & TrackInfoDuration)
== TrackInfoDuration);
bool sendArtwork = ((info.trackInfoFlags & TrackInfoArtwork)
== TrackInfoArtwork);
sp_playlist* playlist = sp_playlistcontainer_playlist(playlistContainer,
playlistId);
int numTracks = sp_playlist_num_tracks(playlist);
for (int i = 0; i < numTracks; i++) {
TrackInfo* trackInfo = new TrackInfo();
trackInfo->id = i;
sp_track* track = sp_playlist_track(playlist, i);
if (sendName) {
trackInfo->name = sp_track_name(track);
}
if (sendArtist) {
trackInfo->numArtists = sp_track_num_artists(track);
trackInfo->artists = new const char*[trackInfo->numArtists];
for (int j = 0; j < trackInfo->numArtists; j++) {
trackInfo->artists[j] = sp_artist_name(
sp_track_artist(track, j));
}
}
if (sendAlbum) {
trackInfo->album = sp_album_name(sp_track_album(track));
}
if (sendDuration) {
trackInfo->duration = sp_track_duration(track);
}
if (sendArtwork) {
trackInfo->artwork = sp_image_create(session,
sp_album_cover(sp_track_album(track),
SP_IMAGE_SIZE_NORMAL));
}
response->addMember(trackInfo);
}
return response;
}
delete response;
return nullptr;
}
/*
* Add an entire playlist to the queue
*/
void queue_add_playlist(sp_playlist *playlist)
{
int i = 0;
for(i = 0; i < sp_playlist_num_tracks(playlist) - 1; i++) {
queue_add(sp_playlist_track(playlist, i));
}
}
/**
* 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 fill_track_tokens_from_playlist(struct track_tokens_t *src,
sp_playlist *playlist) {
int num_tracks = sp_playlist_num_tracks(playlist);
init_track_tokens(src, num_tracks);
for (int i = 0; i < num_tracks; i++) {
sp_track *track = sp_playlist_track(playlist, i);
sp_track_add_ref(track);
src->tracks[i] = track;
}
}
// ----------------------------------------------------------------------------
//
PlaylistArray SpotifyEngine::getPlaylists( void ) {
PlaylistArray playlists;
sp_playlistcontainer *pc = sp_session_playlistcontainer( m_spotify_session );
for ( int i=0; i < sp_playlistcontainer_num_playlists(pc); i++ ) {
sp_playlist *pl = sp_playlistcontainer_playlist(pc, i);
if ( sp_playlist_num_tracks( pl ) > 0 )
playlists.push_back( pl );
}
return playlists;
}
ClientResponse* SpotifyPlaylistContainer::playTrack(PlaylistTask* task) {
StatusResponse* response = new StatusResponse(false,
"Playlist Id is out of range!");
PlayTrackCommandInfo info = task->getCommandInfo().playTrackCommandInfo;
if (info.playlistId > -1
&& info.playlistId
< sp_playlistcontainer_num_playlists(playlistContainer)) {
sp_playlist* playlist = sp_playlistcontainer_playlist(playlistContainer,
info.playlistId);
if (info.trackId > -1
&& info.trackId < sp_playlist_num_tracks(playlist)) {
spotifySession->getSpotifyPlayer()->clearPlayQueue();
for (int i = 0; i < info.trackId; i++) {
spotifySession->getSpotifyPlayer()->addTrackToPlayedQueue(
sp_playlist_track(playlist, i));
}
sp_track* track = sp_playlist_track(playlist, info.trackId);
spotifySession->getSpotifyPlayer()->playTrack(track);
for (int i = info.trackId + 1; i < sp_playlist_num_tracks(playlist);
i++) {
spotifySession->getSpotifyPlayer()->addTrackToQueue(
sp_playlist_track(playlist, i));
}
if(spotifySession->getSpotifyPlayer()->isShuffled()) {
spotifySession->getSpotifyPlayer()->setShuffle(true);
}
response->setSuccess(true);
response->setMessage(nullptr);
} else {
response->setMessage("Track does not exist!");
}
}
return response;
}
sp_error
sp_playlist_remove_tracks(sp_playlist *playlist, const int *tracks, int num_tracks)
{
int size = sp_playlist_num_tracks(playlist);
int new_size = size - num_tracks;
int i = 0, j = 0, k = 0;
sp_playlist_track_t *new_tracks = NULL;
int *sorted_tracks = NULL;
// Make sure all indices are unique and not too small/large
for (i = 0; i < num_tracks; ++i)
{
if (tracks[i] < 0 || tracks[i] >= size)
return SP_ERROR_INVALID_INDATA;
for (j = i + 1; j < num_tracks; ++j)
{
if (tracks[i] == tracks[j])
return SP_ERROR_INVALID_INDATA;
}
}
new_tracks = ALLOC_N(sp_playlist_track_t, new_size);
// this simplifies the remove operation quite a bit!
sorted_tracks = ALLOC_N(int, num_tracks);
MEMCPY_N(sorted_tracks, tracks, int, num_tracks);
qsort(sorted_tracks, num_tracks, sizeof(int), compare_ints);
for (i = 0, j = 0, k = 0; i < size; ++i)
{
if (sorted_tracks[j] == i)
{
j += 1;
continue;
}
MEMCPY(&new_tracks[k++], &playlist->tracks[i], sp_playlist_track_t);
}
// we usually don’t do memory management, but in this case why not?
free(sorted_tracks);
free(playlist->tracks);
playlist->tracks = new_tracks;
playlist->num_tracks = new_size;
return SP_ERROR_OK;
}
// ----------------------------------------------------------------------------
//
TrackArray SpotifyEngine::getTracks( sp_playlist* pl ) {
TrackArray tracks;
int num_tracks = sp_playlist_num_tracks( pl );
for (int i=0; i < num_tracks; i++ ) {
sp_track* track = sp_playlist_track( pl, i );
sp_track_availability availability = sp_track_get_availability( m_spotify_session, track );
if ( availability == SP_TRACK_AVAILABILITY_AVAILABLE )
tracks.push_back( track );
}
return tracks;
}
int
sp_playlistcontainer_get_unseen_tracks(sp_playlistcontainer *pc, sp_playlist *_playlist, sp_track **tracks, int num_tracks)
{
sp_playlistcontainer_playlist_t *playlist = sp_mock_playlistcontainer_find_playlist(pc, _playlist);
bool seen = false;
int unseen_count = 0, i = 0, j = 0;
if ( ! playlist)
{
return -1;
}
for (i = 0; i < sp_playlist_num_tracks(_playlist); ++i)
{
sp_track *track = sp_playlist_track(_playlist, i);
seen = false;
if ( ! track)
{
continue;
}
for (j = 0; j < playlist->num_seen_tracks; ++j)
{
if (playlist->seen_tracks[j] == track)
{
seen = true;
}
}
if ( ! seen)
{
if (unseen_count < num_tracks)
{
tracks[unseen_count] = track;
}
unseen_count += 1;
}
}
return unseen_count;
}
static bool validate_complete_load()
{
if (g_list_container == NULL) {
return false;
}
sp_playlistcontainer *list_container = g_list_container;
int pl_count = sp_playlistcontainer_num_playlists(list_container);
int i=0;
for(; i < pl_count; i++) {
sp_playlist *l = sp_playlistcontainer_playlist(list_container, i);
sp_playlist_type type = sp_playlistcontainer_playlist_type(list_container, i);
if (type == SP_PLAYLIST_TYPE_PLAYLIST && !sp_playlist_is_loaded(l)) {
return false;
}
}
sp_playlist *source_list = NULL;
i=0;
for(; i < pl_count; i++) {
sp_playlist *l = sp_playlistcontainer_playlist(list_container, i);
const char* pname = sp_playlist_name(l);
if (strcmp(pname, playlist_name) == 0) {
source_list = l;
break;
}
}
if (source_list == NULL) {
fprintf(stderr, "Cannot find source list: %s\n", playlist_name);
exit(1);
}
int nt = sp_playlist_num_tracks(source_list);
i=0;
for(; i < nt; i++) {
sp_track *t = sp_playlist_track(source_list, i);
sp_artist *a = sp_track_artist(t,0); // get first artist on track because I am lazy
sp_album *al = sp_track_album(t);
if (al == NULL || a == NULL) {
return false;
}
}
return 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);
}
}
}
}
/*********************
* Tracks management *
*********************/
GArray* tracks_get_playlist(sp_playlist* pl) {
GArray* tracks;
sp_track* tr;
int i, n;
if (!sp_playlist_is_loaded(pl))
return NULL;
n = sp_playlist_num_tracks(pl);
tracks = g_array_sized_new(FALSE, FALSE, sizeof(sp_track*), n);
if (!tracks)
g_error("Can't allocate array of %d tracks.", n);
for (i=0; i < n; i++) {
tr = sp_playlist_track(pl, i);
sp_track_add_ref(tr);
g_array_append_val(tracks, tr);
}
return tracks;
}
void SpotWorker::emitLoggedInSignal(sp_session *session, sp_error error)
{
if (SP_ERROR_OK != error) {
fprintf(stderr, "SpotWorker: Login failed: %s\n",
sp_error_message(error));
}
else{
printf("SpotWorker: Successfully logged in\n");
emit loggedIn(session, error);
sp_playlistcontainer *playlists = sp_session_playlistcontainer(session);
void * userdata = NULL;
sp_playlistcontainer_add_callbacks(playlists,
&pc_callbacks,
userdata);
int listCount = sp_playlistcontainer_num_playlists(playlists);
printf("%d playlists discovered\n", sp_playlistcontainer_num_playlists(playlists));
if(listCount > 0)
emit playlistAdded(playlists);
for (int i = 0; i < listCount && i < 10; ++i) {
sp_playlist *pl = sp_playlistcontainer_playlist(playlists, i);
//TODO: register playback callback
//sp_playlist_add_callbacks(pl, &pl_callbacks, NULL);
if (sp_playlist_is_loaded(pl)){
DEBUG printf("Playlist found: %s (%i tracks)\n",
sp_playlist_name(pl), sp_playlist_num_tracks(pl));
}
}
DEBUG {
if (listCount > 10)
printf("...and %d more.\n", listCount-10);
}
}
}
void Spotify::tryLoadPlaylist()
{
if ((currentPlaylistIdx < 0) || (currentPlaylist == 0)) {
return;
}
if (sp_playlist_is_loaded(currentPlaylist)) {
QList<SpotifyTrackInfo> tracks;
int numTracks = sp_playlist_num_tracks(currentPlaylist);
for (int idx = 0; idx < numTracks; ++idx) {
sp_track * track = sp_playlist_track(currentPlaylist, idx);
if (!track) {
fprintf(stderr, "Spotify: failed to get track #%d\n", idx + 1);
continue;
}
QString name(sp_track_name(track));
if (name.isEmpty()) {
fprintf(stderr, "Spotify: got empty track name\n");
continue;
}
SpotifyTrackInfo info;
info.name = name;
info.URI = uriFromTrack(track);
if (info.URI.isEmpty()) {
continue;
}
tracks.append(info);
}
emit currentPlaylistUpdated(tracks);
fprintf(stderr, "Spotify: loaded playlist %s (%d tracks)\n",
sp_playlist_name(currentPlaylist),
tracks.size());
}
}
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);
}
}
}
}
}
}
bool XplodifyPlaylist::load_tracks() {
int n;
if(m_loading) {
return false;
}
boost::shared_ptr<XplodifySession> sess(m_session.lock());
n = sp_playlist_num_tracks(m_playlist);
lock();
for(int i=0 ; i<n ; i++) {
sp_track * t = sp_playlist_track(m_playlist, i);
track_cache_by_rand& tr_cache_rand = m_track_cache.get<0>();
std::pair<track_r_iterator, bool> p;
boost::shared_ptr<XplodifyTrack> tr(new XplodifyTrack(sess));
if(tr->load(t)){
std::string trname(tr->get_name());
track_entry tr_entry(trname, tr);
p = tr_cache_rand.push_back(tr_entry);
if(p.second) {
#ifdef _DEBUG
std::cout << "Track " << tr->get_name() << " loaded for playlist "
<< get_name() << std::endl;
#endif
} else {
m_pending_tracks.push_back(tr);
}
} else {
m_pending_tracks.push_back(tr);
}
}
sess->update_state_ts();
unlock();
return true;
}
static PyObject *Playlist_remove_tracks(Playlist *self, PyObject *args) {
PyObject *py_tracks;
PyObject *item;
sp_error err;
int *tracks;
int num_tracks;
int playlist_length;
int i;
if(!PyArg_ParseTuple(args, "O", &py_tracks))
return NULL;
if (!PySequence_Check(py_tracks)) {
PyErr_SetString(PyExc_TypeError, "expected sequence");
return NULL;
}
num_tracks = PySequence_Size(py_tracks);
tracks = (int *) malloc(sizeof(tracks)*num_tracks);
playlist_length = sp_playlist_num_tracks(self->_playlist);
for (i = 0; i < num_tracks; i++) {
item = PySequence_GetItem(py_tracks, i);
if (!PyInt_Check(item)) {
free(tracks);
PyErr_SetString(PyExc_TypeError, "expected sequence of integers");
return NULL;
}
tracks[i] = (int)PyInt_AsLong(item);
if (tracks[i] > playlist_length) {
PyErr_SetString(PyExc_IndexError, "specified track does not exist");
return NULL;
}
Py_DECREF(item);
}
Py_BEGIN_ALLOW_THREADS
err = sp_playlist_remove_tracks(self->_playlist, tracks, num_tracks);
Py_END_ALLOW_THREADS
return handle_error(err);
}
ListResponse<PlaylistInfo*>* SpotifyPlaylistContainer::listPlaylists(
PlaylistTask* task) {
ListResponse<PlaylistInfo*>* response = new ListResponse<PlaylistInfo*>();
response->setListType(ListTypePlaylist);
CommandInfo info = task->getCommandInfo();
bool sendName = ((info.ListFlags & Name) == Name);
bool sendNumTracks = ((info.ListFlags & NumTracks) == NumTracks);
bool sendDescription = ((info.ListFlags & Description) == Description);
int numPlaylists = sp_playlistcontainer_num_playlists(playlistContainer);
for (int i = 0; i < numPlaylists; i++) {
if (sp_playlistcontainer_playlist_type(playlistContainer, i)
== SP_PLAYLIST_TYPE_PLAYLIST) {
sp_playlist* playlist = sp_playlistcontainer_playlist(
playlistContainer, i);
const char* name = sp_playlist_name(playlist);
if (!(name[0] == '_' && name[1] == '_')) {
PlaylistInfo* playlistInfo = new PlaylistInfo();
playlistInfo->id = i;
if (sendName) {
playlistInfo->name = name;
}
if (sendNumTracks) {
playlistInfo->numTracks = sp_playlist_num_tracks(playlist);
}
if (sendDescription) {
playlistInfo->description = sp_playlist_get_description(
playlist);
}
response->addMember(playlistInfo);
}
}
}
return response;
}
sp_error
sp_playlist_add_tracks(sp_playlist *playlist, sp_track *const *tracks, int num_tracks, int position, sp_session *session)
{
int size = sp_playlist_num_tracks(playlist);
int new_size = size + num_tracks;
int i, j, k;
sp_playlist_track_t *new_tracks = NULL;
if (position < 0 || position > size)
{
return SP_ERROR_INVALID_INDATA;
}
new_tracks = ALLOC_N(sp_playlist_track_t, new_size);
for (i = 0, j = 0, k = 0; i < new_size; ++i)
{
if (i >= position && j < num_tracks)
{
new_tracks[i].track = tracks[j++];
new_tracks[i].create_time = (int) time(NULL); // let’s hope before year 2038 we fix this :)
new_tracks[i].creator = sp_session_user(session);
new_tracks[i].message = NULL;
new_tracks[i].seen = true;
}
else
{
MEMCPY(&new_tracks[i], &playlist->tracks[k++], sp_playlist_track_t);
}
}
free(playlist->tracks);
playlist->tracks = new_tracks;
playlist->num_tracks = new_size;
return SP_ERROR_OK;
}
int
sp_playlistcontainer_clear_unseen_tracks(sp_playlistcontainer *pc, sp_playlist *_playlist)
{
sp_playlistcontainer_playlist_t *playlist = sp_mock_playlistcontainer_find_playlist(pc, _playlist);
int i = 0;
if ( ! playlist)
{
return -1;
}
playlist->num_seen_tracks = 0;
xfree(playlist->seen_tracks);
playlist->num_seen_tracks = sp_playlist_num_tracks(_playlist);
playlist->seen_tracks = ALLOC_N(sp_track *, playlist->num_seen_tracks);
for (i = 0; i < playlist->num_seen_tracks; ++i)
{
playlist->seen_tracks[i] = sp_playlist_track(_playlist, i);
}
return 0;
}
static bool spiffify() {
if (!validate_complete_load()) {
return false;
}
sp_playlistcontainer *list_container = g_list_container;
// check to see if all playlists have been loaded
int pl_count = sp_playlistcontainer_num_playlists(list_container);
int i=0;
sp_playlist *source_list = NULL;
sp_playlist *spiffify_list = NULL;
char folder_name[256];
int spiffify_start_index = -1;
int spiffify_end_index = -1;
sp_uint64 spiffify_folder_id = -1;
i=0;
for(; i < pl_count; i++) {
sp_playlist *l = sp_playlistcontainer_playlist(list_container, i);
const char* pname = sp_playlist_name(l);
if (strcmp(pname, playlist_name) == 0) {
source_list = l;
}
sp_playlist_type type = sp_playlistcontainer_playlist_type(list_container, i);
if (type == SP_PLAYLIST_TYPE_START_FOLDER) {
sp_error error = sp_playlistcontainer_playlist_folder_name(list_container, i, folder_name, 256);
if (error == SP_ERROR_OK) {
if (strcmp(folder_name, SPIFFIFY_PLAYLIST_NAME) == 0) {
spiffify_list = l;
spiffify_start_index = i;
spiffify_folder_id = sp_playlistcontainer_playlist_folder_id(list_container, i);
}
}
}
else if (type == SP_PLAYLIST_TYPE_END_FOLDER) {
sp_uint64 id = sp_playlistcontainer_playlist_folder_id(list_container, i);
if (id == spiffify_folder_id) {
spiffify_end_index = i;
}
}
}
if (source_list == NULL) {
fprintf(stderr, "Cannot find source list: %s\n", playlist_name);
exit(1);
}
if (spiffify_list != NULL && spiffify_start_index != -1) {
// smoke the list and start over every time.. it's just not worth the effort of inserting changes.
int x=spiffify_end_index;
for(; x >= spiffify_start_index; x--) {
sp_playlistcontainer_remove_playlist(list_container, x);
}
spiffify_list = NULL;
spiffify_start_index = -1;
spiffify_end_index = -1;
}
pl_count = sp_playlistcontainer_num_playlists(list_container); // reset count.
if (spiffify_list == NULL) {
// make the Spiffify list for this user;
sp_error error = sp_playlistcontainer_add_folder(list_container, pl_count, SPIFFIFY_PLAYLIST_NAME);
if (error == SP_ERROR_OK) {
spiffify_list = sp_playlistcontainer_playlist(list_container, pl_count);
spiffify_start_index = pl_count;
spiffify_end_index = spiffify_start_index+1;
}
if (spiffify_list == NULL) {
fprintf(stderr, "Cannot create '%s' playlist\n", SPIFFIFY_PLAYLIST_NAME);
exit(1);
}
}
// iterate the source playlist
int nt = sp_playlist_num_tracks(source_list);
// allocate storage for tracks
sp_track **tracks = (sp_track **) malloc(nt * sizeof(sp_track *));
i=0;
for(; i < nt; i++) {
sp_track *t = sp_playlist_track(source_list, i);
tracks[i] = t; // store in the array
}
// :)
mergesort(tracks, nt, sizeof(sp_track *), &compare_tracks);
i=0;
for(; i < nt; i++) {
sp_track *t = tracks[i]; //sp_playlist_track(source_list, i);
sp_artist *a = sp_track_artist(t,0); // get first artist on track because I am lazy
// find artist folder inside our spiffify list
bool haveartist = false;
int j=spiffify_start_index;
char artist[256];
if (a != NULL) {
strcpy(artist, sp_artist_name(a));
}
else {
strcpy(artist, "Unknown Artist");
}
for(; j < spiffify_end_index; j++) {
sp_error error = sp_playlistcontainer_playlist_folder_name(list_container, j, folder_name, 256);
if (strcmp(artist, folder_name) == 0) {
haveartist = true;
break;
}
}
sp_album *al = sp_track_album(t);
while (al == NULL) {
printf("Cannot find album or it's not loaded.. forcing an event loop\n");
return false;
}
if (!haveartist) {
int artist_pos = spiffify_end_index;
sp_playlistcontainer_add_folder(list_container, artist_pos, artist);
spiffify_end_index+=2; // a folder adds 2 indexes.
pl_count = sp_playlistcontainer_num_playlists(list_container);
sp_playlist* album = sp_playlistcontainer_add_new_playlist(list_container, sp_album_name(al));
sp_playlist_add_tracks(album, &t, 1, 0, session);
sp_playlistcontainer_move_playlist(list_container, pl_count, artist_pos+1, false);
spiffify_end_index++; // one more for the album.
}
else {
int artist_pos = j;
sp_playlist *albumpl = find_album_playlist(list_container, &artist_pos, spiffify_end_index, al);
if (albumpl == NULL) {
pl_count = sp_playlistcontainer_num_playlists(list_container);
albumpl = sp_playlistcontainer_add_new_playlist(list_container, sp_album_name(al));
sp_playlistcontainer_move_playlist(list_container, pl_count, artist_pos+1, false);
spiffify_end_index++; // one more for the album.
}
sp_playlist_add_tracks(albumpl, &t, 1, 0, session);
}
}
free(tracks);
return true;
}
void check_playlist_status(sp_playlist *playlist)
{
printf("Playlist needs to load. Will cache on HD, so you won't need to wait this long again\n");
printf("waiting for playlist %s\n", sp_playlist_name(playlist));
printf("number of tracks %d\n", sp_playlist_num_tracks(playlist));
}
/**
* XXX: candidate to be deprecated, better use is the track iterator's count() function.
*/
PHP_METHOD(SpotifyPlaylist, getNumTracks)
{
spotifyplaylist_object *p = (spotifyplaylist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_LONG(sp_playlist_num_tracks(p->playlist));
}
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();
}
