1 /*****************************************************************************
2 * item.c: input_item management
3 *****************************************************************************
4 * Copyright (C) 1998-2004 the VideoLAN team
7 * Authors: Clément Stenac <zorglub@videolan.org>
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.
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.
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 *****************************************************************************/
29 #include <vlc_common.h>
31 #include "vlc_playlist.h"
32 #include "vlc_interface.h"
33 #include <vlc_charset.h>
38 static int GuessType( const input_item_t
*p_item
);
40 /** Stuff moved out of vlc_input.h -- FIXME: should probably not be inline
42 static inline void input_item_Init( vlc_object_t
*p_o
, input_item_t
*p_i
)
44 memset( p_i
, 0, sizeof(input_item_t
) );
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
);
54 p_i
->i_type
= ITEM_TYPE_UNKNOWN
;
55 p_i
->b_fixed_name
= true;
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
);
73 static inline void input_item_Clean( input_item_t
*p_i
)
77 vlc_event_manager_fini( &p_i
->event_manager
);
79 free( p_i
->psz_name
);
83 vlc_mutex_destroy( &p_i
->p_stats
->lock
);
88 vlc_meta_Delete( p_i
->p_meta
);
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
);
95 for( i
= 0; i
< p_i
->i_es
; i
++ )
97 es_format_Clean( p_i
->es
[i
] );
100 TAB_CLEAN( p_i
->i_es
, p_i
->es
);
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
);
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
);
110 vlc_mutex_destroy( &p_i
->lock
);
112 void input_item_SetErrorWhenReading( input_item_t
*p_i
, bool b_error
)
116 vlc_mutex_lock( &p_i
->lock
);
118 b_changed
= p_i
->b_error_when_reading
!= b_error
;
119 p_i
->b_error_when_reading
= b_error
;
121 vlc_mutex_unlock( &p_i
->lock
);
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
);
132 void input_item_SetPreparsed( input_item_t
*p_i
, bool b_preparsed
)
134 bool b_send_event
= false;
136 vlc_mutex_lock( &p_i
->lock
);
139 p_i
->p_meta
= vlc_meta_New();
141 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
144 new_status
= status
| ITEM_PREPARSED
;
146 new_status
= status
& ~ITEM_PREPARSED
;
147 if( status
!= new_status
)
149 vlc_meta_SetStatus(p_i
->p_meta
, new_status
);
153 vlc_mutex_unlock( &p_i
->lock
);
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
);
164 void input_item_SetArtNotFound( input_item_t
*p_i
, bool b_not_found
)
166 vlc_mutex_lock( &p_i
->lock
);
169 p_i
->p_meta
= vlc_meta_New();
171 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
174 status
|= ITEM_ART_NOTFOUND
;
176 status
&= ~ITEM_ART_NOTFOUND
;
178 vlc_meta_SetStatus(p_i
->p_meta
, status
);
180 vlc_mutex_unlock( &p_i
->lock
);
183 void input_item_SetArtFetched( input_item_t
*p_i
, bool b_art_fetched
)
185 vlc_mutex_lock( &p_i
->lock
);
188 p_i
->p_meta
= vlc_meta_New();
190 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
193 status
|= ITEM_ART_FETCHED
;
195 status
&= ~ITEM_ART_FETCHED
;
197 vlc_meta_SetStatus(p_i
->p_meta
, status
);
199 vlc_mutex_unlock( &p_i
->lock
);
202 void input_item_SetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
, const char *psz_val
)
206 vlc_mutex_lock( &p_i
->lock
);
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
);
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
);
218 /* FIXME GRRRRRRRRRR args should be in the reverse order to be
219 * consistent with (nearly?) all or copy funcs */
220 void input_item_CopyOptions( input_item_t
*p_parent
,
221 input_item_t
*p_child
)
223 vlc_mutex_lock( &p_parent
->lock
);
225 for( int i
= 0 ; i
< p_parent
->i_options
; i
++ )
227 if( !strcmp( p_parent
->ppsz_options
[i
], "meta-file" ) )
230 input_item_AddOption( p_child
,
231 p_parent
->ppsz_options
[i
],
232 p_parent
->optflagv
[i
] );
235 vlc_mutex_unlock( &p_parent
->lock
);
238 static void post_subitems( input_item_node_t
*p_node
)
240 for( int i
= 0; i
< p_node
->i_children
; i
++ )
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
);
247 post_subitems( p_node
->pp_children
[i
] );
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
)
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
);
262 bool input_item_HasErrorWhenReading( input_item_t
*p_item
)
264 vlc_mutex_lock( &p_item
->lock
);
266 bool b_error
= p_item
->b_error_when_reading
;
268 vlc_mutex_unlock( &p_item
->lock
);
273 bool input_item_MetaMatch( input_item_t
*p_i
,
274 vlc_meta_type_t meta_type
, const char *psz
)
276 vlc_mutex_lock( &p_i
->lock
);
280 vlc_mutex_unlock( &p_i
->lock
);
283 const char *psz_meta
= vlc_meta_Get( p_i
->p_meta
, meta_type
);
284 bool b_ret
= psz_meta
&& strcasestr( psz_meta
, psz
);
286 vlc_mutex_unlock( &p_i
->lock
);
291 char *input_item_GetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
)
293 vlc_mutex_lock( &p_i
->lock
);
297 vlc_mutex_unlock( &p_i
->lock
);
302 if( vlc_meta_Get( p_i
->p_meta
, meta_type
) )
303 psz
= strdup( vlc_meta_Get( p_i
->p_meta
, meta_type
) );
305 vlc_mutex_unlock( &p_i
->lock
);
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
)
313 vlc_mutex_lock( &p_item
->lock
);
315 if( !p_item
->p_meta
)
317 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
318 vlc_mutex_unlock( &p_item
->lock
);
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
);
326 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
328 vlc_mutex_unlock( &p_item
->lock
);
332 char *input_item_GetName( input_item_t
*p_item
)
334 vlc_mutex_lock( &p_item
->lock
);
336 char *psz_name
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
338 vlc_mutex_unlock( &p_item
->lock
);
341 void input_item_SetName( input_item_t
*p_item
, const char *psz_name
)
343 vlc_mutex_lock( &p_item
->lock
);
345 free( p_item
->psz_name
);
346 p_item
->psz_name
= strdup( psz_name
);
348 vlc_mutex_unlock( &p_item
->lock
);
351 char *input_item_GetURI( input_item_t
*p_i
)
353 vlc_mutex_lock( &p_i
->lock
);
355 char *psz_s
= p_i
->psz_uri
? strdup( p_i
->psz_uri
) : NULL
;
357 vlc_mutex_unlock( &p_i
->lock
);
361 void input_item_SetURI( input_item_t
*p_i
, const char *psz_uri
)
365 if( !strstr( psz_uri
, "://" )
366 || strchr( psz_uri
, ' ' ) || strchr( psz_uri
, '"' ) )
367 fprintf( stderr
, "Warning: %s(\"%s\"): file path instead of URL.\n",
370 vlc_mutex_lock( &p_i
->lock
);
371 free( p_i
->psz_uri
);
372 p_i
->psz_uri
= strdup( psz_uri
);
374 p_i
->i_type
= GuessType( p_i
);
379 if( p_i
->i_type
== ITEM_TYPE_FILE
|| p_i
->i_type
== ITEM_TYPE_DIRECTORY
)
381 const char *psz_filename
= strrchr( p_i
->psz_uri
, '/' );
383 if( psz_filename
&& *psz_filename
== '/' )
385 if( psz_filename
&& *psz_filename
)
386 p_i
->psz_name
= strdup( psz_filename
);
388 /* Make the name more readable */
391 decode_URI( p_i
->psz_name
);
392 EnsureUTF8( p_i
->psz_name
);
396 { /* Strip login and password from title */
400 vlc_UrlParse( &url
, psz_uri
, 0 );
401 if( url
.psz_protocol
)
404 r
=asprintf( &p_i
->psz_name
, "%s://%s:%d%s", url
.psz_protocol
,
405 url
.psz_host
, url
.i_port
,
406 url
.psz_path
? url
.psz_path
: "" );
408 r
=asprintf( &p_i
->psz_name
, "%s://%s%s", url
.psz_protocol
,
409 url
.psz_host
? url
.psz_host
: "",
410 url
.psz_path
? url
.psz_path
: "" );
415 r
=asprintf( &p_i
->psz_name
, "%s:%d%s", url
.psz_host
, url
.i_port
,
416 url
.psz_path
? url
.psz_path
: "" );
418 r
=asprintf( &p_i
->psz_name
, "%s%s", url
.psz_host
,
419 url
.psz_path
? url
.psz_path
: "" );
421 vlc_UrlClean( &url
);
423 p_i
->psz_name
=NULL
; /* recover from undefined value */
426 vlc_mutex_unlock( &p_i
->lock
);
429 mtime_t
input_item_GetDuration( input_item_t
*p_i
)
431 vlc_mutex_lock( &p_i
->lock
);
433 mtime_t i_duration
= p_i
->i_duration
;
435 vlc_mutex_unlock( &p_i
->lock
);
439 void input_item_SetDuration( input_item_t
*p_i
, mtime_t i_duration
)
441 bool b_send_event
= false;
443 vlc_mutex_lock( &p_i
->lock
);
444 if( p_i
->i_duration
!= i_duration
)
446 p_i
->i_duration
= i_duration
;
449 vlc_mutex_unlock( &p_i
->lock
);
455 event
.type
= vlc_InputItemDurationChanged
;
456 event
.u
.input_item_duration_changed
.new_duration
= i_duration
;
457 vlc_event_send( &p_i
->event_manager
, &event
);
462 bool input_item_IsPreparsed( input_item_t
*p_item
)
464 vlc_mutex_lock( &p_item
->lock
);
465 bool b_preparsed
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_PREPARSED
) != 0 : false;
466 vlc_mutex_unlock( &p_item
->lock
);
471 bool input_item_IsArtFetched( input_item_t
*p_item
)
473 vlc_mutex_lock( &p_item
->lock
);
474 bool b_fetched
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_ART_FETCHED
) != 0 : false;
475 vlc_mutex_unlock( &p_item
->lock
);
480 static void input_item_Destroy ( gc_object_t
*p_gc
)
482 input_item_t
*p_item
= vlc_priv( p_gc
, input_item_t
);
484 input_item_Clean( p_item
);
488 int input_item_AddOption( input_item_t
*p_input
, const char *psz_option
,
491 int err
= VLC_SUCCESS
;
493 if( psz_option
== NULL
)
496 vlc_mutex_lock( &p_input
->lock
);
497 if (flags
& VLC_INPUT_OPTION_UNIQUE
)
499 for (int i
= 0 ; i
< p_input
->i_options
; i
++)
500 if( !strcmp( p_input
->ppsz_options
[i
], psz_option
) )
504 uint8_t *flagv
= realloc (p_input
->optflagv
, p_input
->optflagc
+ 1);
510 p_input
->optflagv
= flagv
;
511 flagv
[p_input
->optflagc
++] = flags
;
513 INSERT_ELEM( p_input
->ppsz_options
, p_input
->i_options
,
514 p_input
->i_options
, strdup( psz_option
) );
516 vlc_mutex_unlock( &p_input
->lock
);
520 static info_category_t
*InputItemFindCat( input_item_t
*p_item
,
521 int *pi_index
, const char *psz_cat
)
523 vlc_assert_locked( &p_item
->lock
);
524 for( int i
= 0; i
< p_item
->i_categories
&& psz_cat
; i
++ )
526 info_category_t
*p_cat
= p_item
->pp_categories
[i
];
528 if( !strcmp( p_cat
->psz_name
, psz_cat
) )
539 * Get a info item from a given category in a given input item.
541 * \param p_i The input item to get info from
542 * \param psz_cat String representing the category for the info
543 * \param psz_name String representing the name of the desired info
544 * \return A pointer to the string with the given info if found, or an
545 * empty string otherwise. The caller should free the returned
548 char *input_item_GetInfo( input_item_t
*p_i
,
550 const char *psz_name
)
552 vlc_mutex_lock( &p_i
->lock
);
554 const info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
557 info_t
*p_info
= info_category_FindInfo( p_cat
, NULL
, psz_name
);
558 if( p_info
&& p_info
->psz_value
)
560 char *psz_ret
= strdup( p_info
->psz_value
);
561 vlc_mutex_unlock( &p_i
->lock
);
565 vlc_mutex_unlock( &p_i
->lock
);
569 static int InputItemVaAddInfo( input_item_t
*p_i
,
571 const char *psz_name
,
572 const char *psz_format
, va_list args
)
574 vlc_assert_locked( &p_i
->lock
);
576 info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
579 p_cat
= info_category_New( psz_cat
);
582 INSERT_ELEM( p_i
->pp_categories
, p_i
->i_categories
, p_i
->i_categories
,
585 info_t
*p_info
= info_category_VaAddInfo( p_cat
, psz_name
, psz_format
, args
);
586 if( !p_info
|| !p_info
->psz_value
)
591 static int InputItemAddInfo( input_item_t
*p_i
,
593 const char *psz_name
,
594 const char *psz_format
, ... )
598 va_start( args
, psz_format
);
599 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
605 int input_item_AddInfo( input_item_t
*p_i
,
607 const char *psz_name
,
608 const char *psz_format
, ... )
612 vlc_mutex_lock( &p_i
->lock
);
614 va_start( args
, psz_format
);
615 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
618 vlc_mutex_unlock( &p_i
->lock
);
625 event
.type
= vlc_InputItemInfoChanged
;
626 vlc_event_send( &p_i
->event_manager
, &event
);
631 int input_item_DelInfo( input_item_t
*p_i
,
633 const char *psz_name
)
635 vlc_mutex_lock( &p_i
->lock
);
637 info_category_t
*p_cat
= InputItemFindCat( p_i
, &i_cat
, psz_cat
);
640 vlc_mutex_unlock( &p_i
->lock
);
646 /* Remove a specific info */
647 int i_ret
= info_category_DeleteInfo( p_cat
, psz_name
);
650 vlc_mutex_unlock( &p_i
->lock
);
656 /* Remove the complete categorie */
657 info_category_Delete( p_cat
);
658 REMOVE_ELEM( p_i
->pp_categories
, p_i
->i_categories
, i_cat
);
660 vlc_mutex_unlock( &p_i
->lock
);
664 event
.type
= vlc_InputItemInfoChanged
;
665 vlc_event_send( &p_i
->event_manager
, &event
);
669 void input_item_ReplaceInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
671 vlc_mutex_lock( &p_item
->lock
);
673 info_category_t
*p_old
= InputItemFindCat( p_item
, &i_cat
, p_cat
->psz_name
);
676 info_category_Delete( p_old
);
677 p_item
->pp_categories
[i_cat
] = p_cat
;
681 INSERT_ELEM( p_item
->pp_categories
, p_item
->i_categories
, p_item
->i_categories
,
684 vlc_mutex_unlock( &p_item
->lock
);
688 event
.type
= vlc_InputItemInfoChanged
;
689 vlc_event_send( &p_item
->event_manager
, &event
);
691 void input_item_MergeInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
693 vlc_mutex_lock( &p_item
->lock
);
694 info_category_t
*p_old
= InputItemFindCat( p_item
, NULL
, p_cat
->psz_name
);
697 for( int i
= 0; i
< p_cat
->i_infos
; i
++ )
698 info_category_ReplaceInfo( p_old
, p_cat
->pp_infos
[i
] );
699 TAB_CLEAN( p_cat
->i_infos
, p_cat
->pp_infos
);
700 info_category_Delete( p_cat
);
704 INSERT_ELEM( p_item
->pp_categories
, p_item
->i_categories
, p_item
->i_categories
,
707 vlc_mutex_unlock( &p_item
->lock
);
711 event
.type
= vlc_InputItemInfoChanged
;
712 vlc_event_send( &p_item
->event_manager
, &event
);
716 void input_item_SetEpg( input_item_t
*p_item
, const vlc_epg_t
*p_update
)
718 vlc_mutex_lock( &p_item
->lock
);
721 vlc_epg_t
*p_epg
= NULL
;
722 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
724 vlc_epg_t
*p_tmp
= p_item
->pp_epg
[i
];
726 if( (p_tmp
->psz_name
== NULL
) != (p_update
->psz_name
== NULL
) )
728 if( p_tmp
->psz_name
&& p_update
->psz_name
&& strcmp(p_tmp
->psz_name
, p_update
->psz_name
) )
738 p_epg
= vlc_epg_New( p_update
->psz_name
);
740 TAB_APPEND( p_item
->i_epg
, p_item
->pp_epg
, p_epg
);
743 vlc_epg_Merge( p_epg
, p_update
);
745 vlc_mutex_unlock( &p_item
->lock
);
749 if( asprintf( &psz_epg
, "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
752 input_item_DelInfo( p_item
, psz_epg
, NULL
);
754 vlc_mutex_lock( &p_item
->lock
);
755 for( int i
= 0; i
< p_epg
->i_event
; i
++ )
757 const vlc_epg_event_t
*p_evt
= p_epg
->pp_event
[i
];
758 time_t t_start
= (time_t)p_evt
->i_start
;
762 localtime_r( &t_start
, &tm_start
);
764 snprintf( psz_start
, sizeof(psz_start
), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
765 1900 + tm_start
.tm_year
, 1 + tm_start
.tm_mon
, tm_start
.tm_mday
,
766 tm_start
.tm_hour
, tm_start
.tm_min
, tm_start
.tm_sec
);
767 if( p_evt
->psz_short_description
|| p_evt
->psz_description
)
768 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d) - %s %s",
770 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60,
771 p_evt
->psz_short_description
? p_evt
->psz_short_description
: "" ,
772 p_evt
->psz_description
? p_evt
->psz_description
: "" );
774 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d)",
776 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60 );
778 vlc_mutex_unlock( &p_item
->lock
);
783 if( p_epg
->i_event
> 0 )
785 vlc_event_t event
= { .type
= vlc_InputItemInfoChanged
, };
786 vlc_event_send( &p_item
->event_manager
, &event
);
790 void input_item_SetEpgOffline( input_item_t
*p_item
)
792 vlc_mutex_lock( &p_item
->lock
);
793 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
794 vlc_epg_SetCurrent( p_item
->pp_epg
[i
], -1 );
795 vlc_mutex_unlock( &p_item
->lock
);
798 vlc_mutex_lock( &p_item
->lock
);
799 const int i_epg_info
= p_item
->i_epg
;
800 char *ppsz_epg_info
[i_epg_info
];
801 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
803 const vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
804 if( asprintf( &ppsz_epg_info
[i
], "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
805 ppsz_epg_info
[i
] = NULL
;
807 vlc_mutex_unlock( &p_item
->lock
);
809 for( int i
= 0; i
< i_epg_info
; i
++ )
811 if( !ppsz_epg_info
[i
] )
813 input_item_DelInfo( p_item
, ppsz_epg_info
[i
], NULL
);
814 free( ppsz_epg_info
[i
] );
818 vlc_event_t event
= { .type
= vlc_InputItemInfoChanged
, };
819 vlc_event_send( &p_item
->event_manager
, &event
);
822 #undef input_item_NewExt
823 input_item_t
*input_item_NewExt( vlc_object_t
*p_obj
, const char *psz_uri
,
824 const char *psz_name
,
826 const char *const *ppsz_options
,
827 unsigned i_option_flags
,
830 return input_item_NewWithType( p_obj
, psz_uri
, psz_name
,
831 i_options
, ppsz_options
, i_option_flags
,
832 i_duration
, ITEM_TYPE_UNKNOWN
);
836 input_item_t
*input_item_NewWithType( vlc_object_t
*p_obj
, const char *psz_uri
,
837 const char *psz_name
,
839 const char *const *ppsz_options
,
840 unsigned i_option_flags
,
844 libvlc_priv_t
*priv
= libvlc_priv (p_obj
->p_libvlc
);
845 static vlc_mutex_t input_id_lock
= VLC_STATIC_MUTEX
;
847 input_item_t
* p_input
= malloc( sizeof(input_item_t
) );
851 input_item_Init( p_obj
, p_input
);
852 vlc_gc_init( p_input
, input_item_Destroy
);
854 vlc_mutex_lock( &input_id_lock
);
855 p_input
->i_id
= ++priv
->i_last_input_id
;
856 vlc_mutex_unlock( &input_id_lock
);
858 p_input
->b_fixed_name
= false;
860 p_input
->i_type
= i_type
;
863 input_item_SetURI( p_input
, psz_uri
);
865 if( i_type
!= ITEM_TYPE_UNKNOWN
)
866 p_input
->i_type
= i_type
;
869 input_item_SetName( p_input
, psz_name
);
871 p_input
->i_duration
= i_duration
;
873 for( int i
= 0; i
< i_options
; i
++ )
874 input_item_AddOption( p_input
, ppsz_options
[i
], i_option_flags
);
878 input_item_t
*input_item_Copy( vlc_object_t
*p_obj
, input_item_t
*p_input
)
880 vlc_mutex_lock( &p_input
->lock
);
882 input_item_t
*p_new_input
=
883 input_item_NewWithType( p_obj
,
884 p_input
->psz_uri
, p_input
->psz_name
,
885 0, NULL
, 0, p_input
->i_duration
,
890 for( int i
= 0 ; i
< p_input
->i_options
; i
++ )
892 input_item_AddOption( p_new_input
,
893 p_input
->ppsz_options
[i
],
894 p_input
->optflagv
[i
] );
898 vlc_mutex_unlock( &p_input
->lock
);
903 struct item_type_entry
905 const char psz_scheme
[7];
909 static int typecmp( const void *key
, const void *entry
)
911 const struct item_type_entry
*type
= entry
;
912 const char *uri
= key
, *scheme
= type
->psz_scheme
;
914 return strncmp( uri
, scheme
, strlen( scheme
) );
917 /* Guess the type of the item using the beginning of the mrl */
918 static int GuessType( const input_item_t
*p_item
)
920 static const struct item_type_entry tab
[] =
921 { /* /!\ Alphabetical order /!\ */
922 /* Short match work, not just exact match */
923 { "alsa", ITEM_TYPE_CARD
},
924 { "atsc", ITEM_TYPE_CARD
},
925 { "bd", ITEM_TYPE_DISC
},
926 { "cable", ITEM_TYPE_CARD
},
927 { "cdda", ITEM_TYPE_CDDA
},
928 { "dc1394", ITEM_TYPE_CARD
},
929 { "dccp", ITEM_TYPE_NET
},
930 { "dir", ITEM_TYPE_DIRECTORY
},
931 { "dshow", ITEM_TYPE_CARD
},
932 { "dv", ITEM_TYPE_CARD
},
933 { "dvb", ITEM_TYPE_CARD
},
934 { "dvd", ITEM_TYPE_DISC
},
935 { "ftp", ITEM_TYPE_NET
},
936 { "http", ITEM_TYPE_NET
},
937 { "icyx", ITEM_TYPE_NET
},
938 { "itpc", ITEM_TYPE_NET
},
939 { "jack", ITEM_TYPE_CARD
},
940 { "live", ITEM_TYPE_NET
}, /* livedotcom */
941 { "mms", ITEM_TYPE_NET
},
942 { "mtp", ITEM_TYPE_DISC
},
943 { "ofdm", ITEM_TYPE_CARD
},
944 { "oss", ITEM_TYPE_CARD
},
945 { "pnm", ITEM_TYPE_NET
},
946 { "pvr", ITEM_TYPE_CARD
},
947 { "qam", ITEM_TYPE_CARD
},
948 { "qpsk", ITEM_TYPE_CARD
},
949 { "qtcapt", ITEM_TYPE_CARD
}, /* qtcapture */
950 { "raw139", ITEM_TYPE_CARD
}, /* raw1394 */
951 { "rt", ITEM_TYPE_NET
}, /* rtp, rtsp, rtmp */
952 { "satell", ITEM_TYPE_CARD
}, /* sattelite */
953 { "screen", ITEM_TYPE_CARD
},
954 { "sdp", ITEM_TYPE_NET
},
955 { "smb", ITEM_TYPE_NET
},
956 { "svcd", ITEM_TYPE_DISC
},
957 { "tcp", ITEM_TYPE_NET
},
958 { "terres", ITEM_TYPE_CARD
}, /* terrestrial */
959 { "udp", ITEM_TYPE_NET
}, /* udplite too */
960 { "unsv", ITEM_TYPE_NET
},
961 { "usdigi", ITEM_TYPE_CARD
}, /* usdigital */
962 { "v4l", ITEM_TYPE_CARD
},
963 { "vcd", ITEM_TYPE_DISC
},
964 { "window", ITEM_TYPE_CARD
},
966 const struct item_type_entry
*e
;
968 if( !strstr( p_item
->psz_uri
, "://" ) )
969 return ITEM_TYPE_FILE
;
971 e
= bsearch( p_item
->psz_uri
, tab
, sizeof( tab
) / sizeof( tab
[0] ),
972 sizeof( tab
[0] ), typecmp
);
973 return e
? e
->i_type
: ITEM_TYPE_FILE
;
976 input_item_node_t
*input_item_node_Create( input_item_t
*p_input
)
978 input_item_node_t
* p_node
= malloc( sizeof( input_item_node_t
) );
984 p_node
->p_item
= p_input
;
985 vlc_gc_incref( p_input
);
987 p_node
->p_parent
= NULL
;
988 p_node
->i_children
= 0;
989 p_node
->pp_children
= NULL
;
994 static void RecursiveNodeDelete( input_item_node_t
*p_node
)
996 for( int i
= 0; i
< p_node
->i_children
; i
++ )
997 RecursiveNodeDelete( p_node
->pp_children
[i
] );
999 vlc_gc_decref( p_node
->p_item
);
1000 free( p_node
->pp_children
);
1004 void input_item_node_Delete( input_item_node_t
*p_node
)
1006 if( p_node
->p_parent
)
1008 for( int i
= 0; i
< p_node
->p_parent
->i_children
; i
++ )
1009 if( p_node
->p_parent
->pp_children
[i
] == p_node
)
1011 REMOVE_ELEM( p_node
->p_parent
->pp_children
,
1012 p_node
->p_parent
->i_children
,
1018 RecursiveNodeDelete( p_node
);
1021 input_item_node_t
*input_item_node_AppendItem( input_item_node_t
*p_node
, input_item_t
*p_item
)
1023 input_item_node_t
*p_new_child
= input_item_node_Create( p_item
);
1024 if( !p_new_child
) return NULL
;
1025 input_item_node_AppendNode( p_node
, p_new_child
);
1029 void input_item_node_AppendNode( input_item_node_t
*p_parent
, input_item_node_t
*p_child
)
1031 assert( p_parent
&& p_child
&& p_child
->p_parent
== NULL
);
1032 INSERT_ELEM( p_parent
->pp_children
,
1033 p_parent
->i_children
,
1034 p_parent
->i_children
,
1036 p_child
->p_parent
= p_parent
;
1039 void input_item_node_PostAndDelete( input_item_node_t
*p_root
)
1041 post_subitems( p_root
);
1044 event
.type
= vlc_InputItemSubItemTreeAdded
;
1045 event
.u
.input_item_subitem_tree_added
.p_root
= p_root
;
1046 vlc_event_send( &p_root
->p_item
->event_manager
, &event
);
1048 input_item_node_Delete( p_root
);