audioscrobbler: rewrite for new protocol 1.2
authorRafaël Carré <funman@videolan.org>
Sun, 7 Oct 2007 22:07:07 +0000 (22:07 +0000)
committerRafaël Carré <funman@videolan.org>
Sun, 7 Oct 2007 22:07:07 +0000 (22:07 +0000)
allocate as much as we can on the stack, to avoid numerous malloc() & free()
fix memory leaks by the same way
metadata reading is now performed exclusively from the callbacks
don't use linked lists anymore, but a queue of a fixed size of 50 songs, i.e. the maximum we can transmit in one submission.
properly unloads the module when encountering a fatal error, like no username/pw, no memory, VLC being banned by last.fm servers ...

modules/misc/audioscrobbler.c

index 576baae..980f268 100644 (file)
@@ -1,11 +1,10 @@
 /*****************************************************************************
  * audioscrobbler.c : audioscrobbler submission plugin
  *****************************************************************************
 /*****************************************************************************
  * audioscrobbler.c : audioscrobbler submission plugin
  *****************************************************************************
- * Copyright (C) 2006 the VideoLAN team
+ * Copyright (C) 2006-2007 the VideoLAN team
  * $Id$
  *
  * $Id$
  *
- * Authors: Rafaël Carré <funman at videolan org>
- *          Kenneth Ostby <kenneo -at- idi -dot- ntnu -dot- no>
+ * Author: Rafaël Carré <funman at videolanorg>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
-/* audioscrobbler protocol version: 1.1
- * http://audioscrobbler.net/wiki/Protocol1.1
- * */
-
+/* audioscrobbler protocol version: 1.2
+ * http://www.audioscrobbler.net/development/protocol/
+ *
+ * TODO:    "Now Playing" feature (not mandatory)
+ */
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
 
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
 
-
 #if defined( WIN32 )
 #include <time.h>
 #endif
 #if defined( WIN32 )
 #include <time.h>
 #endif
 /* Keeps track of metadata to be submitted */
 typedef struct audioscrobbler_song_t
 {
 /* Keeps track of metadata to be submitted */
 typedef struct audioscrobbler_song_t
 {
-    char        *psz_a;                /* track artist     */
-    char        *psz_t;                /* track title      */
-    char        *psz_b;                /* track album      */
-    int         i_l;                   /* track length     */
-    char        *psz_m;                /* musicbrainz id   */
-    char        *psz_i;                /* date             */
-    time_t      time_playing;          /* date (epoch)     */
+    char        *psz_a;             /**< track artist     */
+    char        *psz_t;             /**< track title      */
+    char        *psz_b;             /**< track album      */
+    char        *psz_n;             /**< track number     */
+    int         i_l;                /**< track length     */
+    char        *psz_m;             /**< musicbrainz id   */
+    time_t      date;               /**< date since epoch */
 } audioscrobbler_song_t;
 
 } audioscrobbler_song_t;
 
-
-/* Queue to be submitted to server, 10 songs max */
-typedef struct audioscrobbler_queue_t
-{
-    audioscrobbler_song_t   **p_queue;      /* contains up to 10 songs        */
-    int                     i_songs_nb;     /* number of songs                */
-    void                    *p_next_queue;  /* if queue full, pointer to next */
-} audioscrobbler_queue_t;
-
 struct intf_sys_t
 {
 struct intf_sys_t
 {
-    audioscrobbler_queue_t  *p_first_queue;     /* 1st queue              */
-    vlc_mutex_t             lock;               /* p_sys mutex            */
+    audioscrobbler_song_t   p_queue[50];        /**< songs not submitted yet*/
+    int                     i_songs;            /**< number of songs        */
+
+    vlc_mutex_t             lock;               /**< p_sys mutex            */
 
     /* data about audioscrobbler session */
 
     /* data about audioscrobbler session */
-    time_t                  time_next_exchange; /* when can we send data? */
-    char                    *psz_submit_host;   /* where to submit data ? */
-    int                     i_submit_port;      /* at which port ?        */
-    char                    *psz_submit_file;   /* in which file ?        */
-    char                    *psz_username;      /* last.fm username       */
-    vlc_bool_t              b_handshaked;       /* did we handshake ?     */
-    char                    *psz_response_md5;  /* md5 response to use    */
+    time_t                  next_exchange;      /**< when can we send data  */
+    unsigned int            i_interval;         /**< waiting interval (secs)*/
+
+    /* submission of played songs */
+    char                    *psz_submit_host;   /**< where to submit data   */
+    int                     i_submit_port;      /**< port to which submit   */
+    char                    *psz_submit_file;   /**< file to which submit   */
+
+    /* submission of playing song */
+#if 0 //NOT USED
+    char                    *psz_nowp_host;     /**< where to submit data   */
+    int                     i_nowp_port;        /**< port to which submit   */
+    char                    *psz_nowp_file;     /**< file to which submit   */
+#endif
+    vlc_bool_t              b_handshaked;       /**< are we authenticated ? */
+    char                    psz_auth_token[33]; /**< authentification token */
 
     /* data about song currently playing */
 
     /* data about song currently playing */
-    audioscrobbler_song_t   *p_current_song;    /* song being played      */
-    time_t                  time_pause;         /* time when vlc paused   */
-    time_t                  time_total_pauses;  /* sum of time in pause   */
-    vlc_bool_t              b_queued;           /* has it been queud ?    */
-    vlc_bool_t              b_metadata_read;    /* did we read metadata ? */
-    vlc_bool_t              b_paused;           /* is vlc paused ?        */
-    vlc_bool_t              b_waiting_meta;     /* we need fetched data?  */
+    audioscrobbler_song_t   p_current_song;     /**< song being played      */
+
+    time_t                  time_pause;         /**< time when vlc paused   */
+    time_t                  time_total_pauses;  /**< total time in pause    */
+
+    vlc_bool_t              b_submit;           /**< do we have to submit ? */
+    vlc_bool_t              b_paused;           /**< is vlc paused ?        */
+
+    vlc_bool_t              b_state_cb;         /**< if we registered the
+                                                 * "state" callback         */
+    vlc_bool_t              b_preparsed_cb;     /**< if we registered the
+                                                 * "meta-preparsed" callback*/
 };
 
 };
 
-intf_sys_t *p_sys_global;     /* to retrieve p_sys in Run() thread */
+static int  Open            ( vlc_object_t * );
+static void Close           ( vlc_object_t * );
+static void Unload          ( intf_thread_t * );
+
+static void Run             ( intf_thread_t * );
+static void Main            ( intf_thread_t * );
 
 
-static int  Open        ( vlc_object_t * );
-static void Close       ( vlc_object_t * );
-static void Run         ( intf_thread_t * );
-static void Main        ( intf_thread_t * );
-static int ItemChange   ( vlc_object_t *, const char *, vlc_value_t,
+static int ItemChange       ( vlc_object_t *, const char *, vlc_value_t,
                                 vlc_value_t, void * );
                                 vlc_value_t, void * );
-static int PlayingChange( vlc_object_t *, const char *, vlc_value_t,
+static int PlayingChange    ( vlc_object_t *, const char *, vlc_value_t,
                                 vlc_value_t, void * );
                                 vlc_value_t, void * );
-static int AddToQueue   ( intf_thread_t *p_this );
-static int Handshake    ( intf_thread_t *p_sd );
-static int ReadMetaData ( intf_thread_t *p_this );
-void DeleteQueue        ( audioscrobbler_queue_t *p_queue );
+static int MetaPreparsed    ( vlc_object_t *, const char *, vlc_value_t,
+                                vlc_value_t, void * );
+
+static int AddToQueue       ( intf_thread_t * );
+static int Handshake        ( intf_thread_t * );
+static int ReadMetaData     ( intf_thread_t * );
+static void DeleteSong      ( audioscrobbler_song_t* );
+static int ParseURL         ( char *, char **, char **, int * );
+static void HandleInterval  ( time_t *, unsigned int * );
 
 /*****************************************************************************
  * Module descriptor
 
 /*****************************************************************************
  * Module descriptor
@@ -119,8 +131,8 @@ void DeleteQueue        ( audioscrobbler_queue_t *p_queue );
 #define PASSWORD_TEXT       N_("Password")
 #define PASSWORD_LONGTEXT   N_("The password of your last.fm account")
 
 #define PASSWORD_TEXT       N_("Password")
 #define PASSWORD_LONGTEXT   N_("The password of your last.fm account")
 
-/* if something goes wrong, we wait at least one minute before trying again */
-#define DEFAULT_INTERVAL 60
+/* This error value is used when last.fm plugin has to be unloaded. */
+#define VLC_AUDIOSCROBBLER_EFATAL -69
 
 /* last.fm client identifier */
 #define CLIENT_NAME     PACKAGE
 
 /* last.fm client identifier */
 #define CLIENT_NAME     PACKAGE
@@ -138,16 +150,11 @@ void DeleteQueue        ( audioscrobbler_queue_t *p_queue );
                         "%s\r\n"                                            \
                         "\r\n"
 
                         "%s\r\n"                                            \
                         "\r\n"
 
-/* data to submit */
-#define POST_DATA       "&a%%5B%d%%5D=%s&t%%5B%d%%5D=%s&b%%5B%d%%5D=%s" \
-                        "&m%%5B%d%%5D=%s&l%%5B%d%%5D=%d&i%%5B%d%%5D=%s"
-#define HTTPPOST_MAXLEN 2048
-
 vlc_module_begin();
     set_category( CAT_INTERFACE );
     set_subcategory( SUBCAT_INTERFACE_CONTROL );
     set_shortname( N_( "Audioscrobbler" ) );
 vlc_module_begin();
     set_category( CAT_INTERFACE );
     set_subcategory( SUBCAT_INTERFACE_CONTROL );
     set_shortname( N_( "Audioscrobbler" ) );
-    set_description( N_("Audioscrobbler submission Plugin") );
+    set_description( N_("Submission of played songs to last.fm") );
     add_string( "lastfm-username", "", NULL,
                 USERNAME_TEXT, USERNAME_LONGTEXT, VLC_FALSE );
     add_password( "lastfm-password", "", NULL,
     add_string( "lastfm-username", "", NULL,
                 USERNAME_TEXT, USERNAME_LONGTEXT, VLC_FALSE );
     add_password( "lastfm-password", "", NULL,
@@ -159,62 +166,19 @@ vlc_module_end();
 /*****************************************************************************
  * Open: initialize and create stuff
  *****************************************************************************/
 /*****************************************************************************
  * Open: initialize and create stuff
  *****************************************************************************/
-
 static int Open( vlc_object_t *p_this )
 {
     playlist_t      *p_playlist;
     intf_thread_t   *p_intf     = ( intf_thread_t* ) p_this;
 static int Open( vlc_object_t *p_this )
 {
     playlist_t      *p_playlist;
     intf_thread_t   *p_intf     = ( intf_thread_t* ) p_this;
-    intf_sys_t      *p_sys      = malloc( sizeof( intf_sys_t ) );
-
-#define MEM_ERROR \
-    free( p_sys->p_current_song ); \
-    free( p_sys->p_first_queue ); \
-    free( p_sys->psz_response_md5 ); \
-    free( p_sys ); \
-    return VLC_ENOMEM;
+    intf_sys_t      *p_sys      = calloc( 1, sizeof( intf_sys_t ) );
 
     if( !p_sys )
 
     if( !p_sys )
-    {
-        MEM_ERROR
-    }
+        return VLC_ENOMEM;
 
     p_intf->p_sys = p_sys;
 
     vlc_mutex_init( p_this, &p_sys->lock );
 
 
     p_intf->p_sys = p_sys;
 
     vlc_mutex_init( p_this, &p_sys->lock );
 
-    p_sys_global = p_sys;
-    p_sys->psz_submit_host = NULL;
-    p_sys->psz_submit_file = NULL;
-    p_sys->b_handshaked = VLC_FALSE;
-    p_sys->time_next_exchange = time( NULL );
-    p_sys->psz_username = NULL;
-    p_sys->b_paused = VLC_FALSE;
-
-#define MALLOC_CHECK( a ) \
-    if( !a ) { \
-        vlc_mutex_destroy( &p_sys->lock ); \
-        MEM_ERROR \
-    }
-
-    /* md5 response is 32 chars, + final \0 */
-    p_sys->psz_response_md5 = malloc( 33 );
-    MALLOC_CHECK( p_sys->psz_response_md5 )
-
-    p_sys->p_first_queue = malloc( sizeof( audioscrobbler_queue_t ) );
-    MALLOC_CHECK( p_sys->p_first_queue )
-
-    p_sys->p_current_song = malloc( sizeof( audioscrobbler_song_t ) );
-    MALLOC_CHECK( p_sys->p_current_song )
-    time( &p_sys->p_current_song->time_playing );
-
-    /* queues can't contain more than 10 songs */
-    p_sys->p_first_queue->p_queue =
-        malloc( 10 * sizeof( audioscrobbler_song_t ) );
-    MALLOC_CHECK( p_sys->p_current_song )
-
-    p_sys->p_first_queue->i_songs_nb = 0;
-    p_sys->p_first_queue->p_next_queue = NULL;
-
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
     var_AddCallback( p_playlist, "playlist-current", ItemChange, p_intf );
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
     var_AddCallback( p_playlist, "playlist-current", ItemChange, p_intf );
@@ -224,8 +188,6 @@ static int Open( vlc_object_t *p_this )
     p_intf->pf_run = Run;
 
     return VLC_SUCCESS;
     p_intf->pf_run = Run;
 
     return VLC_SUCCESS;
-#undef MEM_ERROR
-#undef MALLOC_CHECK
 }
 
 /*****************************************************************************
 }
 
 /*****************************************************************************
@@ -233,7 +195,6 @@ static int Open( vlc_object_t *p_this )
  *****************************************************************************/
 static void Close( vlc_object_t *p_this )
 {
  *****************************************************************************/
 static void Close( vlc_object_t *p_this )
 {
-    audioscrobbler_queue_t      *p_current_queue, *p_next_queue;
     playlist_t                  *p_playlist;
     input_thread_t              *p_input;
     intf_thread_t               *p_intf = ( intf_thread_t* ) p_this;
     playlist_t                  *p_playlist;
     input_thread_t              *p_input;
     intf_thread_t               *p_intf = ( intf_thread_t* ) p_this;
@@ -241,46 +202,57 @@ static void Close( vlc_object_t *p_this )
 
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
 
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
+
     var_DelCallback( p_playlist, "playlist-current", ItemChange, p_intf );
 
     p_input = p_playlist->p_input;
     if ( p_input )
     {
         vlc_object_yield( p_input );
     var_DelCallback( p_playlist, "playlist-current", ItemChange, p_intf );
 
     p_input = p_playlist->p_input;
     if ( p_input )
     {
         vlc_object_yield( p_input );
-        var_DelCallback( p_input, "state", PlayingChange, p_intf );
+
+        if( p_sys->b_state_cb )
+            var_DelCallback( p_input, "state", PlayingChange, p_intf );
+        if( p_sys->b_preparsed_cb )
+            var_DelCallback( p_input, "meta-preparsed", MetaPreparsed, p_intf );
+
         vlc_object_release( p_input );
     }
 
     PL_UNLOCK;
     pl_Release( p_playlist );
 
         vlc_object_release( p_input );
     }
 
     PL_UNLOCK;
     pl_Release( p_playlist );
 
+    p_intf->b_dead = VLC_TRUE;
+    /* we lock the mutex in case p_sys is being accessed from a callback */
     vlc_mutex_lock ( &p_sys->lock );
     vlc_mutex_lock ( &p_sys->lock );
-    p_current_queue = p_sys->p_first_queue;
-    vlc_mutex_unlock ( &p_sys->lock );
-
-    while( ( p_current_queue->i_songs_nb == 10 ) &&
-        ( p_current_queue->p_next_queue != NULL ) )
-    {
-        p_next_queue = p_current_queue->p_next_queue;
-        DeleteQueue( p_current_queue );
-        free( p_current_queue );
-        p_current_queue = p_next_queue;
-    }
-
-    DeleteQueue( p_current_queue );
-    free( p_current_queue );
-
-    vlc_mutex_lock ( &p_sys->lock );
-    free( p_sys->psz_username );
-    free( p_sys->p_current_song );
+    int i;
+    for( i = 0; i < p_sys->i_songs; i++ )
+        DeleteSong( &p_sys->p_queue[i] );
     free( p_sys->psz_submit_host );
     free( p_sys->psz_submit_file );
     free( p_sys->psz_submit_host );
     free( p_sys->psz_submit_file );
-    free( p_sys->psz_response_md5 );
+#if 0 //NOT USED
+    free( p_sys->psz_nowp_host );
+    free( p_sys->psz_nowp_file );
+#endif
     vlc_mutex_unlock ( &p_sys->lock );
     vlc_mutex_destroy( &p_sys->lock );
     free( p_sys );
 }
 
     vlc_mutex_unlock ( &p_sys->lock );
     vlc_mutex_destroy( &p_sys->lock );
     free( p_sys );
 }
 
+
+/*****************************************************************************
+ * Unload: Unloads the audioscrobbler when encountering fatal errors
+ *****************************************************************************/
+static void Unload( intf_thread_t *p_this )
+{
+    vlc_object_kill( p_this );
+    vlc_object_detach( p_this );
+    if( p_this->p_module )
+        module_Unneed( p_this, p_this->p_module );
+    vlc_mutex_destroy( &p_this->change_lock );
+    vlc_object_destroy( p_this );
+}
+
+
 /****************************************************************************
  * Run : create Main() thread
  * **************************************************************************/
 /****************************************************************************
  * Run : create Main() thread
  * **************************************************************************/
@@ -293,152 +265,152 @@ static void Run( intf_thread_t *p_intf )
 /*****************************************************************************
  * Main : call Handshake() then submit songs
  *****************************************************************************/
 /*****************************************************************************
  * Main : call Handshake() then submit songs
  *****************************************************************************/
-static void Main( intf_thread_t *p_this )
+static void Main( intf_thread_t *p_intf )
 {
 {
-    char                    *psz_submit         = NULL;
-    char                    *psz_submit_song    = NULL;
+    char                    *psz_submit, *psz_submit_song, *psz_submit_tmp;
     int                     i_net_ret;
     int                     i_song;
     playlist_t              *p_playlist;
     int                     i_net_ret;
     int                     i_song;
     playlist_t              *p_playlist;
-    uint8_t                 *p_buffer           = NULL;
-    char                    *p_buffer_pos       = NULL;
-    audioscrobbler_queue_t  *p_first_queue;
+    uint8_t                 p_buffer[1024];
+    char                    *p_buffer_pos;
     int                     i_post_socket;
     int                     i_post_socket;
-    time_t                  played_time;
-
-    vlc_thread_ready( p_this );
-
-    p_this->p_sys = p_sys_global;
-    intf_sys_t *p_sys = p_this->p_sys;
 
 
-    #define MEM_ERROR \
-        free( psz_submit ); \
-        free( psz_submit_song ); \
-        free( p_buffer ); \
-        msg_Err( p_this, "Out of memory" ); \
-        return;
-
-    psz_submit = malloc( HTTPPOST_MAXLEN );
-    psz_submit_song = malloc( HTTPPOST_MAXLEN );
-    p_buffer = ( uint8_t* ) malloc( 1024 );
-
-    if( !psz_submit || !psz_submit_song || !p_buffer )
-    {
-        MEM_ERROR
-    }
+    intf_sys_t *p_sys = p_intf->p_sys;
 
     /* main loop */
 
     /* main loop */
-    while( !p_this->b_die )
+    while( !p_intf->b_die && !p_intf->p_libvlc->b_die )
     {
         /* verify if there is data to submit
          * and if waiting interval is elapsed */
     {
         /* verify if there is data to submit
          * and if waiting interval is elapsed */
-        if ( ( p_sys->p_first_queue->i_songs_nb > 0 ) &&
-            ( time( NULL ) >= p_sys->time_next_exchange ) )
+        if ( ( p_sys->i_songs > 0 ) &&
+            ( time( NULL ) >= p_sys->next_exchange ) )
         {
             /* handshake if needed */
             if( p_sys->b_handshaked == VLC_FALSE )
             {
         {
             /* handshake if needed */
             if( p_sys->b_handshaked == VLC_FALSE )
             {
-                msg_Dbg( p_this, "Handshaking with last.fm ..." );
+                msg_Dbg( p_intf, "Handshaking with last.fm ..." );
 
 
-                switch( Handshake( p_this ) )
+                switch( Handshake( p_intf ) )
                 {
                     case VLC_ENOMEM:
                 {
                     case VLC_ENOMEM:
-                        MEM_ERROR
-                        break;
+                        Unload( p_intf );
+                        return;
 
                     case VLC_ENOVAR:
                         /* username not set */
 
                     case VLC_ENOVAR:
                         /* username not set */
-                        vlc_mutex_unlock ( &p_sys->lock );
-                        intf_UserFatal( p_this, VLC_FALSE,
+                        intf_UserFatal( p_intf, VLC_FALSE,
                             _("Last.fm username not set"),
                             _("Please set an username or disable "
                             "audioscrobbler plugin, and then restart VLC.\n"
                             "Visit https://www.last.fm/join/ to get an account")
                         );
                             _("Last.fm username not set"),
                             _("Please set an username or disable "
                             "audioscrobbler plugin, and then restart VLC.\n"
                             "Visit https://www.last.fm/join/ to get an account")
                         );
-                        free( psz_submit );
-                        free( psz_submit_song );
-                        free( p_buffer );
+                        Unload( p_intf );
                         return;
                         return;
-                        break;
 
                     case VLC_SUCCESS:
 
                     case VLC_SUCCESS:
-                        msg_Dbg( p_this, "Handshake successfull :)" );
+                        msg_Dbg( p_intf, "Handshake successfull :)" );
                         vlc_mutex_lock ( &p_sys->lock );
                         p_sys->b_handshaked = VLC_TRUE;
                         vlc_mutex_lock ( &p_sys->lock );
                         p_sys->b_handshaked = VLC_TRUE;
+                        p_sys->i_interval = 0;
+                        time( &p_sys->next_exchange );
                         vlc_mutex_unlock ( &p_sys->lock );
                         break;
 
                         vlc_mutex_unlock ( &p_sys->lock );
                         break;
 
+                    case VLC_AUDIOSCROBBLER_EFATAL:
+                        msg_Warn( p_intf, "Unloading..." );
+                        Unload( p_intf );
+                        return;
+
                     case VLC_EGENERIC:
                     default:
                         /* protocol error : we'll try later */
                         vlc_mutex_lock ( &p_sys->lock );
                     case VLC_EGENERIC:
                     default:
                         /* protocol error : we'll try later */
                         vlc_mutex_lock ( &p_sys->lock );
-                        time( &p_sys->time_next_exchange );
-                        p_sys->time_next_exchange += DEFAULT_INTERVAL;
+                        HandleInterval( &p_sys->next_exchange,
+                                &p_sys->i_interval );
                         vlc_mutex_unlock ( &p_sys->lock );
                         break;
                 }
                         vlc_mutex_unlock ( &p_sys->lock );
                         break;
                 }
-                /* handshake is done or failed, lets start from
-                 * beginning to check it out and wait INTERVAL if needed
-                 */
+                /* handshake is finished, let's restart the loop */
                 continue;
             }
 
                 continue;
             }
 
-            msg_Dbg( p_this, "Going to submit some data..." );
+            msg_Dbg( p_intf, "Going to submit some data..." );
             vlc_mutex_lock ( &p_sys->lock );
 
             vlc_mutex_lock ( &p_sys->lock );
 
-            snprintf( psz_submit, HTTPPOST_MAXLEN, "u=%s&s=%s",
-                p_sys->psz_username, p_sys->psz_response_md5 );
+            if( !asprintf( &psz_submit, "s=%s", p_sys->psz_auth_token ) )
+            {   /* Out of memory */
+                vlc_mutex_unlock( &p_sys->lock );
+                Unload( p_intf );
+                return;
+            }
 
             /* forge the HTTP POST request */
 
             /* forge the HTTP POST request */
-            for (i_song = 0 ; i_song < p_sys->p_first_queue->i_songs_nb ;
-                i_song++ )
+            audioscrobbler_song_t *p_song;
+            for( i_song = 0 ; i_song < p_sys->i_songs ; i_song++ )
             {
             {
-                snprintf( psz_submit_song, HTTPPOST_MAXLEN -1, POST_DATA,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->psz_a,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->psz_t,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->psz_b,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->psz_m,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->i_l,
-                    i_song, p_sys->p_first_queue->p_queue[i_song]->psz_i
-                );
-                strncat( psz_submit, psz_submit_song, HTTPPOST_MAXLEN - 1 );
+                p_song = &p_sys->p_queue[i_song];
+                if( !asprintf( &psz_submit_song,
+                        "&a%%5B%d%%5D=%s&t%%5B%d%%5D=%s"
+                        "&i%%5B%d%%5D=%llu&o%%5B%d%%5D=P&r%%5B%d%%5D="
+                        "&l%%5B%d%%5D=%d&b%%5B%d%%5D=%s"
+                        "&n%%5B%d%%5D=%s&m%%5B%d%%5D=%s",
+                        i_song, p_song->psz_a,           i_song, p_song->psz_t,
+                        i_song, (uintmax_t)p_song->date, i_song, i_song,
+                        i_song, p_song->i_l,             i_song, p_song->psz_b,
+                        i_song, p_song->psz_n,           i_song, p_song->psz_m
+                ) )
+                {   /* Out of memory */
+                    vlc_mutex_unlock( &p_sys->lock );
+                    Unload( p_intf );
+                    return;
+                }
+                psz_submit_tmp = psz_submit;
+                if( !asprintf( &psz_submit, "%s%s",
+                        psz_submit_tmp, psz_submit_song ) )
+                {   /* Out of memory */
+                    free( psz_submit_tmp );
+                    free( psz_submit_song );
+                    vlc_mutex_unlock( &p_sys->lock );
+                    Unload( p_intf );
+                    return;
+                }
+                free( psz_submit_song );
+                free( psz_submit_tmp );
             }
 
             }
 
-            i_post_socket = net_ConnectTCP( p_this,
-                p_sys->psz_submit_host, p_sys->i_submit_port);
+            i_post_socket = net_ConnectTCP( p_intf,
+                p_sys->psz_submit_host, p_sys->i_submit_port );
 
             if ( i_post_socket == -1 )
             {
                 /* If connection fails, we assume we must handshake again */
 
             if ( i_post_socket == -1 )
             {
                 /* If connection fails, we assume we must handshake again */
-                time( &p_sys->time_next_exchange );
-                p_sys->time_next_exchange += DEFAULT_INTERVAL;
+                HandleInterval( &p_sys->next_exchange, &p_sys->i_interval );
                 p_sys->b_handshaked = VLC_FALSE;
                 vlc_mutex_unlock( &p_sys->lock );
                 p_sys->b_handshaked = VLC_FALSE;
                 vlc_mutex_unlock( &p_sys->lock );
+                free( psz_submit );
                 continue;
             }
 
             /* we transmit the data */
             i_net_ret = net_Printf(
                 continue;
             }
 
             /* we transmit the data */
             i_net_ret = net_Printf(
-                VLC_OBJECT(p_this), i_post_socket, NULL,
+                VLC_OBJECT( p_intf ), i_post_socket, NULL,
                 POST_REQUEST, p_sys->psz_submit_file,
                 (unsigned)strlen( psz_submit ), p_sys->psz_submit_file,
                 VERSION, psz_submit
             );
 
                 POST_REQUEST, p_sys->psz_submit_file,
                 (unsigned)strlen( psz_submit ), p_sys->psz_submit_file,
                 VERSION, psz_submit
             );
 
+            free( psz_submit );
             if ( i_net_ret == -1 )
             {
                 /* If connection fails, we assume we must handshake again */
             if ( i_net_ret == -1 )
             {
                 /* If connection fails, we assume we must handshake again */
-                time( &p_sys->time_next_exchange );
-                p_sys->time_next_exchange += DEFAULT_INTERVAL;
+                HandleInterval( &p_sys->next_exchange, &p_sys->i_interval );
                 p_sys->b_handshaked = VLC_FALSE;
                 vlc_mutex_unlock( &p_sys->lock );
                 continue;
             }
 
                 p_sys->b_handshaked = VLC_FALSE;
                 vlc_mutex_unlock( &p_sys->lock );
                 continue;
             }
 
-            memset( p_buffer, '\0', 1024 );
-
-            i_net_ret = net_Read( p_this, i_post_socket, NULL,
-                        p_buffer, 1024, VLC_FALSE );
+            i_net_ret = net_Read( p_intf, i_post_socket, NULL,
+                        p_buffer, 1023, VLC_FALSE );
             if ( i_net_ret <= 0 )
             {
                 /* if we get no answer, something went wrong : try again */
             if ( i_net_ret <= 0 )
             {
                 /* if we get no answer, something went wrong : try again */
@@ -447,32 +419,23 @@ static void Main( intf_thread_t *p_this )
             }
 
             net_Close( i_post_socket );
             }
 
             net_Close( i_post_socket );
-
-            /* record interval */
-            p_buffer_pos = strstr( ( char * ) p_buffer, "INTERVAL " );
-            if ( p_buffer_pos )
-            {
-                time( &p_sys->time_next_exchange );
-                p_sys->time_next_exchange += atoi( p_buffer_pos +
-                                            strlen( "INTERVAL " ) );
-            }
+            p_buffer[i_net_ret] = '\0';
 
             p_buffer_pos = strstr( ( char * ) p_buffer, "FAILED" );
             if ( p_buffer_pos )
             {
 
             p_buffer_pos = strstr( ( char * ) p_buffer, "FAILED" );
             if ( p_buffer_pos )
             {
-                /* woops, submission failed */
-                msg_Dbg( p_this, "%s", p_buffer_pos );
-                /* Buggy last.fm server sometimes return INTERVAL 1 */
-                p_sys->time_next_exchange += DEFAULT_INTERVAL;
+                msg_Warn( p_intf, "%s", p_buffer_pos );
+                HandleInterval( &p_sys->next_exchange, &p_sys->i_interval );
                 vlc_mutex_unlock ( &p_sys->lock );
                 continue;
             }
 
                 vlc_mutex_unlock ( &p_sys->lock );
                 continue;
             }
 
-            p_buffer_pos = strstr( ( char * ) p_buffer, "BADAUTH" );
+            p_buffer_pos = strstr( ( char * ) p_buffer, "BADSESSION" );
             if ( p_buffer_pos )
             {
             if ( p_buffer_pos )
             {
-                msg_Dbg( p_this, "Authentification failed, handshaking again" );
+                msg_Dbg( p_intf, "Authentification failed, handshaking again" );
                 p_sys->b_handshaked = VLC_FALSE;
                 p_sys->b_handshaked = VLC_FALSE;
+                HandleInterval( &p_sys->next_exchange, &p_sys->i_interval );
                 vlc_mutex_unlock ( &p_sys->lock );
                 continue;
             }
                 vlc_mutex_unlock ( &p_sys->lock );
                 continue;
             }
@@ -480,78 +443,39 @@ static void Main( intf_thread_t *p_this )
             p_buffer_pos = strstr( ( char * ) p_buffer, "OK" );
             if ( p_buffer_pos )
             {
             p_buffer_pos = strstr( ( char * ) p_buffer, "OK" );
             if ( p_buffer_pos )
             {
-                if ( p_sys->p_first_queue->i_songs_nb == 10 )
-                {
-                    /* if there are more than one queue, delete the 1st */
-                    p_first_queue = p_sys->p_first_queue->p_next_queue;
-                    DeleteQueue( p_sys->p_first_queue );
-                    free( p_sys->p_first_queue );
-                    p_sys->p_first_queue = p_first_queue;
-                }
-                else
-                {
-                    DeleteQueue( p_sys->p_first_queue );
-                    p_sys->p_first_queue->i_songs_nb = 0;
-                }
-                msg_Dbg( p_this, "Submission successfull!" );
+                int i;
+                for( i = 0; i < p_sys->i_songs; i++ )
+                    DeleteSong( &p_sys->p_queue[i] );
+                p_sys->i_songs = 0;
+                p_sys->i_interval = 0;
+                time( &p_sys->next_exchange );
+                msg_Dbg( p_intf, "Submission successfull!" );
+            }
+            else
+            {
+                msg_Dbg( p_intf, "Authentification failed, handshaking again" );
+                p_sys->b_handshaked = VLC_FALSE;
+                HandleInterval( &p_sys->next_exchange, &p_sys->i_interval );
+                vlc_mutex_unlock ( &p_sys->lock );
+                continue;
             }
             vlc_mutex_unlock ( &p_sys->lock );
         } /* data transmission finished or skipped */
 
         msleep( INTF_IDLE_SLEEP );
 
             }
             vlc_mutex_unlock ( &p_sys->lock );
         } /* data transmission finished or skipped */
 
         msleep( INTF_IDLE_SLEEP );
 
-        p_playlist = pl_Yield( p_this );
+        p_playlist = pl_Yield( p_intf );
         PL_LOCK;
         if( p_playlist->request.i_status == PLAYLIST_STOPPED )
         {
             /* if we stopped, we won't submit playing song */
             vlc_mutex_lock( &p_sys->lock );
         PL_LOCK;
         if( p_playlist->request.i_status == PLAYLIST_STOPPED )
         {
             /* if we stopped, we won't submit playing song */
             vlc_mutex_lock( &p_sys->lock );
-            p_sys->b_queued = VLC_TRUE;
-            p_sys->b_metadata_read = VLC_TRUE;
+            p_sys->b_submit = VLC_FALSE;
             vlc_mutex_unlock( &p_sys->lock );
         }
         PL_UNLOCK;
         pl_Release( p_playlist );
             vlc_mutex_unlock( &p_sys->lock );
         }
         PL_UNLOCK;
         pl_Release( p_playlist );
-
-        vlc_mutex_lock( &p_sys->lock );
-        if( p_sys->b_metadata_read == VLC_FALSE )
-        {
-            /* we read the metadata of the playing song */
-            time( &played_time );
-            played_time -= p_sys->p_current_song->time_playing;
-            played_time -= p_sys->time_total_pauses;
-
-            vlc_mutex_unlock( &p_sys->lock );
-
-            if( played_time > 20 )
-            /* wait at least 20 secondes before reading the meta data
-             * since the songs must be at least 30s */
-            {
-                if ( ReadMetaData( p_this ) == VLC_ENOMEM )
-                {
-                    MEM_ERROR
-                }
-            }
-        }
-        else
-        {
-            /* we add the playing song into the queue */
-            if( ( p_sys->b_queued == VLC_FALSE )
-                && ( p_sys->b_paused == VLC_FALSE ) )
-            {
-                vlc_mutex_unlock( &p_sys->lock );
-                if( AddToQueue( p_this ) == VLC_ENOMEM )
-                {
-                    MEM_ERROR
-                }
-            }
-            else
-            {
-                vlc_mutex_unlock( &p_sys->lock );
-            }
-        }
     }
     }
-#undef MEM_ERROR
 }
 
 /*****************************************************************************
 }
 
 /*****************************************************************************
@@ -563,21 +487,20 @@ static int PlayingChange( vlc_object_t *p_this, const char *psz_var,
     intf_thread_t   *p_intf = ( intf_thread_t* ) p_data;
     intf_sys_t      *p_sys  = p_intf->p_sys;
 
     intf_thread_t   *p_intf = ( intf_thread_t* ) p_data;
     intf_sys_t      *p_sys  = p_intf->p_sys;
 
-    (void)p_this; (void)psz_var; (void)oldval;
+    VLC_UNUSED( p_this ); VLC_UNUSED( psz_var );
 
 
-    /* don't bother if song has already been queued */
-    if( p_sys->b_queued == VLC_TRUE )
+    if( p_intf->b_dead )
         return VLC_SUCCESS;
 
     vlc_mutex_lock( &p_sys->lock );
 
         return VLC_SUCCESS;
 
     vlc_mutex_lock( &p_sys->lock );
 
-    if( newval.i_int == PAUSE_S )
+    if( oldval.i_int == PLAYING_S && newval.i_int == PAUSE_S )
     {
         time( &p_sys->time_pause );
         p_sys->b_paused = VLC_TRUE;
     }
 
     {
         time( &p_sys->time_pause );
         p_sys->b_paused = VLC_TRUE;
     }
 
-    else if( newval.i_int == PLAYING_S )
+    else if( oldval.i_int == PAUSE_S && newval.i_int == PLAYING_S )
     {
         p_sys->time_total_pauses += time( NULL ) - p_sys->time_pause;
         p_sys->b_paused = VLC_FALSE;
     {
         p_sys->time_total_pauses += time( NULL ) - p_sys->time_pause;
         p_sys->b_paused = VLC_FALSE;
@@ -588,6 +511,23 @@ static int PlayingChange( vlc_object_t *p_this, const char *psz_var,
     return VLC_SUCCESS;
 }
 
     return VLC_SUCCESS;
 }
 
+/*****************************************************************************
+ * MetaPreparsed: Meta data reading callback
+ *****************************************************************************/
+static int MetaPreparsed( vlc_object_t *p_this, const char *psz_var,
+                       vlc_value_t oldval, vlc_value_t newval, void *p_data )
+{
+    intf_thread_t       *p_intf     = ( intf_thread_t* ) p_data;
+
+    if( p_intf->b_dead )
+        return VLC_SUCCESS;
+
+    vlc_mutex_lock( &p_intf->p_sys->lock );
+    ReadMetaData( p_intf );
+    vlc_mutex_unlock( &p_intf->p_sys->lock );
+    return VLC_SUCCESS;
+}
+
 /*****************************************************************************
  * ItemChange: Playlist item change callback
  *****************************************************************************/
 /*****************************************************************************
  * ItemChange: Playlist item change callback
  *****************************************************************************/
@@ -595,30 +535,41 @@ static int ItemChange( vlc_object_t *p_this, const char *psz_var,
                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 {
     playlist_t          *p_playlist;
                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 {
     playlist_t          *p_playlist;
-    input_thread_t      *p_input    = NULL;
-    time_t              epoch;
-    struct tm           *epoch_tm;
-    char                psz_date[20];
+    input_thread_t      *p_input;
     intf_thread_t       *p_intf     = ( intf_thread_t* ) p_data;
     intf_sys_t          *p_sys      = p_intf->p_sys;
     intf_thread_t       *p_intf     = ( intf_thread_t* ) p_data;
     intf_sys_t          *p_sys      = p_intf->p_sys;
-    (void)p_this; (void)psz_var; (void)oldval; (void)newval;
+    input_item_t        *p_item;
+    vlc_value_t         video_val;
+
+    VLC_UNUSED( p_this ); VLC_UNUSED( psz_var );
+    VLC_UNUSED( oldval ); VLC_UNUSED( newval );
+
+    if( p_intf->b_dead )
+        return VLC_SUCCESS;
+
+    vlc_mutex_lock( &p_sys->lock );
+
+    p_sys->b_preparsed_cb   = VLC_FALSE;
+    p_sys->b_state_cb       = VLC_FALSE;
+
+    /* We'll try to add the previously playing song in the queue */
+    if( AddToQueue( p_intf ) == VLC_ENOMEM )
+    {
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_ENOMEM;
+    }
 
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
     p_input = p_playlist->p_input;
 
 
     p_playlist = pl_Yield( p_intf );
     PL_LOCK;
     p_input = p_playlist->p_input;
 
-    if( !p_input )
+    if( !p_input || p_input->b_dead )
     {
         PL_UNLOCK;
         pl_Release( p_playlist );
 
     {
         PL_UNLOCK;
         pl_Release( p_playlist );
 
-        vlc_mutex_lock( &p_sys->lock );
-
-        p_sys->b_queued = VLC_TRUE;
-        p_sys->b_metadata_read = VLC_TRUE;
-
+        p_sys->b_submit = VLC_FALSE;
         vlc_mutex_unlock( &p_sys->lock );
         vlc_mutex_unlock( &p_sys->lock );
-
         return VLC_SUCCESS;
     }
 
         return VLC_SUCCESS;
     }
 
@@ -626,35 +577,48 @@ static int ItemChange( vlc_object_t *p_this, const char *psz_var,
     PL_UNLOCK;
     pl_Release( p_playlist );
 
     PL_UNLOCK;
     pl_Release( p_playlist );
 
-    var_AddCallback( p_input, "state", PlayingChange, p_intf );
-
-    vlc_mutex_lock ( &p_sys->lock );
-
-    /* reset pause counter */
-    p_sys->time_total_pauses = 0;
-
-    /* we'll read metadata when it's present */
-    p_sys->b_metadata_read = VLC_FALSE;
-    p_sys->b_waiting_meta = VLC_FALSE;
-
-    time( &epoch );
-    epoch_tm = gmtime( &epoch );
-    snprintf( psz_date, 20, "%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
-        epoch_tm->tm_year+1900, epoch_tm->tm_mon+1, epoch_tm->tm_mday,
-        epoch_tm->tm_hour, epoch_tm->tm_min, epoch_tm->tm_sec );
+    p_item = input_GetItem( p_input );
+    if( !p_item )
+    {
+        vlc_object_release( p_input );
+        p_sys->b_submit = VLC_FALSE;
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_SUCCESS;
+    }
 
 
-    p_sys->p_current_song->psz_i = encode_URI_component( psz_date );
-    p_sys->p_current_song->time_playing = epoch;
+    var_Change( p_input, "video-es", VLC_VAR_CHOICESCOUNT, &video_val, NULL );
+    if( ( video_val.i_int > 0 ) || p_item->i_type == ITEM_TYPE_NET )
+    {
+        msg_Dbg( p_this, "Not an audio local file, not submitting");
+        vlc_object_release( p_input );
+        p_sys->b_submit = VLC_FALSE;
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_SUCCESS;
+    }
 
 
-    char *psz_name = input_item_GetName( input_GetItem( p_input ) );
-    p_sys->b_paused = ( p_input->b_dead || !psz_name )
-                      ? VLC_TRUE : VLC_FALSE;
-    free( psz_name );
+    var_AddCallback( p_input, "state", PlayingChange, p_intf );
+    p_sys->b_state_cb = VLC_TRUE;
 
 
-    vlc_mutex_unlock( &p_sys->lock );
+    p_sys->b_submit = VLC_TRUE;
+    p_sys->time_total_pauses = 0;
+    time( &p_sys->p_current_song.date );
 
 
-    vlc_object_release( p_input );
-    return VLC_SUCCESS;
+    if( input_item_IsPreparsed( p_item ) )
+    {
+        ReadMetaData( p_intf );
+        vlc_mutex_unlock( &p_sys->lock );
+        vlc_object_release( p_input );
+        return VLC_SUCCESS;
+    }
+    else
+    {
+        /* We'll read the meta data when it will be preparsed */
+        var_AddCallback( p_input, "meta-preparsed", MetaPreparsed, p_intf );
+        p_sys->b_preparsed_cb = VLC_TRUE;
+        vlc_mutex_unlock( &p_sys->lock );
+        vlc_object_release( p_input );
+        return VLC_SUCCESS;
+    }
 }
 
 /*****************************************************************************
 }
 
 /*****************************************************************************
@@ -662,92 +626,125 @@ static int ItemChange( vlc_object_t *p_this, const char *psz_var,
  *****************************************************************************/
 static int AddToQueue ( intf_thread_t *p_this )
 {
  *****************************************************************************/
 static int AddToQueue ( intf_thread_t *p_this )
 {
-    int                         i_songs_nb;
     time_t                      played_time;
     time_t                      played_time;
-    audioscrobbler_queue_t      *p_queue        = NULL,
-                                *p_next_queue   = NULL;
-    intf_sys_t                  *p_sys          = p_this->p_sys;
+    intf_sys_t                  *p_sys = p_this->p_sys;
+
+    if( !p_sys->b_submit )
+    {
+        DeleteSong( &p_sys->p_current_song );
+        return VLC_SUCCESS;
+    }
 
     /* wait for the user to listen enough before submitting */
     time ( &played_time );
 
     /* wait for the user to listen enough before submitting */
     time ( &played_time );
-    vlc_mutex_lock( &p_sys->lock );
-
-    played_time -= p_sys->p_current_song->time_playing;
+    played_time -= p_sys->p_current_song.date;
     played_time -= p_sys->time_total_pauses;
     played_time -= p_sys->time_total_pauses;
-
-    #define NO_SUBMISSION \
-        p_sys->b_queued = VLC_TRUE; \
-        vlc_mutex_unlock( &p_sys->lock ); \
+    if( ( played_time < 240 ) &&
+        ( played_time < ( p_sys->p_current_song.i_l / 2 ) ) )
+    {
+        msg_Dbg( p_this, "Song not listened long enough, not submitting" );
+        DeleteSong( &p_sys->p_current_song );
         return VLC_SUCCESS;
         return VLC_SUCCESS;
+    }
 
 
-    if( ( played_time < 240 ) &&
-        ( played_time < ( p_sys->p_current_song->i_l / 2 ) ) )
+    if( p_sys->p_current_song.i_l < 30 )
     {
     {
-        //msg_Dbg( p_this, "Song not listened long enough -> waiting" );
-        vlc_mutex_unlock( &p_sys->lock );
+        msg_Dbg( p_this, "Song too short (< 30s), not submitting" );
+        DeleteSong( &p_sys->p_current_song );
         return VLC_SUCCESS;
     }
 
         return VLC_SUCCESS;
     }
 
-    if( p_sys->p_current_song->i_l < 30 )
+    if( !p_sys->p_current_song.psz_a || !*p_sys->p_current_song.psz_a ||
+        !p_sys->p_current_song.psz_t || !*p_sys->p_current_song.psz_t )
     {
     {
-        msg_Dbg( p_this, "Song too short (< 30s) -> not submitting" );
-        NO_SUBMISSION
+        msg_Dbg( p_this, "Missing artist or title, not submitting" );
+        DeleteSong( &p_sys->p_current_song );
+        return VLC_SUCCESS;
     }
 
     }
 
-    if( !p_sys->p_current_song->psz_a || !*p_sys->p_current_song->psz_a ||
-        !p_sys->p_current_song->psz_t || !*p_sys->p_current_song->psz_t )
+    if( p_sys->i_songs == 50 )
     {
     {
-        msg_Dbg( p_this, "Missing artist or title -> not submitting" );
-        NO_SUBMISSION
+        msg_Warn( p_this, "Submission queue is full, not submitting" );
+        DeleteSong( &p_sys->p_current_song );
+        return VLC_SUCCESS;
     }
 
     }
 
-    msg_Dbg( p_this, "Ok. We'll put it in the queue for submission" );
+    msg_Dbg( p_this, "Song will be submitted." );
 
 
-    /* go to last queue */
-    p_queue = p_sys->p_first_queue;
-    while( ( p_queue->i_songs_nb == 10 ) && ( p_queue->p_next_queue != NULL ) )
-        p_queue = p_queue->p_next_queue;
+#define QUEUE_COPY( a ) \
+    p_sys->p_queue[p_sys->i_songs].a = p_sys->p_current_song.a
 
 
-    i_songs_nb = p_queue->i_songs_nb;
+#define QUEUE_COPY_NULL( a ) \
+    QUEUE_COPY( a ); \
+    p_sys->p_current_song.a = NULL
 
 
-    #define MALLOC_CHECK( a ) \
-        if( !a ) { \
-            vlc_mutex_unlock( &p_sys->lock ); \
-            return VLC_ENOMEM; \
-        }
+    QUEUE_COPY( i_l );
+    QUEUE_COPY_NULL( psz_n );
+    QUEUE_COPY_NULL( psz_a );
+    QUEUE_COPY_NULL( psz_t );
+    QUEUE_COPY_NULL( psz_b );
+    QUEUE_COPY_NULL( psz_m );
+    QUEUE_COPY( date );
+#undef QUEUE_COPY_NULL
+#undef QUEUE_COPY
 
 
-    if( i_songs_nb == 10 )
-    {
-        p_next_queue = malloc( sizeof( audioscrobbler_queue_t ) );
-        MALLOC_CHECK( p_next_queue );
-        p_queue->p_next_queue = p_next_queue;
-        p_queue = p_next_queue;
-        i_songs_nb = 0;
-        p_queue->i_songs_nb = i_songs_nb;
-    }
+    p_sys->i_songs++;
+    return VLC_SUCCESS;
+}
 
 
-    p_queue->p_queue[i_songs_nb] = malloc( sizeof( audioscrobbler_song_t ) );
-    MALLOC_CHECK( p_queue->p_queue[i_songs_nb] );
+/*****************************************************************************
+ * ParseURL : Split an http:// URL into host, file, and port
+ *
+ * Example: "62.216.251.205:80/protocol_1.2"
+ *      will be split into "62.216.251.205", 80, "protocol_1.2"
+ *
+ * psz_url will be freed before returning
+ * *psz_file & *psz_host will be freed before use
+ *
+ * Return value:
+ *  VLC_ENOMEM      Out Of Memory
+ *  VLC_EGENERIC    Invalid url provided
+ *  VLC_SUCCESS     Success
+ *****************************************************************************/
+static int ParseURL( char *psz_url, char **psz_host, char **psz_file,
+                        int *i_port )
+{
+    int i_pos;
+    int i_len = strlen( psz_url );
+    FREENULL( *psz_host );
+    FREENULL( *psz_file );
 
 
-    #define QUEUE_COPY( a ) \
-        p_queue->p_queue[i_songs_nb]->a = p_sys->p_current_song->a
+    i_pos = strcspn( psz_url, ":" );
+    if( i_pos == i_len )
+        return VLC_EGENERIC;
 
 
-    QUEUE_COPY(i_l);
-    QUEUE_COPY(psz_a);
-    QUEUE_COPY(psz_t);
-    QUEUE_COPY(psz_b);
-    QUEUE_COPY(psz_m);
-    QUEUE_COPY(psz_i);
+    *psz_host = strndup( psz_url, i_pos );
+    if( !*psz_host )
+        return VLC_ENOMEM;
 
 
-    p_queue->i_songs_nb++;
-    p_sys->b_queued = VLC_TRUE;
+    i_pos++; /* skip the ':' */
+    *i_port = atoi( psz_url + i_pos );
+    if( *i_port <= 0 )
+    {
+        FREENULL( *psz_host );
+        return VLC_EGENERIC;
+    }
 
 
-    vlc_mutex_unlock( &p_sys->lock );
+    i_pos = strcspn( psz_url, "/" );
 
 
+    if( i_pos == i_len )
+        return VLC_EGENERIC;
+
+    i_pos++; /* skip the '/' */
+    *psz_file = strdup( psz_url + i_pos );
+    if( !*psz_file )
+    {
+        FREENULL( *psz_host );
+        return VLC_ENOMEM;
+    }
+
+    free( psz_url );
     return VLC_SUCCESS;
     return VLC_SUCCESS;
-#undef QUEUE_COPY
-#undef MALLOC_CHECK
-#undef NO_SUBMISSION
 }
 
 /*****************************************************************************
 }
 
 /*****************************************************************************
@@ -755,58 +752,101 @@ static int AddToQueue ( intf_thread_t *p_this )
  *****************************************************************************/
 static int Handshake( intf_thread_t *p_this )
 {
  *****************************************************************************/
 static int Handshake( intf_thread_t *p_this )
 {
-    char                *psz_password           = NULL;
-    struct md5_s        *p_struct_md5           = NULL;
-    char                *psz_password_md5       = NULL;
-    char                *ps_challenge_md5       = NULL;
+    char                *psz_username, *psz_password;
+    time_t              timestamp;
+    char                psz_timestamp[33];
+
+    struct md5_s        p_struct_md5;
+    char                psz_password_md5[33];
+
     stream_t            *p_stream;
     stream_t            *p_stream;
-    char                *psz_handshake_url      = NULL;
-    uint8_t             *p_buffer               = NULL;
-    char                *p_buffer_pos           = NULL;
-    char                *psz_url_parser         = NULL;
-    char                *psz_buffer_substring;
-    int                 i_url_pos, i;
+    char                *psz_handshake_url;
+    uint8_t             p_buffer[1024];
+    char                *p_buffer_pos;
+
+    int                 i_ret;
+    char                *psz_url;
 
     intf_thread_t       *p_intf                 = ( intf_thread_t* ) p_this;
     intf_sys_t          *p_sys                  = p_this->p_sys;
 
 
     intf_thread_t       *p_intf                 = ( intf_thread_t* ) p_this;
     intf_sys_t          *p_sys                  = p_this->p_sys;
 
-    vlc_mutex_lock ( &p_sys->lock );
+    psz_username = config_GetPsz( p_this, "lastfm-username" );
+    if( !psz_username )
+        return VLC_ENOMEM;
 
 
-    #define MEM_ERROR \
-        free( p_buffer ); \
-        free( p_struct_md5 ); \
-        free( ps_challenge_md5 ); \
-        vlc_mutex_unlock( &p_sys->lock ); \
+    psz_password = config_GetPsz( p_this, "lastfm-password" );
+    if( !psz_password )
+    {
+        free( psz_username );
         return VLC_ENOMEM;
         return VLC_ENOMEM;
+    }
 
 
-    #define PROTOCOL_ERROR \
-        free( p_buffer ); \
-        vlc_mutex_unlock( &p_sys->lock ); \
-        return VLC_EGENERIC;
+    /* username or password have not been setup */
+    if ( !*psz_username || !*psz_password )
+    {
+        free( psz_username );
+        free( psz_password );
+        return VLC_ENOVAR;
+    }
 
 
-    #define MALLOC_CHECK( a ) \
-        if( !a ) \
-        { \
-            MEM_ERROR \
-        }
+    time( &timestamp );
 
 
-    p_sys->psz_username = config_GetPsz(p_this, "lastfm-username");
-    MALLOC_CHECK( p_sys->psz_username )
+    /* generates a md5 hash of the password */
+    InitMD5( &p_struct_md5 );
+    AddMD5( &p_struct_md5, ( uint8_t* ) psz_password, strlen( psz_password ) );
+    EndMD5( &p_struct_md5 );
 
 
-    /* username has not been setup, ignoring */
-    if ( !*p_sys->psz_username )
-        return VLC_ENOVAR;
+    free( psz_password );
 
 
-    psz_handshake_url = malloc( 1024 );
-    MALLOC_CHECK( p_sys->psz_username )
+    int i;
+    for ( i = 0; i < 4; i++ )
+    {
+        sprintf( &psz_password_md5[8*i], "%02x%02x%02x%02x",
+            p_struct_md5.p_digest[i] & 0xff,
+            ( p_struct_md5.p_digest[i] >> 8 ) & 0xff,
+            ( p_struct_md5.p_digest[i] >> 16 ) & 0xff,
+            p_struct_md5.p_digest[i] >> 24
+        );
+    }
 
 
-    snprintf( psz_handshake_url, 1024,
-        "http://post.audioscrobbler.com/?hs=true&p=1.1&c=%s&v=%s&u=%s",
-        CLIENT_NAME, CLIENT_VERSION, p_sys->psz_username );
+    snprintf( psz_timestamp, 33, "%llu", (uintmax_t)timestamp );
 
 
-    /* send the http handshake request */
-    p_stream = stream_UrlNew( p_intf, psz_handshake_url);
+    /* generates a md5 hash of :
+     * - md5 hash of the password, plus
+     * - timestamp in clear text
+     */
+    InitMD5( &p_struct_md5 );
+    AddMD5( &p_struct_md5, ( uint8_t* ) psz_password_md5, 32 );
+    AddMD5( &p_struct_md5, ( uint8_t* ) psz_timestamp, strlen( psz_timestamp ));
+    EndMD5( &p_struct_md5 );
+
+    vlc_mutex_lock ( &p_sys->lock );
+
+    for ( i = 0; i < 4; i++ )
+    {
+        sprintf( &p_sys->psz_auth_token[8*i], "%02x%02x%02x%02x",
+            p_struct_md5.p_digest[i] & 0xff,
+            ( p_struct_md5.p_digest[i] >> 8 ) & 0xff,
+            ( p_struct_md5.p_digest[i] >> 16 ) & 0xff,
+            p_struct_md5.p_digest[i] >> 24
+        );
+    }
+
+    p_sys->psz_auth_token[32] = '\0';
 
 
+    if( !asprintf( &psz_handshake_url,
+    "http://post.audioscrobbler.com/?hs=true&p=1.2&c=%s&v=%s&u=%s&t=%s&a=%s",
+        CLIENT_NAME, CLIENT_VERSION, psz_username, psz_timestamp,
+        p_sys->psz_auth_token ) )
+    {
+        free( psz_username );
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_ENOMEM;
+    }
+    free( psz_username );
+
+    /* send the http handshake request */
+    p_stream = stream_UrlNew( p_intf, psz_handshake_url );
     free( psz_handshake_url );
 
     if( !p_stream )
     free( psz_handshake_url );
 
     if( !p_stream )
@@ -815,200 +855,152 @@ static int Handshake( intf_thread_t *p_this )
         return VLC_EGENERIC;
     }
 
         return VLC_EGENERIC;
     }
 
-    p_buffer = ( uint8_t* ) calloc( 1, 1024 );
-    if ( !p_buffer )
-    {
-        stream_Delete( p_stream );
-        MEM_ERROR
-    }
-
     /* read answer */
     /* read answer */
-    if ( stream_Read( p_stream, p_buffer, 1024 ) == 0 )
+    i_ret = stream_Read( p_stream, p_buffer, 1023 );
+    if( i_ret == 0 )
     {
         stream_Delete( p_stream );
     {
         stream_Delete( p_stream );
-        PROTOCOL_ERROR
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_EGENERIC;
     }
     }
-
+    p_buffer[i_ret] = '\0';
     stream_Delete( p_stream );
 
     stream_Delete( p_stream );
 
-    /* record interval before next submission */
-    p_buffer_pos = strstr( ( char* ) p_buffer, "INTERVAL" );
-    if ( p_buffer_pos )
-    {
-        time( &p_sys->time_next_exchange );
-        p_sys->time_next_exchange +=
-                atoi( p_buffer_pos + strlen( "INTERVAL " ) );
-    }
-
-    p_buffer_pos = strstr( ( char* ) p_buffer, "FAILED" );
+    p_buffer_pos = strstr( ( char* ) p_buffer, "FAILED " );
     if ( p_buffer_pos )
     {
         /* handshake request failed, sorry */
     if ( p_buffer_pos )
     {
         /* handshake request failed, sorry */
-        msg_Dbg( p_this, "%s", p_buffer_pos );
-        PROTOCOL_ERROR
+        msg_Warn( p_this, "last.fm handshake failed: %s", p_buffer_pos + 7 );
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_EGENERIC;
     }
 
     }
 
-    p_buffer_pos = strstr( ( char* ) p_buffer, "BADUSER" );
+    p_buffer_pos = strstr( ( char* ) p_buffer, "BADAUTH" );
     if ( p_buffer_pos )
     {
     if ( p_buffer_pos )
     {
-        /* username does not exist on the server */
-        intf_UserFatal( p_this, VLC_FALSE, _("Bad last.fm Username"),
-            _("last.fm username is incorrect, please verify your settings")
-        );
-        PROTOCOL_ERROR
+        /* authentication failed, bad username/password combination */
+        intf_UserFatal( p_this, VLC_FALSE,
+            _("last.fm: Authentication failed"),
+            _("last.fm Username or Password is incorrect,"
+              " please verify your settings and relaunch VLC." ) );
+        vlc_mutex_unlock( &p_sys->lock );
+        return VLC_AUDIOSCROBBLER_EFATAL;
     }
 
     }
 
-    p_buffer_pos = strstr( ( char* ) p_buffer, "UPDATE" );
+    p_buffer_pos = strstr( ( char* ) p_buffer, "BANNED" );
     if ( p_buffer_pos )
     {
     if ( p_buffer_pos )
     {
-        /* protocol has been updated, time to update the code */
-        msg_Dbg( p_intf, "Protocol updated : plugin may be outdated" );
-        msg_Dbg( p_intf, "%s", p_buffer_pos );
-    }
-
-    else
-    {
-        p_buffer_pos = strstr( ( char* ) p_buffer, "UPTODATE" );
-        if ( !p_buffer_pos )
-        {
-            msg_Dbg( p_intf, "Can't recognize server protocol" );
-            PROTOCOL_ERROR
-        }
+        /* oops, our version of vlc has been banned by last.fm servers */
+        msg_Err( p_intf, "This version of VLC has been banned by last.fm. "
+                         "You should upgrade VLC, or disable last.fm plugin." );
+        return VLC_AUDIOSCROBBLER_EFATAL;
     }
 
     }
 
-    psz_buffer_substring = strstr( p_buffer_pos, "\n" );
-    if( ( psz_buffer_substring == NULL ) || \
-            ( strlen( psz_buffer_substring + 1 ) < 32 ) )
-    {
-        msg_Dbg( p_intf, "Can't recognize server protocol" );
-        PROTOCOL_ERROR
-    }
-    else
+    p_buffer_pos = strstr( ( char* ) p_buffer, "BADTIME" );
+    if ( p_buffer_pos )
     {
     {
-        ps_challenge_md5 = malloc( 32 );
-        MALLOC_CHECK( ps_challenge_md5 )
-        memcpy( ps_challenge_md5, psz_buffer_substring + 1, 32 );
+        /* The system clock isn't good */
+        msg_Err( p_intf, "last.fm handshake failed because your clock is too "
+                         "much shifted. Please correct it, and relaunch VLC." );
+        return VLC_AUDIOSCROBBLER_EFATAL;
     }
 
     }
 
-    p_buffer_pos = ( void* ) strstr( ( char* ) p_buffer, "http://" );
+    p_buffer_pos = strstr( ( char* ) p_buffer, "OK" );
+    if ( !p_buffer_pos )
+        goto proto;
 
 
-    /* free old information */
-    free( p_sys->psz_submit_host );
-    free( p_sys->psz_submit_file );
+    p_buffer_pos = strstr( p_buffer_pos, "\n" );
+    if( !p_buffer_pos || strlen( p_buffer_pos ) < 34 )
+        goto proto;
+    p_buffer_pos++; /* we skip the '\n' */
 
 
-    psz_url_parser = p_buffer_pos + strlen( "http://" );
-    i_url_pos = strcspn( psz_url_parser, ":" );
+    /* save the session ID */
+    snprintf( &p_sys->psz_auth_token[0], 33, "%s", p_buffer_pos );
 
 
-    p_sys->psz_submit_host = strndup( psz_url_parser, i_url_pos );
-    MALLOC_CHECK( p_sys->psz_submit_host )
+    p_buffer_pos = strstr( p_buffer_pos, "http://" );
+    if( !p_buffer_pos || strlen( p_buffer_pos ) == 7 )
+        goto proto;
 
 
-    p_sys->i_submit_port = atoi( psz_url_parser + i_url_pos + 1 );
+    /* We need to read the nowplaying url */
+    p_buffer_pos += 7; /* we skip "http://" */
+#if 0 //NOT USED
+    psz_url = strndup( p_buffer_pos, strcspn( p_buffer_pos, "\n" ) );
+    if( !psz_url )
+        goto oom;
 
 
-    psz_url_parser += strcspn( psz_url_parser , "/" ) + 1;
-    i_url_pos = strcspn( psz_url_parser, "\n" );
-    p_sys->psz_submit_file = strndup( psz_url_parser, i_url_pos );
-    MALLOC_CHECK( p_sys->psz_submit_file )
-
-    free(p_buffer);
-
-    p_struct_md5 = malloc( sizeof( struct md5_s ) );
-    MALLOC_CHECK( p_struct_md5 )
-
-    psz_password = config_GetPsz(p_this, "lastfm-password");
-    MALLOC_CHECK( psz_password )
-
-    /* generates a md5 hash of the password */
-    InitMD5( p_struct_md5 );
-    AddMD5( p_struct_md5, ( uint8_t* ) psz_password, strlen( psz_password ) );
-    EndMD5( p_struct_md5 );
-
-    free( psz_password );
-
-    psz_password_md5 = malloc ( 33 );
-    MALLOC_CHECK( psz_password_md5 )
-
-    for ( i = 0; i < 4; i++ )
+    switch( ParseURL( psz_url, &p_sys->psz_nowp_host,
+                &p_sys->psz_nowp_file, &p_sys->i_nowp_port ) )
     {
     {
-        sprintf( &psz_password_md5[8*i], "%02x%02x%02x%02x",
-            p_struct_md5->p_digest[i] & 0xff,
-            ( p_struct_md5->p_digest[i] >> 8 ) & 0xff,
-            ( p_struct_md5->p_digest[i] >> 16 ) & 0xff,
-            p_struct_md5->p_digest[i] >> 24
-        );
+        case VLC_ENOMEM:
+            goto oom;
+        case VLC_EGENERIC:
+            goto proto;
+        case VLC_SUCCESS:
+        default:
+            break;
     }
     }
-
-    /* generates a md5 hash of :
-     * - md5 hash of the password, plus
-     * - md5 challenge sent by last.fm server
-     */
-    InitMD5( p_struct_md5 );
-    AddMD5( p_struct_md5, ( uint8_t* ) psz_password_md5, 32 );
-    AddMD5( p_struct_md5, ( uint8_t* ) ps_challenge_md5, 32 );
-    EndMD5( p_struct_md5 );
-
-    free( ps_challenge_md5 );
-    free( psz_password_md5 );
-
-    for ( i = 0; i < 4; i++ )
+#endif
+    p_buffer_pos = strstr( p_buffer_pos, "http://" );
+    if( !p_buffer_pos || strlen( p_buffer_pos ) == 7 )
+        goto proto;
+
+    /* We need to read the submission url */
+    p_buffer_pos += 7; /* we skip "http://" */
+    psz_url = strndup( p_buffer_pos, strcspn( p_buffer_pos, "\n" ) );
+    if( !psz_url )
+        goto oom;
+
+    switch( ParseURL( psz_url, &p_sys->psz_submit_host,
+                &p_sys->psz_submit_file, &p_sys->i_submit_port ) )
     {
     {
-        sprintf( &p_sys->psz_response_md5[8*i], "%02x%02x%02x%02x",
-            p_struct_md5->p_digest[i] & 0xff,
-            ( p_struct_md5->p_digest[i] >> 8 ) & 0xff,
-            ( p_struct_md5->p_digest[i] >> 16 ) & 0xff,
-            p_struct_md5->p_digest[i] >> 24
-        );
+        case VLC_ENOMEM:
+            goto oom;
+        case VLC_EGENERIC:
+            goto proto;
+        case VLC_SUCCESS:
+        default:
+            break;
     }
 
     }
 
-    p_sys->psz_response_md5[32] = '\0';
-
     vlc_mutex_unlock ( &p_sys->lock );
     vlc_mutex_unlock ( &p_sys->lock );
-
     return VLC_SUCCESS;
     return VLC_SUCCESS;
-#undef MEM_ERROR
-#undef PROTOCOL_ERROR
-#undef MALLOC_CHECK
+
+oom:
+    vlc_mutex_unlock( &p_sys->lock );
+    return VLC_ENOMEM;
+
+proto:
+    msg_Warn( p_intf, "Handshake: can't recognize server protocol" );
+    vlc_mutex_unlock( &p_sys->lock );
+    return VLC_EGENERIC;
 }
 
 /*****************************************************************************
 }
 
 /*****************************************************************************
- * DeleteQueue : Free all songs from an audioscrobbler_queue_t
+ * DeleteSong : Delete the char pointers in a song
  *****************************************************************************/
  *****************************************************************************/
-void DeleteQueue( audioscrobbler_queue_t *p_queue )
+static void DeleteSong( audioscrobbler_song_t* p_song )
 {
 {
-    int     i;
-
-    for( i = 0; i < p_queue->i_songs_nb; i++ )
-    {
-        free( p_queue->p_queue[i]->psz_a );
-        free( p_queue->p_queue[i]->psz_b );
-        free( p_queue->p_queue[i]->psz_t );
-        free( p_queue->p_queue[i]->psz_i );
-        free( p_queue->p_queue[i] );
-    }
+    FREENULL( p_song->psz_a );
+    FREENULL( p_song->psz_b );
+    FREENULL( p_song->psz_t );
+    FREENULL( p_song->psz_m );
+    FREENULL( p_song->psz_n );
 }
 
 /*****************************************************************************
  * ReadMetaData : Read meta data when parsed by vlc
 }
 
 /*****************************************************************************
  * ReadMetaData : Read meta data when parsed by vlc
- * or wait for fetching if unavailable
  *****************************************************************************/
 static int ReadMetaData( intf_thread_t *p_this )
 {
     playlist_t          *p_playlist;
  *****************************************************************************/
 static int ReadMetaData( intf_thread_t *p_this )
 {
     playlist_t          *p_playlist;
-    input_thread_t      *p_input        = NULL;
-    vlc_value_t         video_val;
+    input_thread_t      *p_input;
+    input_item_t        *p_item;
 
 
-    char                *psz_title      = NULL;
-    char                *psz_artist     = NULL;
-    char                *psz_album      = NULL;
-    char                *psz_trackid    = NULL;
-    int                 i_length        = -1;
-    vlc_bool_t          b_waiting;
-    intf_sys_t          *p_sys          = p_this->p_sys;
-    int                 i_status;
+    intf_sys_t          *p_sys = p_this->p_sys;
 
     p_playlist = pl_Yield( p_this );
     PL_LOCK;
     p_input = p_playlist->p_input;
 
     p_playlist = pl_Yield( p_this );
     PL_LOCK;
     p_input = p_playlist->p_input;
-
     if( !p_input )
     {
         PL_UNLOCK;
     if( !p_input )
     {
         PL_UNLOCK;
@@ -1020,118 +1012,79 @@ static int ReadMetaData( intf_thread_t *p_this )
     PL_UNLOCK;
     pl_Release( p_playlist );
 
     PL_UNLOCK;
     pl_Release( p_playlist );
 
-    var_Change( p_input, "video-es", VLC_VAR_CHOICESCOUNT, &video_val, NULL );
-    if( ( video_val.i_int > 0 ) || \
-        ( input_GetItem( p_input )->i_type == ITEM_TYPE_NET ) )
-    {
-        msg_Dbg( p_this, "Not an audio only local file -> no submission");
-        vlc_object_release( p_input );
-
-        vlc_mutex_lock( &p_sys->lock );
-        p_sys->b_queued = VLC_TRUE;
-        p_sys->b_metadata_read = VLC_TRUE;
-        vlc_mutex_unlock( &p_sys->lock );
-
+    p_item = input_GetItem( p_input );
+    if( !p_item )
         return VLC_SUCCESS;
         return VLC_SUCCESS;
-    }
-
-    #define FREE_INPUT_AND_CHARS \
-        vlc_object_release( p_input ); \
-        free( psz_title ); \
-        free( psz_artist ); \
-        free( psz_album ); \
-        free( psz_trackid );
-
-    #define WAIT_METADATA_FETCHING( a ) \
-        if ( b_waiting == VLC_TRUE ) \
-        { \
-            a = calloc( 1, 1 ); \
-        } \
-        else \
-        { \
-            vlc_object_release( p_input ); \
-            vlc_mutex_lock( &p_sys->lock ); \
-            p_sys->b_waiting_meta = VLC_TRUE; \
-            vlc_mutex_unlock( &p_sys->lock ); \
-            free( psz_artist ); \
-            return VLC_SUCCESS; \
-        }
 
     char *psz_meta;
 
     char *psz_meta;
-    #define ALLOC_ITEM_META( a, b ) \
-        psz_meta = input_item_Get##b( input_GetItem( p_input ) ); \
-        if( psz_meta ) \
+#define ALLOC_ITEM_META( a, b ) \
+    psz_meta = input_item_Get##b( p_item ); \
+    if( psz_meta && *psz_meta ) \
+    { \
+        a = encode_URI_component( psz_meta ); \
+        if( !a ) \
         { \
         { \
-            a = encode_URI_component( psz_meta ); \
-            if( !a ) \
-            { \
-                free( psz_meta ); \
-                FREE_INPUT_AND_CHARS \
-                return VLC_ENOMEM; \
-            } \
             free( psz_meta ); \
             free( psz_meta ); \
-        }
-
-    i_status = input_GetItem(p_input)->p_meta->i_status;
+            return VLC_ENOMEM; \
+        } \
+        free( psz_meta ); \
+    }
 
 
-    vlc_mutex_lock( &p_sys->lock );
-    b_waiting = p_sys->b_waiting_meta;
-    vlc_mutex_unlock( &p_sys->lock );
+    ALLOC_ITEM_META( p_sys->p_current_song.psz_a, Artist )
+    else
+    {
+        msg_Dbg( p_this, "No artist.." );
+        vlc_object_release( p_input );
+        free( psz_meta );
+        return VLC_EGENERIC;
+    }
 
 
-    if( i_status & ( !b_waiting ? ITEM_PREPARSED : ITEM_META_FETCHED ) )
+    ALLOC_ITEM_META( p_sys->p_current_song.psz_t, Title )
+    else
     {
     {
-        ALLOC_ITEM_META( psz_artist, Artist )
-        else
-        {
-            msg_Dbg( p_this, "No artist.." );
-            WAIT_METADATA_FETCHING( psz_artist )
-        }
-        psz_meta = input_item_GetTitle( input_GetItem( p_input ) );
-        if( psz_meta )
-        {
-            psz_title = encode_URI_component( psz_meta );
-            if( !psz_title )
-            {
-                free( psz_meta );
-                FREE_INPUT_AND_CHARS
-                return VLC_ENOMEM;
-            }
-            free( psz_meta );
-        }
-        else
-        {
-            msg_Dbg( p_this, "No track name.." );
-            WAIT_METADATA_FETCHING( psz_title );
-        }
+        msg_Dbg( p_this, "No track name.." );
+        vlc_object_release( p_input );
+        free( p_sys->p_current_song.psz_a );
+        free( psz_meta );
+        return VLC_EGENERIC;
+    }
 
 
-        ALLOC_ITEM_META( psz_album, Album )
-        else
-            psz_album = calloc( 1, 1 );
+    ALLOC_ITEM_META( p_sys->p_current_song.psz_b, Album )
+    else
+        p_sys->p_current_song.psz_b = calloc( 1, 1 );
 
 
-        ALLOC_ITEM_META( psz_trackid, TrackID )
-        else
-            psz_trackid = calloc( 1, 1 );
+    ALLOC_ITEM_META( p_sys->p_current_song.psz_m, TrackID )
+    else
+        p_sys->p_current_song.psz_m = calloc( 1, 1 );
 
 
-        i_length = input_item_GetDuration( input_GetItem( p_input ) ) / 1000000;
+    p_sys->p_current_song.i_l = input_item_GetDuration( p_item ) / 1000000;
 
 
-        vlc_mutex_lock ( &p_sys->lock );
+    ALLOC_ITEM_META( p_sys->p_current_song.psz_n, TrackNum )
+    else
+        p_sys->p_current_song.psz_n = calloc( 1, 1 );
+#undef ALLOC_ITEM_META
 
 
-        p_sys->p_current_song->psz_a    = strdup( psz_artist );
-        p_sys->p_current_song->psz_t    = strdup( psz_title );
-        p_sys->p_current_song->psz_b    = strdup( psz_album );
-        p_sys->p_current_song->psz_m    = strdup( psz_trackid );
-        p_sys->p_current_song->i_l      = i_length;
-        p_sys->b_queued                 = VLC_FALSE;
-        p_sys->b_metadata_read          = VLC_TRUE;
+    msg_Dbg( p_this, "Meta data registered" );
 
 
-        vlc_mutex_unlock( &p_sys->lock );
+    vlc_object_release( p_input );
+    return VLC_SUCCESS;
+
+}
 
 
-        msg_Dbg( p_this, "Meta data registered, waiting to be queued" );
+static void HandleInterval( time_t *next, unsigned int *i_interval )
+{
+    if( *i_interval == 0 )
+    {
+        /* first interval is 1 minute */
+        *i_interval = 60;
     }
     }
-    FREE_INPUT_AND_CHARS
-    return VLC_SUCCESS;
-#undef FREE_INPUT_AND_CHARS
-#undef ALLOC_ITEM_META
-#undef WAIT_METADATA_FETCHING
+    else
+    {
+        /* else we double the previous interval, up to 120 minutes */
+        *i_interval = *i_interval * 2;
+        if( *i_interval > 60*120 )
+            *i_interval = 60*120;
+    }
+    *next = time( NULL ) + *i_interval;
 }
 }
+