git.sesse.net Git - vlc/blob - src/input/item.c

   1 /*****************************************************************************
   2  * item.c: input_item management
   3  *****************************************************************************
   4  * Copyright (C) 1998-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Clément Stenac <zorglub@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along
  20  * with this program; if not, write to the Free Software Foundation, Inc.,
  21  * 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27 #include <assert.h>
  28
  29 #include <vlc_common.h>
  30 #include <vlc_url.h>
  31 #include "vlc_playlist.h"
  32 #include "vlc_interface.h"
  33 #include <vlc_charset.h>
  34
  35 #include "item.h"
  36 #include "info.h"
  37
  38 static int GuessType( const input_item_t *p_item );
  39
  40 /** Stuff moved out of vlc_input.h -- FIXME: should probably not be inline
  41  * anyway. */
  42 static inline void input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
  43 {
  44     memset( p_i, 0, sizeof(input_item_t) );
  45
  46     p_i->psz_name = NULL;
  47     p_i->psz_uri = NULL;
  48     TAB_INIT( p_i->i_es, p_i->es );
  49     TAB_INIT( p_i->i_options, p_i->ppsz_options );
  50     p_i->optflagv = NULL, p_i->optflagc = 0;
  51     TAB_INIT( p_i->i_categories, p_i->pp_categories );
  52     TAB_INIT( p_i->i_epg, p_i->pp_epg );
  53
  54     p_i->i_type = ITEM_TYPE_UNKNOWN;
  55     p_i->b_fixed_name = true;
  56
  57     p_i->p_stats = NULL;
  58     p_i->p_meta = NULL;
  59
  60     vlc_mutex_init( &p_i->lock );
  61     vlc_event_manager_t * p_em = &p_i->event_manager;
  62     vlc_event_manager_init( p_em, p_i, p_o );
  63     vlc_event_manager_register_event_type( p_em, vlc_InputItemMetaChanged );
  64     vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemAdded );
  65     vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemTreeAdded );
  66     vlc_event_manager_register_event_type( p_em, vlc_InputItemDurationChanged );
  67     vlc_event_manager_register_event_type( p_em, vlc_InputItemPreparsedChanged );
  68     vlc_event_manager_register_event_type( p_em, vlc_InputItemNameChanged );
  69     vlc_event_manager_register_event_type( p_em, vlc_InputItemInfoChanged );
  70     vlc_event_manager_register_event_type( p_em, vlc_InputItemErrorWhenReadingChanged );
  71 }
  72
  73 static inline void input_item_Clean( input_item_t *p_i )
  74 {
  75     int i;
  76
  77     vlc_event_manager_fini( &p_i->event_manager );
  78
  79     free( p_i->psz_name );
  80     free( p_i->psz_uri );
  81     if( p_i->p_stats )
  82     {
  83         vlc_mutex_destroy( &p_i->p_stats->lock );
  84         free( p_i->p_stats );
  85     }
  86
  87     if( p_i->p_meta )
  88         vlc_meta_Delete( p_i->p_meta );
  89
  90     for( i = 0; i < p_i->i_options; i++ )
  91         free( p_i->ppsz_options[i] );
  92     TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
  93     free( p_i->optflagv);
  94
  95     for( i = 0; i < p_i->i_es; i++ )
  96     {
  97         es_format_Clean( p_i->es[i] );
  98         free( p_i->es[i] );
  99     }
 100     TAB_CLEAN( p_i->i_es, p_i->es );
 101
 102     for( i = 0; i < p_i->i_epg; i++ )
 103         vlc_epg_Delete( p_i->pp_epg[i] );
 104     TAB_CLEAN( p_i->i_epg, p_i->pp_epg );
 105
 106     for( i = 0; i < p_i->i_categories; i++ )
 107         info_category_Delete( p_i->pp_categories[i] );
 108     TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
 109
 110     vlc_mutex_destroy( &p_i->lock );
 111 }
 112 void input_item_SetErrorWhenReading( input_item_t *p_i, bool b_error )
 113 {
 114     bool b_changed;
 115
 116     vlc_mutex_lock( &p_i->lock );
 117
 118     b_changed = p_i->b_error_when_reading != b_error;
 119     p_i->b_error_when_reading = b_error;
 120
 121     vlc_mutex_unlock( &p_i->lock );
 122
 123     if( b_changed )
 124     {
 125         vlc_event_t event;
 126
 127         event.type = vlc_InputItemErrorWhenReadingChanged;
 128         event.u.input_item_error_when_reading_changed.new_value = b_error;
 129         vlc_event_send( &p_i->event_manager, &event );
 130     }
 131 }
 132 void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
 133 {
 134     bool b_send_event = false;
 135
 136     vlc_mutex_lock( &p_i->lock );
 137
 138     if( !p_i->p_meta )
 139         p_i->p_meta = vlc_meta_New();
 140
 141     int status = vlc_meta_GetStatus(p_i->p_meta);
 142     int new_status;
 143     if( b_preparsed )
 144         new_status = status | ITEM_PREPARSED;
 145     else
 146         new_status = status & ~ITEM_PREPARSED;
 147     if( status != new_status )
 148     {
 149         vlc_meta_SetStatus(p_i->p_meta, new_status);
 150         b_send_event = true;
 151     }
 152
 153     vlc_mutex_unlock( &p_i->lock );
 154
 155     if( b_send_event )
 156     {
 157         vlc_event_t event;
 158         event.type = vlc_InputItemPreparsedChanged;
 159         event.u.input_item_preparsed_changed.new_status = new_status;
 160         vlc_event_send( &p_i->event_manager, &event );
 161     }
 162 }
 163
 164 void input_item_SetArtNotFound( input_item_t *p_i, bool b_not_found )
 165 {
 166     vlc_mutex_lock( &p_i->lock );
 167
 168     if( !p_i->p_meta )
 169         p_i->p_meta = vlc_meta_New();
 170
 171     int status = vlc_meta_GetStatus(p_i->p_meta);
 172
 173     if( b_not_found )
 174         status |= ITEM_ART_NOTFOUND;
 175     else
 176         status &= ~ITEM_ART_NOTFOUND;
 177
 178     vlc_meta_SetStatus(p_i->p_meta, status);
 179
 180     vlc_mutex_unlock( &p_i->lock );
 181 }
 182
 183 void input_item_SetArtFetched( input_item_t *p_i, bool b_art_fetched )
 184 {
 185     vlc_mutex_lock( &p_i->lock );
 186
 187     if( !p_i->p_meta )
 188         p_i->p_meta = vlc_meta_New();
 189
 190     int status = vlc_meta_GetStatus(p_i->p_meta);
 191
 192     if( b_art_fetched )
 193         status |= ITEM_ART_FETCHED;
 194     else
 195         status &= ~ITEM_ART_FETCHED;
 196
 197     vlc_meta_SetStatus(p_i->p_meta, status);
 198
 199     vlc_mutex_unlock( &p_i->lock );
 200 }
 201
 202 void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
 203 {
 204     vlc_event_t event;
 205
 206     vlc_mutex_lock( &p_i->lock );
 207     if( !p_i->p_meta )
 208         p_i->p_meta = vlc_meta_New();
 209     vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
 210     vlc_mutex_unlock( &p_i->lock );
 211
 212     /* Notify interested third parties */
 213     event.type = vlc_InputItemMetaChanged;
 214     event.u.input_item_meta_changed.meta_type = meta_type;
 215     vlc_event_send( &p_i->event_manager, &event );
 216 }
 217
 218 /* FIXME GRRRRRRRRRR args should be in the reverse order to be
 219  * consistant with (nearly?) all or copy funcs */
 220 void input_item_CopyOptions( input_item_t *p_parent,
 221                              input_item_t *p_child )
 222 {
 223     vlc_mutex_lock( &p_parent->lock );
 224
 225     for( int i = 0 ; i< p_parent->i_options; i++ )
 226     {
 227         if( !strcmp( p_parent->ppsz_options[i], "meta-file" ) )
 228             continue;
 229
 230         input_item_AddOption( p_child,
 231                               p_parent->ppsz_options[i],
 232                               p_parent->optflagv[i] );
 233     }
 234
 235     vlc_mutex_unlock( &p_parent->lock );
 236 }
 237
 238 static void post_subitems( input_item_node_t *p_node )
 239 {
 240     for( int i = 0; i < p_node->i_children; i++ )
 241     {
 242         vlc_event_t event;
 243         event.type = vlc_InputItemSubItemAdded;
 244         event.u.input_item_subitem_added.p_new_child = p_node->pp_children[i]->p_item;
 245         vlc_event_send( &p_node->p_item->event_manager, &event );
 246
 247         post_subitems( p_node->pp_children[i] );
 248     }
 249 }
 250
 251 /* This won't hold the item, but can tell to interested third parties
 252  * Like the playlist, that there is a new sub item. With this design
 253  * It is not the input item's responsability to keep all the ref of
 254  * the input item children. */
 255 void input_item_PostSubItem( input_item_t *p_parent, input_item_t *p_child )
 256 {
 257     input_item_node_t *p_node = input_item_node_Create( p_parent );
 258     input_item_node_AppendItem( p_node, p_child );
 259     input_item_node_PostAndDelete( p_node );
 260 }
 261
 262 bool input_item_HasErrorWhenReading( input_item_t *p_item )
 263 {
 264     vlc_mutex_lock( &p_item->lock );
 265
 266     bool b_error = p_item->b_error_when_reading;
 267
 268     vlc_mutex_unlock( &p_item->lock );
 269
 270     return b_error;
 271 }
 272
 273 bool input_item_MetaMatch( input_item_t *p_i,
 274                            vlc_meta_type_t meta_type, const char *psz )
 275 {
 276     vlc_mutex_lock( &p_i->lock );
 277
 278     if( !p_i->p_meta )
 279     {
 280         vlc_mutex_unlock( &p_i->lock );
 281         return false;
 282     }
 283     const char *psz_meta = vlc_meta_Get( p_i->p_meta, meta_type );
 284     bool b_ret = psz_meta && strcasestr( psz_meta, psz );
 285
 286     vlc_mutex_unlock( &p_i->lock );
 287
 288     return b_ret;
 289 }
 290
 291 char *input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
 292 {
 293     vlc_mutex_lock( &p_i->lock );
 294
 295     if( !p_i->p_meta )
 296     {
 297         vlc_mutex_unlock( &p_i->lock );
 298         return NULL;
 299     }
 300
 301     char *psz = NULL;
 302     if( vlc_meta_Get( p_i->p_meta, meta_type ) )
 303         psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );
 304
 305     vlc_mutex_unlock( &p_i->lock );
 306     return psz;
 307 }
 308
 309 /* Get the title of a given item or fallback to the name if the title is empty */
 310 char *input_item_GetTitleFbName( input_item_t *p_item )
 311 {
 312     char *psz_ret;
 313     vlc_mutex_lock( &p_item->lock );
 314
 315     if( !p_item->p_meta )
 316     {
 317         psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 318         vlc_mutex_unlock( &p_item->lock );
 319         return psz_ret;
 320     }
 321
 322     const char *psz_title = vlc_meta_Get( p_item->p_meta, vlc_meta_Title );
 323     if( !EMPTY_STR( psz_title ) )
 324         psz_ret = strdup( psz_title );
 325     else
 326         psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 327
 328     vlc_mutex_unlock( &p_item->lock );
 329     return psz_ret;
 330 }
 331
 332 char *input_item_GetName( input_item_t *p_item )
 333 {
 334     vlc_mutex_lock( &p_item->lock );
 335
 336     char *psz_name = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
 337
 338     vlc_mutex_unlock( &p_item->lock );
 339     return psz_name;
 340 }
 341 void input_item_SetName( input_item_t *p_item, const char *psz_name )
 342 {
 343     vlc_mutex_lock( &p_item->lock );
 344
 345     free( p_item->psz_name );
 346     p_item->psz_name = strdup( psz_name );
 347
 348     vlc_mutex_unlock( &p_item->lock );
 349 }
 350
 351 char *input_item_GetURI( input_item_t *p_i )
 352 {
 353     vlc_mutex_lock( &p_i->lock );
 354
 355     char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
 356
 357     vlc_mutex_unlock( &p_i->lock );
 358     return psz_s;
 359 }
 360 void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
 361 {
 362 #ifndef NDEBUG
 363     if( !strstr( psz_uri, "://" )
 364      || strchr( psz_uri, ' ' ) || strchr( psz_uri, '"' ) )
 365         fprintf( stderr, "Warning: %s(\"%s\"): file path instead of URL.\n",
 366                  __func__, psz_uri );
 367 #endif
 368     vlc_mutex_lock( &p_i->lock );
 369     free( p_i->psz_uri );
 370     p_i->psz_uri = strdup( psz_uri );
 371
 372     p_i->i_type = GuessType( p_i );
 373
 374     if( p_i->psz_name )
 375         ;
 376     else
 377     if( p_i->i_type == ITEM_TYPE_FILE || p_i->i_type == ITEM_TYPE_DIRECTORY )
 378     {
 379         const char *psz_filename = strrchr( p_i->psz_uri, '/' );
 380
 381         if( psz_filename && *psz_filename == '/' )
 382             psz_filename++;
 383         if( psz_filename && *psz_filename )
 384             p_i->psz_name = strdup( psz_filename );
 385
 386         /* Make the name more readable */
 387         if( p_i->psz_name )
 388         {
 389             decode_URI( p_i->psz_name );
 390             EnsureUTF8( p_i->psz_name );
 391         }
 392     }
 393     else
 394     {   /* Strip login and password from title */
 395         int r;
 396         vlc_url_t url;
 397
 398         vlc_UrlParse( &url, psz_uri, 0 );
 399         if( url.psz_protocol )
 400         {
 401             if( url.i_port > 0 )
 402                 r=asprintf( &p_i->psz_name, "%s://%s:%d%s", url.psz_protocol,
 403                           url.psz_host, url.i_port,
 404                           url.psz_path ? url.psz_path : "" );
 405             else
 406                 r=asprintf( &p_i->psz_name, "%s://%s%s", url.psz_protocol,
 407                           url.psz_host ? url.psz_host : "",
 408                           url.psz_path ? url.psz_path : "" );
 409         }
 410         else
 411         {
 412             if( url.i_port > 0 )
 413                 r=asprintf( &p_i->psz_name, "%s:%d%s", url.psz_host, url.i_port,
 414                           url.psz_path ? url.psz_path : "" );
 415             else
 416                 r=asprintf( &p_i->psz_name, "%s%s", url.psz_host,
 417                           url.psz_path ? url.psz_path : "" );
 418         }
 419         vlc_UrlClean( &url );
 420         if( -1==r )
 421             p_i->psz_name=NULL; /* recover from undefined value */
 422     }
 423
 424     vlc_mutex_unlock( &p_i->lock );
 425 }
 426
 427 mtime_t input_item_GetDuration( input_item_t *p_i )
 428 {
 429     vlc_mutex_lock( &p_i->lock );
 430
 431     mtime_t i_duration = p_i->i_duration;
 432
 433     vlc_mutex_unlock( &p_i->lock );
 434     return i_duration;
 435 }
 436
 437 void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
 438 {
 439     bool b_send_event = false;
 440
 441     vlc_mutex_lock( &p_i->lock );
 442     if( p_i->i_duration != i_duration )
 443     {
 444         p_i->i_duration = i_duration;
 445         b_send_event = true;
 446     }
 447     vlc_mutex_unlock( &p_i->lock );
 448
 449     if( b_send_event )
 450     {
 451         vlc_event_t event;
 452
 453         event.type = vlc_InputItemDurationChanged;
 454         event.u.input_item_duration_changed.new_duration = i_duration;
 455         vlc_event_send( &p_i->event_manager, &event );
 456     }
 457 }
 458
 459
 460 bool input_item_IsPreparsed( input_item_t *p_item )
 461 {
 462     vlc_mutex_lock( &p_item->lock );
 463     bool b_preparsed = p_item->p_meta ? ( vlc_meta_GetStatus(p_item->p_meta) & ITEM_PREPARSED ) != 0 : false;
 464     vlc_mutex_unlock( &p_item->lock );
 465
 466     return b_preparsed;
 467 }
 468
 469 bool input_item_IsArtFetched( input_item_t *p_item )
 470 {
 471     vlc_mutex_lock( &p_item->lock );
 472     bool b_fetched = p_item->p_meta ? ( vlc_meta_GetStatus(p_item->p_meta) & ITEM_ART_FETCHED ) != 0 : false;
 473     vlc_mutex_unlock( &p_item->lock );
 474
 475     return b_fetched;
 476 }
 477
 478 static void input_item_Destroy ( gc_object_t *p_gc )
 479 {
 480     input_item_t *p_item = vlc_priv( p_gc, input_item_t );
 481
 482     input_item_Clean( p_item );
 483     free( p_item );
 484 }
 485
 486 int input_item_AddOption( input_item_t *p_input, const char *psz_option,
 487                           unsigned flags )
 488 {
 489     int err = VLC_SUCCESS;
 490
 491     if( psz_option == NULL )
 492         return VLC_EGENERIC;
 493
 494     vlc_mutex_lock( &p_input->lock );
 495     if (flags & VLC_INPUT_OPTION_UNIQUE)
 496     {
 497         for (int i = 0 ; i < p_input->i_options; i++)
 498             if( !strcmp( p_input->ppsz_options[i], psz_option ) )
 499                 goto out;
 500     }
 501
 502     uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
 503     if (flagv == NULL)
 504     {
 505         err = VLC_ENOMEM;
 506         goto out;
 507     }
 508     p_input->optflagv = flagv;
 509     flagv[p_input->optflagc++] = flags;
 510
 511     INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
 512                  p_input->i_options, strdup( psz_option ) );
 513 out:
 514     vlc_mutex_unlock( &p_input->lock );
 515     return err;
 516 }
 517
 518 static info_category_t *InputItemFindCat( input_item_t *p_item,
 519                                           int *pi_index, const char *psz_cat )
 520 {
 521     vlc_assert_locked( &p_item->lock );
 522     for( int i = 0; i < p_item->i_categories && psz_cat; i++ )
 523     {
 524         info_category_t *p_cat = p_item->pp_categories[i];
 525
 526         if( !strcmp( p_cat->psz_name, psz_cat ) )
 527         {
 528             if( pi_index )
 529                 *pi_index = i;
 530             return p_cat;
 531         }
 532     }
 533     return NULL;
 534 }
 535
 536 /**
 537  * Get a info item from a given category in a given input item.
 538  *
 539  * \param p_i The input item to get info from
 540  * \param psz_cat String representing the category for the info
 541  * \param psz_name String representing the name of the desired info
 542  * \return A pointer to the string with the given info if found, or an
 543  *         empty string otherwise. The caller should free the returned
 544  *         pointer.
 545  */
 546 char *input_item_GetInfo( input_item_t *p_i,
 547                           const char *psz_cat,
 548                           const char *psz_name )
 549 {
 550     vlc_mutex_lock( &p_i->lock );
 551
 552     const info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
 553     if( p_cat )
 554     {
 555         info_t *p_info = info_category_FindInfo( p_cat, NULL, psz_name );
 556         if( p_info && p_info->psz_value )
 557         {
 558             char *psz_ret = strdup( p_info->psz_value );
 559             vlc_mutex_unlock( &p_i->lock );
 560             return psz_ret;
 561         }
 562     }
 563     vlc_mutex_unlock( &p_i->lock );
 564     return strdup( "" );
 565 }
 566
 567 static int InputItemVaAddInfo( input_item_t *p_i,
 568                                const char *psz_cat,
 569                                const char *psz_name,
 570                                const char *psz_format, va_list args )
 571 {
 572     vlc_assert_locked( &p_i->lock );
 573
 574     info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
 575     if( !p_cat )
 576     {
 577         p_cat = info_category_New( psz_cat );
 578         if( !p_cat )
 579             return VLC_ENOMEM;
 580         INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
 581                      p_cat );
 582     }
 583     info_t *p_info = info_category_VaAddInfo( p_cat, psz_name, psz_format, args );
 584     if( !p_info || !p_info->psz_value )
 585         return VLC_EGENERIC;
 586     return VLC_SUCCESS;
 587 }
 588
 589 static int InputItemAddInfo( input_item_t *p_i,
 590                              const char *psz_cat,
 591                              const char *psz_name,
 592                              const char *psz_format, ... )
 593 {
 594     va_list args;
 595
 596     va_start( args, psz_format );
 597     const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
 598     va_end( args );
 599
 600     return i_ret;
 601 }
 602
 603 int input_item_AddInfo( input_item_t *p_i,
 604                         const char *psz_cat,
 605                         const char *psz_name,
 606                         const char *psz_format, ... )
 607 {
 608     va_list args;
 609
 610     vlc_mutex_lock( &p_i->lock );
 611
 612     va_start( args, psz_format );
 613     const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
 614     va_end( args );
 615
 616     vlc_mutex_unlock( &p_i->lock );
 617
 618
 619     if( !i_ret )
 620     {
 621         vlc_event_t event;
 622
 623         event.type = vlc_InputItemInfoChanged;
 624         vlc_event_send( &p_i->event_manager, &event );
 625     }
 626     return i_ret;
 627 }
 628
 629 int input_item_DelInfo( input_item_t *p_i,
 630                         const char *psz_cat,
 631                         const char *psz_name )
 632 {
 633     vlc_mutex_lock( &p_i->lock );
 634     int i_cat;
 635     info_category_t *p_cat = InputItemFindCat( p_i, &i_cat, psz_cat );
 636     if( !p_cat )
 637     {
 638         vlc_mutex_unlock( &p_i->lock );
 639         return VLC_EGENERIC;
 640     }
 641
 642     if( psz_name )
 643     {
 644         /* Remove a specific info */
 645         int i_ret = info_category_DeleteInfo( p_cat, psz_name );
 646         if( i_ret )
 647         {
 648             vlc_mutex_unlock( &p_i->lock );
 649             return VLC_EGENERIC;
 650         }
 651     }
 652     else
 653     {
 654         /* Remove the complete categorie */
 655         info_category_Delete( p_cat );
 656         REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
 657     }
 658     vlc_mutex_unlock( &p_i->lock );
 659
 660
 661     vlc_event_t event;
 662     event.type = vlc_InputItemInfoChanged;
 663     vlc_event_send( &p_i->event_manager, &event );
 664
 665     return VLC_SUCCESS;
 666 }
 667 void input_item_ReplaceInfos( input_item_t *p_item, info_category_t *p_cat )
 668 {
 669     vlc_mutex_lock( &p_item->lock );
 670     int i_cat;
 671     info_category_t *p_old = InputItemFindCat( p_item, &i_cat, p_cat->psz_name );
 672     if( p_old )
 673     {
 674         info_category_Delete( p_old );
 675         p_item->pp_categories[i_cat] = p_cat;
 676     }
 677     else
 678     {
 679         INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
 680                      p_cat );
 681     }
 682     vlc_mutex_unlock( &p_item->lock );
 683
 684
 685     vlc_event_t event;
 686     event.type = vlc_InputItemInfoChanged;
 687     vlc_event_send( &p_item->event_manager, &event );
 688 }
 689 void input_item_MergeInfos( input_item_t *p_item, info_category_t *p_cat )
 690 {
 691     vlc_mutex_lock( &p_item->lock );
 692     info_category_t *p_old = InputItemFindCat( p_item, NULL, p_cat->psz_name );
 693     if( p_old )
 694     {
 695         for( int i = 0; i < p_cat->i_infos; i++ )
 696             info_category_ReplaceInfo( p_old, p_cat->pp_infos[i] );
 697         TAB_CLEAN( p_cat->i_infos, p_cat->pp_infos );
 698         info_category_Delete( p_cat );
 699     }
 700     else
 701     {
 702         INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
 703                      p_cat );
 704     }
 705     vlc_mutex_unlock( &p_item->lock );
 706
 707
 708     vlc_event_t event;
 709     event.type = vlc_InputItemInfoChanged;
 710     vlc_event_send( &p_item->event_manager, &event );
 711 }
 712
 713 #define EPG_DEBUG
 714 void input_item_SetEpg( input_item_t *p_item, const vlc_epg_t *p_update )
 715 {
 716     vlc_mutex_lock( &p_item->lock );
 717
 718     /* */
 719     vlc_epg_t *p_epg = NULL;
 720     for( int i = 0; i < p_item->i_epg; i++ )
 721     {
 722         vlc_epg_t *p_tmp = p_item->pp_epg[i];
 723
 724         if( (p_tmp->psz_name == NULL) != (p_update->psz_name == NULL) )
 725             continue;
 726         if( p_tmp->psz_name && p_update->psz_name && strcmp(p_tmp->psz_name, p_update->psz_name) )
 727             continue;
 728
 729         p_epg = p_tmp;
 730         break;
 731     }
 732
 733     /* */
 734     if( !p_epg )
 735     {
 736         p_epg = vlc_epg_New( p_update->psz_name );
 737         if( p_epg )
 738             TAB_APPEND( p_item->i_epg, p_item->pp_epg, p_epg );
 739     }
 740     if( p_epg )
 741         vlc_epg_Merge( p_epg, p_update );
 742
 743     vlc_mutex_unlock( &p_item->lock );
 744
 745 #ifdef EPG_DEBUG
 746     char *psz_epg;
 747     if( asprintf( &psz_epg, "EPG %s", p_epg->psz_name ? p_epg->psz_name : "unknown" ) < 0 )
 748         goto signal;
 749
 750     input_item_DelInfo( p_item, psz_epg, NULL );
 751
 752     vlc_mutex_lock( &p_item->lock );
 753     for( int i = 0; i < p_epg->i_event; i++ )
 754     {
 755         const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
 756         time_t t_start = (time_t)p_evt->i_start;
 757         struct tm tm_start;
 758         char psz_start[128];
 759
 760         localtime_r( &t_start, &tm_start );
 761
 762         snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
 763                   1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
 764                   tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
 765         if( p_evt->psz_short_description || p_evt->psz_description )
 766             InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s %s",
 767                               p_evt->psz_name,
 768                               p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
 769                               p_evt->psz_short_description ? p_evt->psz_short_description : "" ,
 770                               p_evt->psz_description ? p_evt->psz_description : "" );
 771         else
 772             InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
 773                               p_evt->psz_name,
 774                               p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
 775     }
 776     vlc_mutex_unlock( &p_item->lock );
 777     free( psz_epg );
 778 signal:
 779 #endif
 780
 781     if( p_epg->i_event > 0 )
 782     {
 783         vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
 784         vlc_event_send( &p_item->event_manager, &event );
 785     }
 786 }
 787
 788 void input_item_SetEpgOffline( input_item_t *p_item )
 789 {
 790     vlc_mutex_lock( &p_item->lock );
 791     for( int i = 0; i < p_item->i_epg; i++ )
 792         vlc_epg_SetCurrent( p_item->pp_epg[i], -1 );
 793     vlc_mutex_unlock( &p_item->lock );
 794
 795 #ifdef EPG_DEBUG
 796     vlc_mutex_lock( &p_item->lock );
 797     const int i_epg_info = p_item->i_epg;
 798     char *ppsz_epg_info[i_epg_info];
 799     for( int i = 0; i < p_item->i_epg; i++ )
 800     {
 801         const vlc_epg_t *p_epg = p_item->pp_epg[i];
 802         if( asprintf( &ppsz_epg_info[i], "EPG %s", p_epg->psz_name ? p_epg->psz_name : "unknown" ) < 0 )
 803             ppsz_epg_info[i] = NULL;
 804     }
 805     vlc_mutex_unlock( &p_item->lock );
 806
 807     for( int i = 0; i < i_epg_info; i++ )
 808     {
 809         if( !ppsz_epg_info[i] )
 810             continue;
 811         input_item_DelInfo( p_item, ppsz_epg_info[i], NULL );
 812         free( ppsz_epg_info[i] );
 813     }
 814 #endif
 815
 816     vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
 817     vlc_event_send( &p_item->event_manager, &event );
 818 }
 819
 820 #undef input_item_NewExt
 821 input_item_t *input_item_NewExt( vlc_object_t *p_obj, const char *psz_uri,
 822                                  const char *psz_name,
 823                                  int i_options,
 824                                  const char *const *ppsz_options,
 825                                  unsigned i_option_flags,
 826                                  mtime_t i_duration )
 827 {
 828     return input_item_NewWithType( p_obj, psz_uri, psz_name,
 829                                   i_options, ppsz_options, i_option_flags,
 830                                   i_duration, ITEM_TYPE_UNKNOWN );
 831 }
 832
 833
 834 input_item_t *input_item_NewWithType( vlc_object_t *p_obj, const char *psz_uri,
 835                                 const char *psz_name,
 836                                 int i_options,
 837                                 const char *const *ppsz_options,
 838                                 unsigned i_option_flags,
 839                                 mtime_t i_duration,
 840                                 int i_type )
 841 {
 842     libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
 843     static vlc_mutex_t input_id_lock = VLC_STATIC_MUTEX;
 844
 845     input_item_t* p_input = malloc( sizeof(input_item_t ) );
 846     if( !p_input )
 847         return NULL;
 848
 849     input_item_Init( p_obj, p_input );
 850     vlc_gc_init( p_input, input_item_Destroy );
 851
 852     vlc_mutex_lock( &input_id_lock );
 853     p_input->i_id = ++priv->i_last_input_id;
 854     vlc_mutex_unlock( &input_id_lock );
 855
 856     p_input->b_fixed_name = false;
 857
 858     p_input->i_type = i_type;
 859     p_input->b_prefers_tree = false;
 860
 861     if( psz_uri )
 862         input_item_SetURI( p_input, psz_uri );
 863
 864     if( i_type != ITEM_TYPE_UNKNOWN )
 865         p_input->i_type = i_type;
 866
 867     if( psz_name )
 868         input_item_SetName( p_input, psz_name );
 869
 870     p_input->i_duration = i_duration;
 871
 872     for( int i = 0; i < i_options; i++ )
 873         input_item_AddOption( p_input, ppsz_options[i], i_option_flags );
 874     return p_input;
 875 }
 876
 877 struct item_type_entry
 878 {
 879     const char psz_scheme[7];
 880     uint8_t    i_type;
 881 };
 882
 883 static int typecmp( const void *key, const void *entry )
 884 {
 885     const struct item_type_entry *type = entry;
 886     const char *uri = key, *scheme = type->psz_scheme;
 887
 888     return strncmp( uri, scheme, strlen( scheme ) );
 889 }
 890
 891 /* Guess the type of the item using the beginning of the mrl */
 892 static int GuessType( const input_item_t *p_item )
 893 {
 894     static const struct item_type_entry tab[] =
 895     {   /* /!\ Alphabetical order /!\ */
 896         /* Short match work, not just exact match */
 897         { "alsa",   ITEM_TYPE_CARD },
 898         { "atsc",   ITEM_TYPE_CARD },
 899         { "bd",     ITEM_TYPE_DISC },
 900         { "cable",  ITEM_TYPE_CARD },
 901         { "cdda",   ITEM_TYPE_CDDA },
 902         { "dc1394", ITEM_TYPE_CARD },
 903         { "dccp",   ITEM_TYPE_NET },
 904         { "dir",    ITEM_TYPE_DIRECTORY },
 905         { "dshow",  ITEM_TYPE_CARD },
 906         { "dv",     ITEM_TYPE_CARD },
 907         { "dvb",    ITEM_TYPE_CARD },
 908         { "dvd",    ITEM_TYPE_DISC },
 909         { "ftp",    ITEM_TYPE_NET },
 910         { "http",   ITEM_TYPE_NET },
 911         { "icyx",   ITEM_TYPE_NET },
 912         { "itpc",   ITEM_TYPE_NET },
 913         { "jack",   ITEM_TYPE_CARD },
 914         { "live",   ITEM_TYPE_NET }, /* livedotcom */
 915         { "mms",    ITEM_TYPE_NET },
 916         { "mtp",    ITEM_TYPE_DISC },
 917         { "ofdm",   ITEM_TYPE_CARD },
 918         { "oss",    ITEM_TYPE_CARD },
 919         { "pnm",    ITEM_TYPE_NET },
 920         { "pvr",    ITEM_TYPE_CARD },
 921         { "qam",    ITEM_TYPE_CARD },
 922         { "qpsk",   ITEM_TYPE_CARD },
 923         { "qtcapt", ITEM_TYPE_CARD }, /* qtcapture */
 924         { "raw139", ITEM_TYPE_CARD }, /* raw1394 */
 925         { "rt",     ITEM_TYPE_NET }, /* rtp, rtsp, rtmp */
 926         { "satell", ITEM_TYPE_CARD }, /* sattelite */
 927         { "screen", ITEM_TYPE_CARD },
 928         { "sdp",    ITEM_TYPE_NET },
 929         { "smb",    ITEM_TYPE_NET },
 930         { "svcd",   ITEM_TYPE_DISC },
 931         { "tcp",    ITEM_TYPE_NET },
 932         { "terres", ITEM_TYPE_CARD }, /* terrestrial */
 933         { "udp",    ITEM_TYPE_NET },  /* udplite too */
 934         { "unsv",   ITEM_TYPE_NET },
 935         { "usdigi", ITEM_TYPE_CARD }, /* usdigital */
 936         { "v4l",    ITEM_TYPE_CARD },
 937         { "vcd",    ITEM_TYPE_DISC },
 938         { "window", ITEM_TYPE_CARD },
 939     };
 940     const struct item_type_entry *e;
 941
 942     if( !strstr( p_item->psz_uri, "://" ) )
 943         return ITEM_TYPE_FILE;
 944
 945     e = bsearch( p_item->psz_uri, tab, sizeof( tab ) / sizeof( tab[0] ),
 946                  sizeof( tab[0] ), typecmp );
 947     return e ? e->i_type : ITEM_TYPE_FILE;
 948 }
 949
 950 input_item_node_t *input_item_node_Create( input_item_t *p_input )
 951 {
 952     input_item_node_t* p_node = malloc( sizeof( input_item_node_t ) );
 953     if( !p_node )
 954         return NULL;
 955
 956     assert( p_input );
 957
 958     p_node->p_item = p_input;
 959     vlc_gc_incref( p_input );
 960
 961     p_node->p_parent = NULL;
 962     p_node->i_children = 0;
 963     p_node->pp_children = NULL;
 964
 965     return p_node;
 966 }
 967
 968 static void RecursiveNodeDelete( input_item_node_t *p_node )
 969 {
 970   for( int i = 0; i < p_node->i_children; i++ )
 971       RecursiveNodeDelete( p_node->pp_children[i] );
 972
 973   vlc_gc_decref( p_node->p_item );
 974   free( p_node->pp_children );
 975   free( p_node );
 976 }
 977
 978 void input_item_node_Delete( input_item_node_t *p_node )
 979 {
 980   if(  p_node->p_parent )
 981   {
 982       for( int i = 0; i < p_node->p_parent->i_children; i++ )
 983           if( p_node->p_parent->pp_children[i] == p_node )
 984           {
 985               REMOVE_ELEM( p_node->p_parent->pp_children,
 986                            p_node->p_parent->i_children,
 987                            i );
 988               break;
 989           }
 990   }
 991
 992   RecursiveNodeDelete( p_node );
 993 }
 994
 995 input_item_node_t *input_item_node_AppendItem( input_item_node_t *p_node, input_item_t *p_item )
 996 {
 997     input_item_node_t *p_new_child = input_item_node_Create( p_item );
 998     if( !p_new_child ) return NULL;
 999     input_item_node_AppendNode( p_node, p_new_child );
1000     return p_new_child;
1001 }
1002
1003 void input_item_node_AppendNode( input_item_node_t *p_parent, input_item_node_t *p_child )
1004 {
1005     assert( p_parent && p_child && p_child->p_parent == NULL );
1006     INSERT_ELEM( p_parent->pp_children,
1007                  p_parent->i_children,
1008                  p_parent->i_children,
1009                  p_child );
1010     p_child->p_parent = p_parent;
1011 }
1012
1013 void input_item_node_PostAndDelete( input_item_node_t *p_root )
1014 {
1015   post_subitems( p_root );
1016
1017   vlc_event_t event;
1018   event.type = vlc_InputItemSubItemTreeAdded;
1019   event.u.input_item_subitem_tree_added.p_root = p_root;
1020   vlc_event_send( &p_root->p_item->event_manager, &event );
1021
1022   input_item_node_Delete( p_root );
1023 }