engine.c 24.3 KB
Newer Older
1 2 3
/*****************************************************************************
 * engine.c : Run the playlist and handle its control
 *****************************************************************************
4
 * Copyright (C) 1999-2007 the VideoLAN team
Antoine Cellerier's avatar
Antoine Cellerier committed
5
 * $Id$
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *
 * 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
 * (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.
 *
 * 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.
 *****************************************************************************/
24

25 26 27 28
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

29
#include <vlc/vlc.h>
Clément Stenac's avatar
Clément Stenac committed
30 31 32 33
#include <vlc_vout.h>
#include <vlc_sout.h>
#include <vlc_playlist.h>
#include <vlc_interface.h>
34
#include "playlist_internal.h"
Clément Stenac's avatar
Clément Stenac committed
35
#include "stream_output/stream_output.h" /* sout_DeleteInstance */
36 37 38 39 40 41

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
static void VariablesInit( playlist_t *p_playlist );

Clément Stenac's avatar
Clément Stenac committed
42 43 44
static int RandomCallback( vlc_object_t *p_this, char const *psz_cmd,
                           vlc_value_t oldval, vlc_value_t newval, void *a )
{
45 46
    (void)psz_cmd; (void)oldval; (void)newval; (void)a;

Clément Stenac's avatar
Clément Stenac committed
47
    ((playlist_t*)p_this)->b_reset_currently_playing = VLC_TRUE;
48
    playlist_Signal( ((playlist_t*)p_this) );
Clément Stenac's avatar
Clément Stenac committed
49 50 51
    return VLC_SUCCESS;
}

52 53 54 55 56 57 58 59 60 61
/**
 * Create playlist
 *
 * Create a playlist structure.
 * \param p_parent the vlc object that is to be the parent of this playlist
 * \return a pointer to the created playlist, or NULL on error
 */
playlist_t * playlist_Create( vlc_object_t *p_parent )
{
    playlist_t *p_playlist;
62
    vlc_bool_t b_save;
63
    int i_tree;
64 65 66 67 68 69 70 71

    /* Allocate structure */
    p_playlist = vlc_object_create( p_parent, VLC_OBJECT_PLAYLIST );
    if( !p_playlist )
    {
        msg_Err( p_parent, "out of memory" );
        return NULL;
    }
72

73
    TAB_INIT( p_playlist->i_sds, p_playlist->pp_sds );
74

75
    p_parent->p_libvlc->p_playlist = p_playlist;
76 77 78 79 80 81 82 83 84

    VariablesInit( p_playlist );

    /* Initialise data structures */
    vlc_mutex_init( p_playlist, &p_playlist->gc_lock );
    p_playlist->i_last_playlist_id = 0;
    p_playlist->i_last_input_id = 0;
    p_playlist->p_input = NULL;

85 86
    p_playlist->gc_date = 0;
    p_playlist->b_cant_sleep = VLC_FALSE;
87

Clément Stenac's avatar
Clément Stenac committed
88 89 90 91
    ARRAY_INIT( p_playlist->items );
    ARRAY_INIT( p_playlist->all_items );
    ARRAY_INIT( p_playlist->input_items );
    ARRAY_INIT( p_playlist->current );
92

Clément Stenac's avatar
Clément Stenac committed
93 94
    p_playlist->i_current_index = 0;
    p_playlist->b_reset_currently_playing = VLC_TRUE;
95
    p_playlist->last_rebuild_date = 0;
Clément Stenac's avatar
Clément Stenac committed
96

97 98 99 100
    i_tree = var_CreateGetBool( p_playlist, "playlist-tree" );
    p_playlist->b_always_tree = (i_tree == 1);
    p_playlist->b_never_tree = (i_tree == 2);

101 102
    p_playlist->b_doing_ml = VLC_FALSE;

103 104 105
    p_playlist->b_auto_preparse =
                        var_CreateGetBool( p_playlist, "auto-preparse") ;

106
    p_playlist->p_root_category = playlist_NodeCreate( p_playlist, NULL, NULL,
107
                                    0, NULL );
108
    p_playlist->p_root_onelevel = playlist_NodeCreate( p_playlist, NULL, NULL,
109
                                    0, p_playlist->p_root_category->p_input );
110

111 112 113
    if( !p_playlist->p_root_category || !p_playlist->p_root_onelevel )
        return NULL;

114
    /* Create playlist and media library */
115 116 117 118
    playlist_NodesPairCreate( p_playlist, _( "Playlist" ),
                            &p_playlist->p_local_category,
                            &p_playlist->p_local_onelevel, VLC_FALSE );

119 120 121
    p_playlist->p_local_category->i_flags |= PLAYLIST_RO_FLAG;
    p_playlist->p_local_onelevel->i_flags |= PLAYLIST_RO_FLAG;

122 123 124 125 126
    if( !p_playlist->p_local_category || !p_playlist->p_local_onelevel ||
        !p_playlist->p_local_category->p_input ||
        !p_playlist->p_local_onelevel->p_input )
        return NULL;

127 128
    if( config_GetInt( p_playlist, "media-library") )
    {
129 130 131
        playlist_NodesPairCreate( p_playlist, _( "Media Library" ),
                            &p_playlist->p_ml_category,
                            &p_playlist->p_ml_onelevel, VLC_FALSE );
132 133 134 135

        if(!p_playlist->p_ml_category || !p_playlist->p_ml_onelevel)
            return NULL;

136 137 138 139 140 141 142
        p_playlist->p_ml_category->i_flags |= PLAYLIST_RO_FLAG;
        p_playlist->p_ml_onelevel->i_flags |= PLAYLIST_RO_FLAG;
    }
    else
    {
        p_playlist->p_ml_category = p_playlist->p_ml_onelevel = NULL;
    }
143 144 145

    /* Initial status */
    p_playlist->status.p_item = NULL;
146
    p_playlist->status.p_node = p_playlist->p_local_onelevel;
147 148 149 150 151 152
    p_playlist->request.b_request = VLC_FALSE;
    p_playlist->status.i_status = PLAYLIST_STOPPED;

    p_playlist->i_sort = SORT_ID;
    p_playlist->i_order = ORDER_NORMAL;

153 154
    b_save = p_playlist->b_auto_preparse;
    p_playlist->b_auto_preparse = VLC_FALSE;
155
    playlist_MLLoad( p_playlist );
156
    p_playlist->b_auto_preparse = VLC_TRUE;
157 158 159 160 161 162 163 164
    return p_playlist;
}

void playlist_Destroy( playlist_t *p_playlist )
{
    var_Destroy( p_playlist, "intf-change" );
    var_Destroy( p_playlist, "item-change" );
    var_Destroy( p_playlist, "playlist-current" );
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
165
    var_Destroy( p_playlist, "intf-popupmenu" );
166 167
    var_Destroy( p_playlist, "intf-show" );
    var_Destroy( p_playlist, "play-and-stop" );
168
    var_Destroy( p_playlist, "play-and-exit" );
169 170 171 172 173 174
    var_Destroy( p_playlist, "random" );
    var_Destroy( p_playlist, "repeat" );
    var_Destroy( p_playlist, "loop" );
    var_Destroy( p_playlist, "activity" );

    vlc_mutex_destroy( &p_playlist->gc_lock );
175
    vlc_object_detach( p_playlist );
176 177
    vlc_object_destroy( p_playlist );
}
178

179
/* Destroy remaining objects */
180
static void ObjectGarbageCollector( playlist_t *p_playlist, vlc_bool_t b_force )
181 182 183
{
    vlc_object_t *p_obj;

184
    if( !b_force )
185
    {
186 187 188 189 190 191 192
        if( mdate() - p_playlist->gc_date < 1000000 )
        {
            p_playlist->b_cant_sleep = VLC_TRUE;
            return;
        }
        else if( p_playlist->gc_date == 0 )
            return;
193
    }
194

195 196 197
    vlc_mutex_lock( &p_playlist->gc_lock );
    while( ( p_obj = vlc_object_find( p_playlist, VLC_OBJECT_VOUT,
                                                  FIND_CHILD ) ) )
198
    {
199
        if( p_obj->p_parent != VLC_OBJECT(p_playlist) )
200 201 202 203 204 205 206 207
        {
            vlc_object_release( p_obj );
            break;
        }
        msg_Dbg( p_playlist, "garbage collector destroying 1 vout" );
        vlc_object_detach( p_obj );
        vlc_object_release( p_obj );
        vout_Destroy( (vout_thread_t *)p_obj );
208
    }
209 210
    while( ( p_obj = vlc_object_find( p_playlist, VLC_OBJECT_SOUT,
                                                  FIND_CHILD ) ) )
211
    {
212
        if( p_obj->p_parent != VLC_OBJECT(p_playlist) )
213
        {
214 215
            vlc_object_release( p_obj );
            break;
216
        }
217 218
        msg_Dbg( p_playlist, "garbage collector destroying 1 sout" );
        vlc_object_detach( p_obj );
219 220
        vlc_object_release( p_obj );
        sout_DeleteInstance( (sout_instance_t*)p_obj );
221
    }
222 223
    p_playlist->b_cant_sleep = VLC_FALSE;
    vlc_mutex_unlock( &p_playlist->gc_lock );
224 225 226 227 228 229
}

/** Main loop for the playlist */
void playlist_MainLoop( playlist_t *p_playlist )
{
    playlist_item_t *p_item = NULL;
230
    vlc_bool_t b_playexit = var_GetBool( p_playlist, "play-and-exit" );
231
    PL_LOCK;
232

233 234
    if( p_playlist->b_reset_currently_playing &&
        mdate() - p_playlist->last_rebuild_date > 30000 ) // 30 ms
235
    {
236 237 238
        ResetCurrentlyPlaying( p_playlist, var_GetBool( p_playlist, "random"),
                             p_playlist->status.p_item );
        p_playlist->last_rebuild_date = mdate();
239
    }
240

241
check_input:
242 243 244
    /* If there is an input, check that it doesn't need to die. */
    if( p_playlist->p_input )
    {
245 246 247 248 249 250
        if( p_playlist->request.b_request && !p_playlist->p_input->b_die )
        {
            PL_DEBUG( "incoming request - stopping current input" );
            input_StopThread( p_playlist->p_input );
        }

251 252 253 254 255
        /* This input is dead. Remove it ! */
        if( p_playlist->p_input->b_dead )
        {
            int i_activity;
            input_thread_t *p_input;
256
            PL_DEBUG( "dead input" );
257 258 259 260 261 262

            p_input = p_playlist->p_input;
            p_playlist->p_input = NULL;

            /* Release the playlist lock, because we may get stuck
             * in input_DestroyThread() for some time. */
263
            PL_UNLOCK;
264 265 266 267

            /* Destroy input */
            input_DestroyThread( p_input );

268 269 270 271
            PL_LOCK;

            p_playlist->gc_date = mdate();
            p_playlist->b_cant_sleep = VLC_TRUE;
272 273 274 275

            if( p_playlist->status.p_item->i_flags
                & PLAYLIST_REMOVE_FLAG )
            {
276 277
                 PL_DEBUG( "%s was marked for deletion, deleting",
                                 PLI_NAME( p_playlist->status.p_item  ) );
278
                 playlist_ItemDelete( p_playlist->status.p_item );
279 280
                 if( p_playlist->request.p_item == p_playlist->status.p_item )
                     p_playlist->request.p_item = NULL;
281 282 283 284 285 286
                 p_playlist->status.p_item = NULL;
            }

            i_activity= var_GetInteger( p_playlist, "activity") ;
            var_SetInteger( p_playlist, "activity", i_activity -
                            DEFAULT_INPUT_ACTIVITY );
287
            goto check_input;
288 289 290 291
        }
        /* This input is dying, let it do */
        else if( p_playlist->p_input->b_die )
        {
292
            PL_DEBUG( "dying input" );
293
            PL_UNLOCK;
294
            msleep( INTF_IDLE_SLEEP );
295
            PL_LOCK;
296
            goto check_input;
297 298 299 300 301
        }
        /* This input has finished, ask it to die ! */
        else if( p_playlist->p_input->b_error
                  || p_playlist->p_input->b_eof )
        {
302
            PL_DEBUG( "finished input" );
303
            input_StopThread( p_playlist->p_input );
304 305
            /* No need to wait here, we'll wait in the p_input->b_die case */
            goto check_input;
306 307 308
        }
        else if( p_playlist->p_input->i_state != INIT_S )
        {
309
            PL_UNLOCK;
310
            ObjectGarbageCollector( p_playlist, VLC_FALSE );
311
            PL_LOCK;
312 313 314 315 316 317 318 319 320 321
        }
    }
    else
    {
        /* No input. Several cases
         *  - No request, running status -> start new item
         *  - No request, stopped status -> collect garbage
         *  - Request, running requested -> start new item
         *  - Request, stopped requested -> collect garbage
         */
322
         if( p_playlist->request.i_status != PLAYLIST_STOPPED )
323
         {
324
             msg_Dbg( p_playlist, "starting new item" );
325 326 327 328 329
             p_item = playlist_NextItem( p_playlist );

             if( p_item == NULL )
             {
                msg_Dbg( p_playlist, "nothing to play" );
330
                p_playlist->status.i_status = PLAYLIST_STOPPED;
331
                PL_UNLOCK;
332

333 334 335
                if( b_playexit == VLC_TRUE )
                {
                    msg_Info( p_playlist, "end of playlist, exiting" );
336
                    vlc_object_kill( p_playlist->p_libvlc );
337
                }
338
                ObjectGarbageCollector( p_playlist, VLC_TRUE );
339 340 341 342 343 344
                return;
             }
             playlist_PlayItem( p_playlist, p_item );
         }
         else
         {
345 346
            const vlc_bool_t b_gc_forced = p_playlist->status.i_status != PLAYLIST_STOPPED;

347 348 349 350 351 352 353 354
            p_playlist->status.i_status = PLAYLIST_STOPPED;
            if( p_playlist->status.p_item &&
                p_playlist->status.p_item->i_flags & PLAYLIST_REMOVE_FLAG )
            {
                PL_DEBUG( "deleting item marked for deletion" );
                playlist_ItemDelete( p_playlist->status.p_item );
                p_playlist->status.p_item = NULL;
            }
355

356 357
            /* Collect garbage */
            PL_UNLOCK;
358
            ObjectGarbageCollector( p_playlist, b_gc_forced );
359 360
            PL_LOCK;
        }
361
    }
362
    PL_UNLOCK;
363 364 365 366 367 368 369 370 371 372
}

/** Playlist dying last loop */
void playlist_LastLoop( playlist_t *p_playlist )
{
    vlc_object_t *p_obj;

    /* If there is an input, kill it */
    while( 1 )
    {
373
        PL_LOCK;
374 375
        if( p_playlist->p_input == NULL )
        {
376
            PL_UNLOCK;
377 378 379 380 381 382 383 384 385 386
            break;
        }

        if( p_playlist->p_input->b_dead )
        {
            input_thread_t *p_input;

            /* Unlink current input */
            p_input = p_playlist->p_input;
            p_playlist->p_input = NULL;
387
            PL_UNLOCK;
388 389 390 391 392 393 394 395 396 397 398 399 400

            /* Destroy input */
            input_DestroyThread( p_input );
            continue;
        }
        else if( p_playlist->p_input->b_die )
        {
            /* This input is dying, leave it alone */
            ;
        }
        else if( p_playlist->p_input->b_error || p_playlist->p_input->b_eof )
        {
            input_StopThread( p_playlist->p_input );
401
            PL_UNLOCK;
402 403 404 405 406 407
            continue;
        }
        else
        {
            p_playlist->p_input->b_eof = 1;
        }
408
        PL_UNLOCK;
409 410 411 412 413 414 415 416

        msleep( INTF_IDLE_SLEEP );
    }

    /* close all remaining sout */
    while( ( p_obj = vlc_object_find( p_playlist,
                                      VLC_OBJECT_SOUT, FIND_CHILD ) ) )
    {
417
        vlc_object_detach( p_obj );
418 419 420 421 422 423 424 425 426 427 428 429
        vlc_object_release( p_obj );
        sout_DeleteInstance( (sout_instance_t*)p_obj );
    }

    /* close all remaining vout */
    while( ( p_obj = vlc_object_find( p_playlist,
                                      VLC_OBJECT_VOUT, FIND_CHILD ) ) )
    {
        vlc_object_detach( p_obj );
        vlc_object_release( p_obj );
        vout_Destroy( (vout_thread_t *)p_obj );
    }
430

431
    while( p_playlist->i_sds )
432 433
    {
        playlist_ServicesDiscoveryRemove( p_playlist,
434
                                          p_playlist->pp_sds[0]->p_sd->psz_module );
435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458
    }

    playlist_MLDump( p_playlist );

    PL_LOCK;
    /* Go through all items, and simply free everything without caring
     * about the tree structure. Do not decref, it will be done by doing
     * the same thing on the input items array */
    FOREACH_ARRAY( playlist_item_t *p_del, p_playlist->all_items )
        free( p_del->pp_children );
        free( p_del );
    FOREACH_END();
    ARRAY_RESET( p_playlist->all_items );

    FOREACH_ARRAY( input_item_t *p_del, p_playlist->input_items )
        input_ItemClean( p_del );
        free( p_del );
    FOREACH_END();
    ARRAY_RESET( p_playlist->input_items );

    ARRAY_RESET( p_playlist->items );
    ARRAY_RESET( p_playlist->current );

    PL_UNLOCK;
459 460 461 462 463 464
}

/** Main loop for preparser queue */
void playlist_PreparseLoop( playlist_preparse_t *p_obj )
{
    playlist_t *p_playlist = (playlist_t *)p_obj->p_parent;
465
    input_item_t *p_current;
466
    int i_activity;
Clément Stenac's avatar
Clément Stenac committed
467
    uint32_t i_m, i_o;
468

469
    while( !p_playlist->b_die )
470
    {
471 472 473 474 475 476 477 478 479 480
        vlc_mutex_lock( &p_obj->object_lock );
        while( p_obj->i_waiting == 0 )
        {
            vlc_cond_wait( &p_obj->object_wait, &p_obj->object_lock );
            if( p_playlist->b_die )
            {
                vlc_mutex_unlock( &p_obj->object_lock );
                return;
            }
        }
481

482
        p_current = p_obj->pp_waiting[0];
483 484
        REMOVE_ELEM( p_obj->pp_waiting, p_obj->i_waiting, 0 );
        vlc_mutex_unlock( &p_obj->object_lock );
485

Clément Stenac's avatar
Clément Stenac committed
486
        PL_LOCK;
487 488
        if( p_current )
        {
489
            if( p_current->i_type == ITEM_TYPE_FILE )
490 491 492
            {
                stats_TimerStart( p_playlist, "Preparse run",
                                  STATS_TIMER_PREPARSE );
493
                /* Do not preparse if it is already done (like by playing it) */
494
                if( !input_item_IsPreparsed( p_current ) )
495 496 497 498 499
                {
                    PL_UNLOCK;
                    input_Preparse( p_playlist, p_current );
                    PL_LOCK;
                }
500
                stats_TimerStop( p_playlist, STATS_TIMER_PREPARSE );
501
                PL_UNLOCK;
502
                input_item_SetPreparsed( p_current, VLC_TRUE );
503
                var_SetInteger( p_playlist, "item-change", p_current->i_id );
504
                PL_LOCK;
505
            }
Clément Stenac's avatar
Clément Stenac committed
506
            /* If we haven't retrieved enough meta, add to secondary queue
507 508 509
             * which will run the "meta fetchers".
             * This only checks for meta, not for art
             * \todo don't do this for things we won't get meta for, like vids
510
             */
511 512
            char *psz_arturl = input_item_GetArtURL( p_current );
            char *psz_name = input_item_GetName( p_current );
513
            if( !input_MetaSatisfied( p_playlist, p_current, &i_m, &i_o ) )
Clément Stenac's avatar
Clément Stenac committed
514 515
            {
                preparse_item_t p;
516
                PL_DEBUG("need to fetch meta for %s", p_current->psz_name );
517 518
                p.p_item = p_current;
                p.b_fetch_art = VLC_FALSE;
519 520 521
                vlc_mutex_lock( &p_playlist->p_fetcher->object_lock );
                INSERT_ELEM( p_playlist->p_fetcher->p_waiting,
                             p_playlist->p_fetcher->i_waiting,
522
                             p_playlist->p_fetcher->i_waiting, p);
523
                vlc_cond_signal( &p_playlist->p_fetcher->object_wait );
524
                vlc_mutex_unlock( &p_playlist->p_fetcher->object_lock );
525 526
            }
            /* We already have all needed meta, but we need art right now */
527
            else if( p_playlist->p_fetcher->i_art_policy == ALBUM_ART_ALL &&
528
                        ( !psz_arturl || strncmp( psz_arturl, "file://", 7 ) ) )
529 530
            {
                preparse_item_t p;
531
                PL_DEBUG("meta ok for %s, need to fetch art", psz_name );
532 533 534
                p.p_item = p_current;
                p.b_fetch_art = VLC_TRUE;
                vlc_mutex_lock( &p_playlist->p_fetcher->object_lock );
535 536 537
                INSERT_ELEM( p_playlist->p_fetcher->p_waiting,
                             p_playlist->p_fetcher->i_waiting,
                             p_playlist->p_fetcher->i_waiting, p);
538
                vlc_cond_signal( &p_playlist->p_fetcher->object_wait );
539
                vlc_mutex_unlock( &p_playlist->p_fetcher->object_lock );
Clément Stenac's avatar
Clément Stenac committed
540
            }
541
            else
542 543
            {
                PL_DEBUG( "no fetch required for %s (art currently %s)",
544
                          psz_name, psz_arturl );
Clément Stenac's avatar
Clément Stenac committed
545
                vlc_gc_decref( p_current );
546
            }
547 548
            free( psz_name );
            free( psz_arturl );
549
            PL_UNLOCK;
550 551
        }
        else
552 553
            PL_UNLOCK;

554
        vlc_mutex_lock( &p_obj->object_lock );
555
        i_activity = var_GetInteger( p_playlist, "activity" );
556
        if( i_activity < 0 ) i_activity = 0;
557
        vlc_mutex_unlock( &p_obj->object_lock );
558
        /* Sleep at least 1ms */
559 560 561 562
        msleep( (i_activity+1) * 1000 );
    }
}

563
/** Main loop for secondary preparser queue */
564
void playlist_FetcherLoop( playlist_fetcher_t *p_obj )
565 566
{
    playlist_t *p_playlist = (playlist_t *)p_obj->p_parent;
567 568 569
    vlc_bool_t b_fetch_art;
    input_item_t *p_item;
    int i_activity;
570

571
    while( !p_playlist->b_die )
572
    {
573 574 575 576 577 578 579 580 581 582 583 584 585
        vlc_mutex_lock( &p_obj->object_lock );
        while( p_obj->i_waiting == 0 )
        {
            vlc_cond_wait( &p_obj->object_wait, &p_obj->object_lock );
            if( p_playlist->b_die )
            {
                vlc_mutex_unlock( &p_obj->object_lock );
                return;
            }
        }

        b_fetch_art = p_obj->p_waiting->b_fetch_art;
        p_item = p_obj->p_waiting->p_item;
586
        REMOVE_ELEM( p_obj->p_waiting, p_obj->i_waiting, 0 );
587
        vlc_mutex_unlock( &p_obj->object_lock );
588
        if( p_item )
589
        {
Clément Stenac's avatar
Clément Stenac committed
590 591
            if( !b_fetch_art )
            {
592 593 594 595 596 597 598 599
                /* If the user doesn't want us to fetch meta automatically 
                 * abort here. */
                if( p_playlist->p_fetcher->b_fetch_meta )
                {
                    input_MetaFetch( p_playlist, p_item );
                    var_SetInteger( p_playlist, "item-change", p_item->i_id );
                }

600
                /*  Fetch right now */
601
                if( p_playlist->p_fetcher->i_art_policy == ALBUM_ART_ALL )
602 603 604 605 606
                {
                    vlc_mutex_lock( &p_obj->object_lock );
                    preparse_item_t p;
                    p.p_item = p_item;
                    p.b_fetch_art = VLC_TRUE;
607 608
                    INSERT_ELEM( p_playlist->p_fetcher->p_waiting,
                                 p_playlist->p_fetcher->i_waiting,
609
                                 0, p );
610
                    PL_DEBUG("meta fetched for %s, get art", p_item->psz_name);
611
                    vlc_mutex_unlock( &p_obj->object_lock );
612
                    continue;
613 614 615
                }
                else
                    vlc_gc_decref( p_item );
Clément Stenac's avatar
Clément Stenac committed
616 617
            }
            else
618
            {
619 620 621 622 623
                int i_ret;

                /* Check if it is not yet preparsed and if so wait for it (at most 0.5s)
                 * (This can happen if we fetch art on play)
                 * FIXME this doesn't work if we need to fetch meta before art ... */
624
                for( i_ret = 0; i_ret < 10 && !input_item_IsPreparsed( p_item ); i_ret++ )
625 626 627 628 629 630 631 632 633 634
                {
                    vlc_bool_t b_break;
                    PL_LOCK;
                    b_break = ( !p_playlist->p_input || input_GetItem(p_playlist->p_input) != p_item  ||
                                p_playlist->p_input->b_die || p_playlist->p_input->b_eof || p_playlist->p_input->b_error );
                    PL_UNLOCK;
                    if( b_break )
                        break;
                    msleep( 50000 );
                }
635

636
                i_ret = input_ArtFind( p_playlist, p_item );
637 638 639
                if( i_ret == 1 )
                {
                    PL_DEBUG("downloading art for %s", p_item->psz_name );
640
                    if( input_DownloadAndCacheArt( p_playlist, p_item ) )
641
                        input_item_SetArtNotFound( p_item, VLC_TRUE );
642
                    else {
643
                        input_item_SetArtFetched( p_item, VLC_TRUE );
644 645 646
                        var_SetInteger( p_playlist, "item-change",
                                        p_item->i_id );
                    }
647 648 649 650
                }
                else if( i_ret == 0 ) /* Was in cache */
                {
                    PL_DEBUG("found art for %s in cache", p_item->psz_name );
651
                    input_item_SetArtFetched( p_item, VLC_TRUE );
652
                    var_SetInteger( p_playlist, "item-change", p_item->i_id );
653 654 655 656
                }
                else
                {
                    PL_DEBUG("art not found for %s", p_item->psz_name );
657
                    input_item_SetArtNotFound( p_item, VLC_TRUE );
658
                }
659 660
                vlc_gc_decref( p_item );
           }
661
        }
662 663 664 665 666 667
        vlc_mutex_lock( &p_obj->object_lock );
        i_activity = var_GetInteger( p_playlist, "activity" );
        if( i_activity < 0 ) i_activity = 0;
        vlc_mutex_unlock( &p_obj->object_lock );
        /* Sleep at least 1ms */
        msleep( (i_activity+1) * 1000 );
668 669 670
    }
}

671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703
static void VariablesInit( playlist_t *p_playlist )
{
    vlc_value_t val;
    /* These variables control updates */
    var_Create( p_playlist, "intf-change", VLC_VAR_BOOL );
    val.b_bool = VLC_TRUE;
    var_Set( p_playlist, "intf-change", val );

    var_Create( p_playlist, "item-change", VLC_VAR_INTEGER );
    val.i_int = -1;
    var_Set( p_playlist, "item-change", val );

    var_Create( p_playlist, "item-deleted", VLC_VAR_INTEGER );
    val.i_int = -1;
    var_Set( p_playlist, "item-deleted", val );

    var_Create( p_playlist, "item-append", VLC_VAR_ADDRESS );

    var_Create( p_playlist, "playlist-current", VLC_VAR_INTEGER );
    val.i_int = -1;
    var_Set( p_playlist, "playlist-current", val );

    var_Create( p_playlist, "intf-popupmenu", VLC_VAR_BOOL );

    var_Create( p_playlist, "intf-show", VLC_VAR_BOOL );
    val.b_bool = VLC_TRUE;
    var_Set( p_playlist, "intf-show", val );

    var_Create( p_playlist, "activity", VLC_VAR_INTEGER );
    var_SetInteger( p_playlist, "activity", 0 );

    /* Variables to control playback */
    var_CreateGetBool( p_playlist, "play-and-stop" );
704
    var_CreateGetBool( p_playlist, "play-and-exit" );
705 706 707
    var_CreateGetBool( p_playlist, "random" );
    var_CreateGetBool( p_playlist, "repeat" );
    var_CreateGetBool( p_playlist, "loop" );
Clément Stenac's avatar
Clément Stenac committed
708 709

    var_AddCallback( p_playlist, "random", RandomCallback, NULL );
710
}