LGPL
[vlc.git] / src / playlist / fetcher.c
index e1d45e8..1b202dc 100644 (file)
@@ -1,52 +1,55 @@
 /*****************************************************************************
  * fetcher.c: Art fetcher thread.
  *****************************************************************************
- * Copyright © 1999-2009 the VideoLAN team
+ * Copyright © 1999-2009 VLC authors and VideoLAN
  * $Id$
  *
  * Authors: Samuel Hocevar <sam@zoy.org>
  *          Clément Stenac <zorglub@videolan.org>
  *
- * 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
- * the Free Software Foundation; either version 2 of the License, or
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 
+#include <assert.h>
+
 #include <vlc_common.h>
 #include <vlc_playlist.h>
 #include <vlc_stream.h>
 #include <limits.h>
+#include <vlc_art_finder.h>
+#include <vlc_memory.h>
+#include <vlc_demux.h>
+#include <vlc_modules.h>
 
 #include "art.h"
 #include "fetcher.h"
 #include "playlist_internal.h"
 
-
 /*****************************************************************************
  * Structures/definitions
  *****************************************************************************/
 struct playlist_fetcher_t
 {
-    VLC_COMMON_MEMBERS;
-
     playlist_t      *p_playlist;
 
-    vlc_thread_t    thread;
     vlc_mutex_t     lock;
     vlc_cond_t      wait;
+    bool            b_live;
     int             i_art_policy;
     int             i_waiting;
     input_item_t    **pp_waiting;
@@ -62,61 +65,59 @@ static void *Thread( void * );
  *****************************************************************************/
 playlist_fetcher_t *playlist_fetcher_New( playlist_t *p_playlist )
 {
-    playlist_fetcher_t *p_fetcher =
-        vlc_custom_create( p_playlist, sizeof(*p_fetcher),
-                           VLC_OBJECT_GENERIC, "playlist fetcher" );
-
+    playlist_fetcher_t *p_fetcher = malloc( sizeof(*p_fetcher) );
     if( !p_fetcher )
         return NULL;
 
-    vlc_object_attach( p_fetcher, p_playlist );
     p_fetcher->p_playlist = p_playlist;
     vlc_mutex_init( &p_fetcher->lock );
     vlc_cond_init( &p_fetcher->wait );
+    p_fetcher->b_live = false;
     p_fetcher->i_waiting = 0;
     p_fetcher->pp_waiting = NULL;
     p_fetcher->i_art_policy = var_GetInteger( p_playlist, "album-art" );
     ARRAY_INIT( p_fetcher->albums );
 
-    if( vlc_clone( &p_fetcher->thread, Thread, p_fetcher,
-                   VLC_THREAD_PRIORITY_LOW ) )
-    {
-        msg_Err( p_fetcher, "cannot spawn secondary preparse thread" );
-        vlc_object_release( p_fetcher );
-        return NULL;
-    }
-
     return p_fetcher;
 }
 
-void playlist_fetcher_Push( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
+void playlist_fetcher_Push( playlist_fetcher_t *p_fetcher,
+                            input_item_t *p_item )
 {
     vlc_gc_incref( p_item );
 
     vlc_mutex_lock( &p_fetcher->lock );
     INSERT_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting,
                  p_fetcher->i_waiting, p_item );
-    vlc_cond_signal( &p_fetcher->wait );
+    if( !p_fetcher->b_live )
+    {
+        if( vlc_clone_detach( NULL, Thread, p_fetcher,
+                              VLC_THREAD_PRIORITY_LOW ) )
+            msg_Err( p_fetcher->p_playlist,
+                     "cannot spawn secondary preparse thread" );
+        else
+            p_fetcher->b_live = true;
+    }
     vlc_mutex_unlock( &p_fetcher->lock );
 }
 
 void playlist_fetcher_Delete( playlist_fetcher_t *p_fetcher )
 {
-    /* */
-    vlc_object_kill( p_fetcher );
-
-    /* Destroy the item meta-infos fetcher */
-    vlc_cancel( p_fetcher->thread );
-    vlc_join( p_fetcher->thread, NULL );
-
+    vlc_mutex_lock( &p_fetcher->lock );
+    /* Remove any left-over item, the fetcher will exit */
     while( p_fetcher->i_waiting > 0 )
-    {   /* Any left-over unparsed item? */
+    {
         vlc_gc_decref( p_fetcher->pp_waiting[0] );
         REMOVE_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting, 0 );
     }
+
+    while( p_fetcher->b_live )
+        vlc_cond_wait( &p_fetcher->wait, &p_fetcher->lock );
+    vlc_mutex_unlock( &p_fetcher->lock );
+
     vlc_cond_destroy( &p_fetcher->wait );
     vlc_mutex_destroy( &p_fetcher->lock );
-    vlc_object_release( p_fetcher );
+    free( p_fetcher );
 }
 
 
@@ -133,12 +134,10 @@ void playlist_fetcher_Delete( playlist_fetcher_t *p_fetcher )
 static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
 {
     int i_ret;
-    module_t *p_module;
-    char *psz_title, *psz_artist, *psz_album;
 
-    psz_artist = input_item_GetArtist( p_item );
-    psz_album = input_item_GetAlbum( p_item );
-    psz_title = input_item_GetTitle( p_item );
+    char *psz_artist = input_item_GetArtist( p_item );
+    char *psz_album = input_item_GetAlbum( p_item );
+    char *psz_title = input_item_GetTitle( p_item );
     if( !psz_title )
         psz_title = input_item_GetName( p_item );
 
@@ -154,7 +153,8 @@ static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
             if( !strcmp( album.psz_artist, psz_artist ) &&
                 !strcmp( album.psz_album, psz_album ) )
             {
-                msg_Dbg( p_fetcher, " %s - %s has already been searched",
+                msg_Dbg( p_fetcher->p_playlist,
+                         " %s - %s has already been searched",
                          psz_artist, psz_album );
                 /* TODO-fenrir if we cache art filename too, we can go faster */
                 free( psz_artist );
@@ -182,7 +182,7 @@ static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
     char *psz_arturl = input_item_GetArtURL( p_item );
     if( psz_arturl )
     {
-        /* We already have an URL */
+        /* We already have a URL */
         if( !strncmp( psz_arturl, "file://", strlen( "file://" ) ) )
         {
             free( psz_arturl );
@@ -200,7 +200,7 @@ static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
     psz_artist = input_item_GetArtist( p_item );
     if( psz_album && psz_artist )
     {
-        msg_Dbg( p_fetcher, "searching art for %s - %s",
+        msg_Dbg( p_fetcher->p_playlist, "searching art for %s - %s",
              psz_artist, psz_album );
     }
     else
@@ -209,24 +209,33 @@ static int FindArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
         if( !psz_title )
             psz_title = input_item_GetName( p_item );
 
-        msg_Dbg( p_fetcher, "searching art for %s", psz_title );
+        msg_Dbg( p_fetcher->p_playlist, "searching art for %s", psz_title );
         free( psz_title );
     }
 
     /* Fetch the art url */
-    p_fetcher->p_private = p_item;
-
-    p_module = module_need( p_fetcher, "art finder", NULL, false );
+    i_ret = VLC_EGENERIC;
 
-    if( p_module )
+    vlc_object_t *p_parent = VLC_OBJECT(p_fetcher->p_playlist);
+    art_finder_t *p_finder =
+        vlc_custom_create( p_parent, sizeof( *p_finder ), "art finder" );
+    if( p_finder != NULL)
     {
-        module_unneed( p_fetcher, p_module );
-        i_ret = 1;
-    }
-    else
-    {
-        msg_Dbg( p_fetcher, "unable to find art" );
-        i_ret = VLC_EGENERIC;
+        module_t *p_module;
+
+        p_finder->p_item = p_item;
+
+        p_module = module_need( p_finder, "art finder", NULL, false );
+        if( p_module )
+        {
+            module_unneed( p_finder, p_module );
+            /* Try immediately if found in cache by download URL */
+            if( !playlist_FindArtInCache( p_item ) )
+                i_ret = 0;
+            else
+                i_ret = 1;
+        }
+        vlc_object_release( p_finder );
     }
 
     /* Record this album */
@@ -259,18 +268,19 @@ static int DownloadArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
 
     if( !strncmp( psz_arturl , "file://", 7 ) )
     {
-        msg_Dbg( p_fetcher, "Album art is local file, no need to cache" );
+        msg_Dbg( p_fetcher->p_playlist,
+                 "Album art is local file, no need to cache" );
         free( psz_arturl );
         return VLC_SUCCESS;
     }
 
     if( !strncmp( psz_arturl , "APIC", 4 ) )
     {
-        msg_Warn( p_fetcher, "APIC fetch not supported yet" );
+        msg_Warn( p_fetcher->p_playlist, "APIC fetch not supported yet" );
         goto error;
     }
 
-    stream_t *p_stream = stream_UrlNew( p_fetcher, psz_arturl );
+    stream_t *p_stream = stream_UrlNew( p_fetcher->p_playlist, psz_arturl );
     if( !p_stream )
         goto error;
 
@@ -283,7 +293,7 @@ static int DownloadArt( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
         if( i_data >= INT_MAX - i_read )
             break;
 
-        p_data = realloc( p_data, i_data + i_read );
+        p_data = realloc_or_free( p_data, i_data + i_read );
         if( !p_data )
             break;
 
@@ -314,6 +324,26 @@ error:
     return VLC_EGENERIC;
 }
 
+/**
+ * FetchMeta, run the "meta fetcher". They are going to do network
+ * connections, and gather information upon the playing media.
+ * (even artwork).
+ */
+static void FetchMeta( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
+{
+    demux_meta_t *p_demux_meta = vlc_custom_create(p_fetcher->p_playlist,
+                                         sizeof(*p_demux_meta), "demux meta" );
+    if( !p_demux_meta )
+        return;
+
+    p_demux_meta->p_demux = NULL;
+    p_demux_meta->p_item = p_item;
+
+    module_t *p_meta_fetcher = module_need( p_demux_meta, "meta fetcher", NULL, false );
+    if( p_meta_fetcher )
+        module_unneed( p_demux_meta, p_meta_fetcher );
+    vlc_object_release( p_demux_meta );
+}
 
 static int InputEvent( vlc_object_t *p_this, char const *psz_cmd,
                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
@@ -364,7 +394,7 @@ static void WaitPreparsed( playlist_fetcher_t *p_fetcher, input_item_t *p_item )
         vlc_mutex_unlock( &p_fetcher->lock );
     }
 
-    var_DelCallback( p_input, "intf-event", InputEvent, p_fetcher );
+    var_DelCallback( p_input, "intf-event", InputEvent, &cond );
     vlc_cond_destroy( &cond );
 
 exit:
@@ -378,42 +408,37 @@ static void *Thread( void *p_data )
 
     for( ;; )
     {
-        input_item_t *p_item;
+        input_item_t *p_item = NULL;
 
-        /* Be sure to be cancellable before our queue is empty */
-        vlc_testcancel();
-
-        /* */
         vlc_mutex_lock( &p_fetcher->lock );
-        mutex_cleanup_push( &p_fetcher->lock );
-
-        while( p_fetcher->i_waiting == 0 )
-            vlc_cond_wait( &p_fetcher->wait, &p_fetcher->lock );
-
-        p_item = p_fetcher->pp_waiting[0];
-        REMOVE_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting, 0 );
-        vlc_cleanup_run( );
+        if( p_fetcher->i_waiting != 0 )
+        {
+            p_item = p_fetcher->pp_waiting[0];
+            REMOVE_ELEM( p_fetcher->pp_waiting, p_fetcher->i_waiting, 0 );
+        }
+        else
+        {
+            p_fetcher->b_live = false;
+            vlc_cond_signal( &p_fetcher->wait );
+        }
+        vlc_mutex_unlock( &p_fetcher->lock );
 
         if( !p_item )
-            continue;
+            break;
 
         /* */
-        int canc = vlc_savecancel();
 
         /* Wait that the input item is preparsed if it is being played */
         WaitPreparsed( p_fetcher, p_item );
 
-        /* */
-        if( !vlc_object_alive( p_fetcher ) )
-            goto end;
+        /* Triggers "meta fetcher", eventually fetch meta on the network.
+         * They are identical to "meta reader" expect that may actually
+         * takes time. That's why they are running here.
+         * The result of this fetch is not cached. */
+        FetchMeta( p_fetcher, p_item );
 
         /* Find art, and download it if needed */
         int i_ret = FindArt( p_fetcher, p_item );
-
-        /* */
-        if( !vlc_object_alive( p_fetcher ) )
-            goto end;
-
         if( i_ret == 1 )
             i_ret = DownloadArt( p_fetcher, p_item );
 
@@ -431,18 +456,7 @@ static void *Thread( void *p_data )
             input_item_SetArtNotFound( p_item, true );
         }
         free( psz_name );
-
-    end:
         vlc_gc_decref( p_item );
-
-        vlc_restorecancel( canc );
-
-        int i_activity = var_GetInteger( p_playlist, "activity" );
-        if( i_activity < 0 ) i_activity = 0;
-        /* Sleep at least 1ms */
-        msleep( (i_activity+1) * 1000 );
     }
     return NULL;
 }
-
-