void Spotify::Session::loadCoverart( const byte* coverartIdentifier,
Spotify::ImageContainer* imageContainer )
{
if( coverartIdentifier && imageContainer )
{
sp_image* image = sp_image_create( m_session, coverartIdentifier );
if( image )
{
// Already loaded:
if( sp_image_is_loaded( image ) )
{
Spotify::ImageData* imageData = new Spotify::ImageData( image );
imageContainer->imageReadySlot( imageData, imageContainer );
}
// Load:
else
{
sp_image_add_load_callback( image, &Spotify::Session::imageLoadedCallback,
imageContainer );
connect( this, SIGNAL(coverArtReady(Spotify::ImageData*,Spotify::ImageContainer*)),
imageContainer, SLOT(imageReadySlot(Spotify::ImageData*,Spotify::ImageContainer*)) );
}
}
else
{
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;
}
sp_image* track_get_image(sp_track* track) {
sp_album* alb = NULL;
sp_image* img = NULL;
const void* img_id = NULL;
/* Get album */
alb = sp_track_album(track);
if (!alb)
g_error("Can't get track album.");
sp_album_add_ref(alb);
if (!sp_album_is_loaded(alb))
g_error("Album not loaded.");
/* Get image */
img_id = sp_album_cover(alb, SP_IMAGE_SIZE_NORMAL);
if (!img_id) {
/* Since the album is loaded, a NULL here indicates that there is no
cover for this album. */
sp_album_release(alb);
return NULL;
}
img = sp_image_create(g_session, img_id);
sp_album_release(alb);
if (!img)
g_error("Can't create image.");
return img;
}
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;
}
PyObject *Session_image_create(Session *self, PyObject *args) {
char *image_id;
size_t len;
if(!PyArg_ParseTuple(args, "s#", &image_id, &len))
return NULL;
assert(len == 20);
Image *i = PyObject_CallObject((PyObject *)&ImageType, NULL);
i->_image = sp_image_create(self->_session, image_id);
return (PyObject *)i;
}
sp_image *Track::albumImage(SpotifySession *session) const
{
if(isValid()) {
sp_album *album = sp_track_album(m_spTrack);
if (album) {
const byte *id = sp_album_cover(album);
return sp_image_create(session->session(), id);
}
}
return NULL;
}
static PyObject *
Session_image_create(Session * self, PyObject *args)
{
byte *image_id;
size_t len;
sp_image *image;
if (!PyArg_ParseTuple(args, "s#", &image_id, &len))
return NULL;
if (len != 20) {
PyErr_SetString(SpotifyError, "Image id length != 20");
return NULL;
}
image = sp_image_create(self->_session, image_id);
return Image_FromSpotify(image);
}
static PyObject *
Session_image_create(PyObject *self, PyObject *args)
{
byte *image_id;
size_t len;
sp_image *image;
if (!PyArg_ParseTuple(args, "s#", &image_id, &len))
return NULL;
if ((int)len != 20) {
PyErr_SetString(SpotifyError, "Image id length != 20");
return NULL;
}
image = sp_image_create(Session_SP_SESSION(self), image_id);
return Image_FromSpotify(image, 0 /* add_ref */);
}
void QSpotifySession::sendImageRequest(const QString &id)
{
qDebug() << "QSpotifySession::sendImageRequest" << id;
sp_image *image = nullptr;
byte *idPtr = QSpotifyPlaylist::getImageIdPtr(id);
if(idPtr)
image = sp_image_create(m_sp_session, idPtr);
else {
sp_link *link = sp_link_create_from_string(id.toUtf8().constData());
if(link) {
image = sp_image_create_from_link(m_sp_session, link);
sp_link_release(link);
}
}
if (image) {
g_imageRequestObject.insert(image, id);
sp_image_add_load_callback(image, callback_image_loaded, nullptr);
}
}
PHP_METHOD(SpotifyArtist, getPortrait)
{
int timeout = 0;
zval *index, *object = getThis();
spotifyartist_object *p = (spotifyartist_object*)zend_object_store_get_object(object TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
return;
}
zval tempretval, *thisptr = getThis();
SPOTIFY_METHOD(SpotifyArtist, browse, &tempretval, thisptr);
int numportraits = sp_artistbrowse_num_portraits(p->artistbrowse);
if(Z_LVAL_P(index) > numportraits)
{
RETURN_FALSE;
}
const byte* image_id = sp_artistbrowse_portrait(p->artistbrowse, Z_LVAL_P(index));
sp_image *image = sp_image_create(p->session, image_id);
while(!sp_image_is_loaded(image))
{
sp_session_process_events(p->session, &timeout);
}
size_t size;
const byte* image_data = sp_image_data(image, &size);
RETURN_STRINGL(image_data, size, 1);
sp_image_release(image);
}
sp_search *
sp_mock_search_create(sp_error error, const char *query, const char *did_you_mean,
int total_tracks, int num_tracks, const sp_track **tracks,
int total_albums, int num_albums, const sp_album **albums,
int total_artists, int num_artists, const sp_artist **artists,
int total_playlists, int num_playlists, const sp_playlist **playlists,
search_complete_cb *callback, void *userdata)
{
int i = 0, length = 0;
sp_link *uri = NULL;
sp_session *session = NULL;
sp_image *image = NULL;
sp_search *search = ALLOC(sp_search);
search->error = error;
search->query = strclone(query);
if (did_you_mean)
{
search->did_you_mean = strclone(did_you_mean);
}
search->total_tracks = total_tracks;
search->total_artists = total_artists;
search->total_albums = total_albums;
search->total_playlists = total_playlists;
search->num_tracks = num_tracks;
search->num_artists = num_artists;
search->num_albums = num_albums;
search->num_playlists =
search->num_playlist_names =
search->num_playlist_uris =
search->num_playlist_image_uris = num_playlists;
search->tracks = ALLOC_N(sp_track *, num_tracks);
search->artists = ALLOC_N(sp_artist *, num_artists);
search->albums = ALLOC_N(sp_album *, num_artists);
MEMCPY_N(search->tracks, tracks, sp_track *, num_tracks);
MEMCPY_N(search->artists, artists, sp_artist *, num_artists);
MEMCPY_N(search->albums, albums, sp_album *, num_albums);
search->playlist_names = ALLOC_N(char *, num_playlists);
search->playlist_uris = ALLOC_N(char *, num_playlists);
search->playlist_image_uris = ALLOC_N(char *, num_playlists);
for (i = 0; i < num_playlists; ++i)
{
const sp_playlist *playlist = playlists[i];
search->playlist_names[i] = strclone(playlist->name);
uri = sp_link_create_from_playlist((sp_playlist *) playlist);
if (uri)
{
length = sp_link_as_string(uri, NULL, 0);
search->playlist_uris[i] = ALLOC_STR(length);
sp_link_as_string(uri, search->playlist_uris[i], length + 1);
}
if (playlist->image)
{
image = sp_image_create(session, playlist->image);
if (image)
{
uri = sp_link_create_from_image(image);
length = sp_link_as_string(uri, NULL, 0);
search->playlist_image_uris[i] = ALLOC_STR(length);
sp_link_as_string(uri, search->playlist_image_uris[i], length + 1);
}
}
}
search->callback = callback;
search->userdata = userdata;
return search;
}
bool Image::Load(const byte *image_id) {
image_ = sp_image_create(session_->session_, image_id);
return (image_ != NULL);
}
