bool Image::IsLoading() {
    if (!image_)
        return false;
    if (!sp_image_is_loaded(image_))
        return true;
    return false;
}
예제 #2
0
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
        {
예제 #3
0
파일: spotify.c 프로젝트: theodoor/spop
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;
}
예제 #4
0
SP_LIBEXPORT(sp_image *) sp_image_create(sp_session *session, const byte image_id[20]) {
    sp_image *image;
    void **container;
    struct image_ctx *image_ctx;


    image = osfy_image_create(session, image_id);
    sp_image_add_ref(image);

    if(sp_image_is_loaded(image))
        return image;


    /* Prevent the image from being loaded twice */
    if(image->error == SP_ERROR_IS_LOADING)
        return image;

    image->error = SP_ERROR_IS_LOADING;


    image_ctx = malloc(sizeof(struct image_ctx));
    image_ctx->session = session;
    image_ctx->req = NULL;
    image_ctx->image = image;

    container = (void **)malloc(sizeof(void *));
    *container = image_ctx;

    {
        char buf[41];
        hex_bytes_to_ascii(image->id, buf, 20);
        DSFYDEBUG("Requesting download of image '%s'\n", buf);
    }

    request_post(session, REQ_TYPE_IMAGE, container);

    return image;
}
예제 #5
0
파일: spotify.c 프로젝트: theodoor/spop
gboolean track_get_image_data(sp_track* track, gpointer* data, gsize* len) {
    sp_image* img;
    const guchar* img_data = NULL;

    img = track_get_image(track);
    if (!img) {
        /* No cover */
        *data = NULL;
        *len = 0;
        return TRUE;
    }

    if (!sp_image_is_loaded(img))
        return FALSE;

    img_data = sp_image_data(img, len);
    if (!img_data)
        g_error("Can't read image data");

    *data = g_memdup(img_data, *len);
    sp_image_release(img);
    return TRUE;
}
예제 #6
0
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);
}
예제 #7
0
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;

}
예제 #8
0
파일: image.c 프로젝트: bfirsh/pyspotify
static PyObject *Image_is_loaded(Image *self) {
    return Py_BuildValue("i", sp_image_is_loaded(self->_image));
}