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;
}
static PyObject *Image_add_load_callback(Image *self, PyObject *args) {
PyObject *callback;
PyObject *userdata;
image_callback_trampoline *tramp;
if(!PyArg_ParseTuple(args, "OO", &callback, &userdata))
return NULL;
Py_INCREF(callback);
Py_INCREF(userdata);
tramp = malloc(sizeof(image_callback_trampoline));
tramp->userdata = userdata;
tramp->callback = callback;
Py_BEGIN_ALLOW_THREADS
sp_image_add_load_callback(self->_image, image_callback, tramp);
Py_END_ALLOW_THREADS
Py_INCREF(Py_None);
return Py_None;
}
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);
}
}
gboolean track_get_image_file(sp_track* track, gchar** filename) {
if (!filename)
return FALSE;
sp_image* img = track_get_image(track);
if (!img) {
/* No cover */
*filename = NULL;
return FALSE;
}
/* Build filename */
const guchar* img_id = sp_image_image_id(img);
gchar* b64_id = g_base64_encode(img_id, 20);
gchar* img_name = g_strdup_printf("%s.jpg", b64_id);
/* Avoid / in base64-encoded file name! */
g_strdelimit(img_name, "/", '_');
*filename = g_build_filename(g_get_user_cache_dir(), g_get_prgname(), img_name, NULL);
g_free(b64_id);
g_free(img_name);
/* If the file already exists, we're done. */
if (g_file_test(*filename, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
sp_image_release(img);
}
/* If image is already loaded, write it to the file now */
else if (sp_image_is_loaded(img)) {
gchar* fn_copy = g_strdup(*filename);
_track_write_image_to_file(img, fn_copy);
}
/* Load the image and write it with a callback */
else {
gchar* fn_copy = g_strdup(*filename);
sp_image_add_load_callback(img, _track_write_image_to_file, fn_copy);
}
return TRUE;
}
jobject createJArtistInstance(JNIEnv *env, sp_artist *artist)
{
jclass jClass;
jobject artistInstance = createInstance(env,"jahspotify/media/Artist");
sp_link *artistLink = sp_link_create_from_artist(artist);
jClass = (*env)->FindClass(env, "jahspotify/media/Artist");
if (jClass == NULL)
{
fprintf(stderr,"jahspotify::createJArtistInstance: could not load jahnotify.media.Artist\n");
return NULL;
}
if (artistLink)
{
sp_link_add_ref(artistLink);
jobject artistJLink = createJLinkInstance(env, artistLink);
setObjectObjectField(env,artistInstance,"id","Ljahspotify/media/Link;",artistJLink);
sp_link_release(artistLink);
setObjectStringField(env,artistInstance,"name",sp_artist_name(artist));
sp_artistbrowse *artistBrowse = sp_artistbrowse_create(g_sess,artist,artistBrowseCompleteCallback,NULL);
if (artistBrowse)
{
sp_artistbrowse_add_ref(artistBrowse);
while (!sp_artistbrowse_is_loaded(artistBrowse))
{
usleep(100);
}
int numSimilarArtists = sp_artistbrowse_num_similar_artists(artistBrowse);
if (numSimilarArtists > 0)
{
jmethodID jMethod = (*env)->GetMethodID(env,jClass,"addSimilarArtist","(Ljahspotify/media/Link;)V");
if (jMethod == NULL)
{
fprintf(stderr,"jahspotify::createJTrackInstance: could not load method setAlbum(link) on class Track\n");
return NULL;
}
// Load the artist links
int count = 0;
for (count = 0; count < numSimilarArtists; count++)
{
sp_artist *similarArtist = sp_artistbrowse_similar_artist(artistBrowse,0);
if (similarArtist)
{
sp_artist_add_ref(similarArtist);
sp_link *similarArtistLink = sp_link_create_from_artist(similarArtist);
if (similarArtistLink)
{
sp_link_add_ref(similarArtistLink);
jobject similarArtistJLink = createJLinkInstance(env,similarArtistLink);
// set it on the track
(*env)->CallVoidMethod(env,artistInstance,jMethod,similarArtistJLink);
sp_link_release(similarArtistLink);
}
sp_artist_release(similarArtist);
}
}
}
int numPortraits = sp_artistbrowse_num_portraits(artistBrowse);
if (numPortraits > 0)
{
// Load portrait url
const byte *portraitURI = sp_artistbrowse_portrait(artistBrowse,0);
if (portraitURI)
{
char *portraitURIStr = toHexString((byte*)portraitURI);
const char spotifyURI[] = "spotify:image:";
int len = strlen(spotifyURI) + strlen(portraitURIStr);
char *dest = malloc(len+1);
dest[0] = 0;
strcat(dest,spotifyURI);
strcat(dest,portraitURIStr);
sp_link *portraitLink = sp_link_create_from_string(dest);
sp_image *portrait = sp_image_create_from_link(g_sess,portraitLink);
if (portrait)
{
sp_image_add_ref(portrait);
sp_image_add_load_callback(portrait,imageLoadedCallback,NULL);
}
free(dest);
free(portraitURIStr);
if (portraitLink)
{
sp_link_add_ref(portraitLink);
jobject portraitJLlink = createJLinkInstance(env,portraitLink);
setObjectObjectField(env,artistInstance,"portrait","Ljahspotify/media/Link;",portraitJLlink);
sp_link_release(portraitLink);
}
}
}
// sp_artistbrowse_num_albums()
// sp_artistbrowse_album()
const char *bios = sp_artistbrowse_biography(artistBrowse);
if (bios)
{
setObjectStringField(env,artistInstance,"bios",bios);
}
// sp_artistbrowse_num_tracks()
// sp_artistbrowse_track()
sp_artistbrowse_release(artistBrowse);
}
}
return artistInstance;
}
jobject createJAlbumInstance(JNIEnv *env, sp_album *album)
{
jclass albumJClass;
jobject albumInstance;
albumJClass = (*env)->FindClass(env, "jahspotify/media/Album");
if (albumJClass == NULL)
{
fprintf(stderr,"jahspotify::createJAlbumInstance: could not load jahnotify.media.Album\n");
return NULL;
}
albumInstance = (*env)->AllocObject(env,albumJClass);
if (!albumInstance)
{
fprintf(stderr,"jahspotify::createJAlbumInstance: could not create instance of jahspotify.media.Album\n");
return NULL;
}
sp_albumbrowse *albumBrowse = sp_albumbrowse_create(g_sess,album,albumBrowseCompleteCallback,NULL);
if (albumBrowse)
{
sp_albumbrowse_add_ref(albumBrowse);
int count = 0;
while (!sp_albumbrowse_is_loaded(albumBrowse) && count < 5)
{
fprintf(stderr,"jahspotify::createJAlbumInstance: waiting for album browse load to complete\n");
sleep(1);
count++;
}
if (count == 5)
{
sp_albumbrowse_release(albumBrowse);
return NULL;
}
// By now it looks like the album will also be loaded
sp_link *albumLink = sp_link_create_from_album(album);
if (albumLink)
{
sp_link_add_ref(albumLink);
jobject albumJLink = createJLinkInstance(env, albumLink);
setObjectObjectField(env,albumInstance,"id","Ljahspotify/media/Link;",albumJLink);
setObjectStringField(env,albumInstance,"name",sp_album_name(album));
setObjectIntField(env,albumInstance,"year",sp_album_year(album));
sp_albumtype albumType = sp_album_type(album);
jclass albumTypeJClass = (*env)->FindClass(env, "jahspotify/media/AlbumType");
jmethodID jMethod = (*env)->GetStaticMethodID(env,albumTypeJClass,"fromOrdinal","(I)Ljahspotify/media/AlbumType;");
jobject albumTypeEnum = (jobjectArray)(*env)->CallStaticObjectMethod(env, albumTypeJClass, jMethod,(int)albumType);
setObjectObjectField(env,albumInstance,"type","Ljahspotify/media/AlbumType;",albumTypeEnum);
sp_link *albumCoverLink = sp_link_create_from_album_cover(album);
if (albumCoverLink)
{
sp_link_add_ref(albumCoverLink);
jobject albumCoverJLink = createJLinkInstance(env, albumCoverLink);
setObjectObjectField(env,albumInstance,"cover","Ljahspotify/media/Link;",albumCoverJLink);
sp_image *albumCoverImage = sp_image_create_from_link(g_sess,albumCoverLink);
if (albumCoverImage)
{
sp_image_add_ref(albumCoverImage);
sp_image_add_load_callback(albumCoverImage,imageLoadedCallback,NULL);
}
sp_link_release(albumCoverLink);
}
sp_artist *artist = sp_album_artist(album);
if (artist)
{
sp_artist_add_ref(artist);
sp_link *artistLink = sp_link_create_from_artist(artist);
if (artistLink)
{
sp_link_add_ref(artistLink);
jobject artistJLink = createJLinkInstance(env,artistLink);
setObjectObjectField(env,albumInstance,"artist","Ljahspotify/media/Link;",artistJLink);
sp_link_release(artistLink);
}
sp_artist_release(artist);
}
sp_link_release(albumLink);
}
int numTracks = sp_albumbrowse_num_tracks(albumBrowse);
if (numTracks > 0)
{
// Add each track to the album - also pass in the disk as need be
jmethodID addTrackJMethodID = (*env)->GetMethodID(env,albumJClass,"addTrack","(ILjahspotify/media/Link;)V");
int i = 0;
for (i = 0; i < numTracks; i++)
{
sp_track *track = sp_albumbrowse_track(albumBrowse,i);
if (track)
{
sp_track_add_ref(track);
sp_link *trackLink = sp_link_create_from_track(track,0);
if (trackLink)
{
sp_link_add_ref(trackLink);
jobject trackJLink = createJLinkInstance(env,trackLink);
(*env)->CallVoidMethod(env, albumInstance, addTrackJMethodID,sp_track_disc(track),trackJLink);
sp_link_release(trackLink);
}
}
}
}
int numCopyrights = sp_albumbrowse_num_copyrights(albumBrowse);
if (numCopyrights > 0)
{
// Add copyrights to album
jmethodID addCopyrightMethodID = (*env)->GetMethodID(env,albumJClass,"addCopyright","(Ljava/lang/String;)V");
int i = 0;
for (i = 0; i < numCopyrights; i++)
{
const char *copyright = sp_albumbrowse_copyright(albumBrowse,i);
if (copyright)
{
jstring str = (*env)->NewStringUTF(env, copyright);
(*env)->CallVoidMethod(env, albumInstance, addCopyrightMethodID,str);
}
}
}
const char *review = sp_albumbrowse_review(albumBrowse);
if (review)
{
setObjectStringField(env,albumInstance,"review",review);
}
sp_albumbrowse_release(albumBrowse);
}
return albumInstance;
}
JNIEXPORT int JNICALL Java_jahspotify_impl_JahSpotifyImpl_readImage (JNIEnv *env, jobject obj, jstring uri, jobject outputStream)
{
uint8_t *nativeURI = ( uint8_t * ) ( *env )->GetStringUTFChars ( env, uri, NULL );
sp_link *imageLink = sp_link_create_from_string(nativeURI);
size_t size;
jclass jClass;
int numBytesWritten = -1;
if (imageLink)
{
sp_link_add_ref(imageLink);
sp_image *image = sp_image_create_from_link(g_sess,imageLink);
if (image)
{
sp_image_add_ref(image);
sp_image_add_load_callback(image, imageLoadedCallback, NULL);
int count = 0;
while (!sp_image_is_loaded(image) && count < 5)
{
sleep(1);
count++;
}
if (count == 5)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_readImage: Timeout waiting for image to load ...\n");
sp_image_release(image);
sp_link_release(imageLink);
return -1;
}
byte *data = (byte*)sp_image_data(image,&size);
jClass = (*env)->FindClass(env,"Ljava/io/OutputStream;");
if (jClass == NULL)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_readImage: could not load class java.io.OutputStream\n");
return -1;
}
// Lookup the method now - saves us looking it up for each iteration of the loop
jmethodID jMethod = (*env)->GetMethodID(env,jClass,"write","(I)V");
if (jMethod == NULL)
{
fprintf(stderr,"jahspotify::Java_jahspotify_impl_JahSpotifyImpl_readImage: could not load method write(int) on class java.io.OutputStream\n");
return -1;
}
int i = 0;
for (i = 0; i < size; i++)
{
(*env)->CallVoidMethod(env,outputStream,jMethod,*data);
data++;
numBytesWritten++;
}
sp_image_release(image);
}
sp_link_release(imageLink);
}
// Plus one because we start at -1
return numBytesWritten+1;
}
