1 /*****************************************************************************
2 * item.c: input_item management
3 *****************************************************************************
4 * Copyright (C) 1998-2004 VLC authors and VideoLAN
6 * Authors: Clément Stenac <zorglub@videolan.org>
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21 *****************************************************************************/
31 #include <vlc_common.h>
33 #include <vlc_interface.h>
34 #include <vlc_charset.h>
35 #include <vlc_strings.h>
39 #include "input_internal.h"
41 struct input_item_opaque
43 struct input_item_opaque
*next
;
48 static enum input_item_type_e
GuessType( const input_item_t
*p_item
, bool *p_net
);
50 void input_item_SetErrorWhenReading( input_item_t
*p_i
, bool b_error
)
54 vlc_mutex_lock( &p_i
->lock
);
56 b_changed
= p_i
->b_error_when_reading
!= b_error
;
57 p_i
->b_error_when_reading
= b_error
;
59 vlc_mutex_unlock( &p_i
->lock
);
63 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
64 .type
= vlc_InputItemErrorWhenReadingChanged
,
65 .u
.input_item_error_when_reading_changed
.new_value
= b_error
} );
68 void input_item_SetPreparsed( input_item_t
*p_i
, bool b_preparsed
)
70 bool b_send_event
= false;
72 vlc_mutex_lock( &p_i
->lock
);
74 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
77 new_status
= status
| ITEM_PREPARSED
;
79 new_status
= status
& ~ITEM_PREPARSED
;
80 if( status
!= new_status
)
82 vlc_meta_SetStatus(p_i
->p_meta
, new_status
);
86 vlc_mutex_unlock( &p_i
->lock
);
90 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
91 .type
= vlc_InputItemPreparsedChanged
,
92 .u
.input_item_preparsed_changed
.new_status
= new_status
} );
96 void input_item_SetArtNotFound( input_item_t
*p_i
, bool b_not_found
)
98 vlc_mutex_lock( &p_i
->lock
);
100 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
103 status
|= ITEM_ART_NOTFOUND
;
105 status
&= ~ITEM_ART_NOTFOUND
;
107 vlc_meta_SetStatus(p_i
->p_meta
, status
);
109 vlc_mutex_unlock( &p_i
->lock
);
112 void input_item_SetArtFetched( input_item_t
*p_i
, bool b_art_fetched
)
114 vlc_mutex_lock( &p_i
->lock
);
116 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
119 status
|= ITEM_ART_FETCHED
;
121 status
&= ~ITEM_ART_FETCHED
;
123 vlc_meta_SetStatus(p_i
->p_meta
, status
);
125 vlc_mutex_unlock( &p_i
->lock
);
128 void input_item_SetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
, const char *psz_val
)
130 vlc_mutex_lock( &p_i
->lock
);
131 vlc_meta_Set( p_i
->p_meta
, meta_type
, psz_val
);
132 vlc_mutex_unlock( &p_i
->lock
);
134 /* Notify interested third parties */
135 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
136 .type
= vlc_InputItemMetaChanged
,
137 .u
.input_item_meta_changed
.meta_type
= meta_type
} );
140 void input_item_CopyOptions( input_item_t
*p_child
,
141 input_item_t
*p_parent
)
144 uint8_t *flagv
= NULL
;
146 char **optv_realloc
= NULL
;
147 uint8_t *flagv_realloc
= NULL
;
149 vlc_mutex_lock( &p_parent
->lock
);
151 if( p_parent
->i_options
> 0 )
153 optv
= vlc_alloc( p_parent
->i_options
, sizeof (*optv
) );
155 flagv
= vlc_alloc( p_parent
->i_options
, sizeof (*flagv
) );
159 for( int i
= 0; i
< p_parent
->i_options
; i
++ )
161 char *psz_dup
= strdup( p_parent
->ppsz_options
[i
] );
162 if( likely(psz_dup
) )
164 flagv
[optc
] = p_parent
->optflagv
[i
];
165 optv
[optc
++] = psz_dup
;
171 vlc_mutex_unlock( &p_parent
->lock
);
173 if( likely(optv
&& flagv
&& optc
) )
175 vlc_mutex_lock( &p_child
->lock
);
177 if( INT_MAX
- p_child
->i_options
>= optc
&&
178 SIZE_MAX
/ sizeof (*flagv
) >= (size_t) (p_child
->i_options
+ optc
) )
179 flagv_realloc
= realloc( p_child
->optflagv
,
180 (p_child
->i_options
+ optc
) * sizeof (*flagv
) );
181 if( likely(flagv_realloc
) )
183 p_child
->optflagv
= flagv_realloc
;
184 if( SIZE_MAX
/ sizeof (*optv
) >= (size_t) (p_child
->i_options
+ optc
) )
185 optv_realloc
= realloc( p_child
->ppsz_options
,
186 (p_child
->i_options
+ optc
) * sizeof (*optv
) );
187 if( likely(optv_realloc
) )
189 p_child
->ppsz_options
= optv_realloc
;
190 memcpy( p_child
->ppsz_options
+ p_child
->i_options
, optv
,
191 optc
* sizeof (*optv
) );
192 memcpy( p_child
->optflagv
+ p_child
->i_options
, flagv
,
193 optc
* sizeof (*flagv
) );
194 p_child
->i_options
+= optc
;
195 p_child
->optflagc
+= optc
;
199 vlc_mutex_unlock( &p_child
->lock
);
202 if( unlikely(!flagv_realloc
|| !optv_realloc
) )
204 /* Didn't copy pointers, so need to free the strdup() */
205 for( int i
=0; i
<optc
; i
++ )
213 bool input_item_HasErrorWhenReading( input_item_t
*p_item
)
215 vlc_mutex_lock( &p_item
->lock
);
217 bool b_error
= p_item
->b_error_when_reading
;
219 vlc_mutex_unlock( &p_item
->lock
);
224 bool input_item_MetaMatch( input_item_t
*p_i
,
225 vlc_meta_type_t meta_type
, const char *psz
)
227 vlc_mutex_lock( &p_i
->lock
);
229 const char *psz_meta
= vlc_meta_Get( p_i
->p_meta
, meta_type
);
230 bool b_ret
= psz_meta
&& strcasestr( psz_meta
, psz
);
232 vlc_mutex_unlock( &p_i
->lock
);
237 const char *input_item_GetMetaLocked(input_item_t
*item
,
238 vlc_meta_type_t meta_type
)
240 vlc_mutex_assert(&item
->lock
);
242 return vlc_meta_Get(item
->p_meta
, meta_type
);
245 char *input_item_GetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
)
247 vlc_mutex_lock( &p_i
->lock
);
248 const char *value
= input_item_GetMetaLocked( p_i
, meta_type
);
249 char *psz
= value
? strdup( value
) : NULL
;
250 vlc_mutex_unlock( &p_i
->lock
);
254 /* Get the title of a given item or fallback to the name if the title is empty */
255 char *input_item_GetTitleFbName( input_item_t
*p_item
)
258 vlc_mutex_lock( &p_item
->lock
);
260 const char *psz_title
= vlc_meta_Get( p_item
->p_meta
, vlc_meta_Title
);
261 if( !EMPTY_STR( psz_title
) )
262 psz_ret
= strdup( psz_title
);
264 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
266 vlc_mutex_unlock( &p_item
->lock
);
270 char *input_item_GetName( input_item_t
*p_item
)
272 vlc_mutex_lock( &p_item
->lock
);
274 char *psz_name
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
276 vlc_mutex_unlock( &p_item
->lock
);
279 void input_item_SetName( input_item_t
*p_item
, const char *psz_name
)
281 vlc_mutex_lock( &p_item
->lock
);
283 free( p_item
->psz_name
);
284 p_item
->psz_name
= strdup( psz_name
);
286 vlc_mutex_unlock( &p_item
->lock
);
289 char *input_item_GetURI( input_item_t
*p_i
)
291 vlc_mutex_lock( &p_i
->lock
);
293 char *psz_s
= p_i
->psz_uri
? strdup( p_i
->psz_uri
) : NULL
;
295 vlc_mutex_unlock( &p_i
->lock
);
299 void input_item_SetURI( input_item_t
*p_i
, const char *psz_uri
)
303 if( !strstr( psz_uri
, "://" )
304 || strchr( psz_uri
, ' ' ) || strchr( psz_uri
, '"' ) )
305 fprintf( stderr
, "Warning: %s(\"%s\"): file path instead of URL.\n",
308 vlc_mutex_lock( &p_i
->lock
);
309 free( p_i
->psz_uri
);
310 p_i
->psz_uri
= strdup( psz_uri
);
312 p_i
->i_type
= GuessType( p_i
, &p_i
->b_net
);
317 if( p_i
->i_type
== ITEM_TYPE_FILE
|| p_i
->i_type
== ITEM_TYPE_DIRECTORY
)
319 const char *psz_filename
= strrchr( p_i
->psz_uri
, '/' );
321 if( psz_filename
&& *psz_filename
== '/' )
323 if( psz_filename
&& *psz_filename
)
324 p_i
->psz_name
= strdup( psz_filename
);
326 /* Make the name more readable */
329 vlc_uri_decode( p_i
->psz_name
);
330 EnsureUTF8( p_i
->psz_name
);
334 { /* Strip login and password from title */
338 vlc_UrlParse( &url
, psz_uri
);
339 if( url
.psz_protocol
)
342 r
=asprintf( &p_i
->psz_name
, "%s://%s:%u%s", url
.psz_protocol
,
343 url
.psz_host
, url
.i_port
,
344 url
.psz_path
? url
.psz_path
: "" );
346 r
=asprintf( &p_i
->psz_name
, "%s://%s%s", url
.psz_protocol
,
347 url
.psz_host
? url
.psz_host
: "",
348 url
.psz_path
? url
.psz_path
: "" );
353 r
=asprintf( &p_i
->psz_name
, "%s:%u%s", url
.psz_host
, url
.i_port
,
354 url
.psz_path
? url
.psz_path
: "" );
356 r
=asprintf( &p_i
->psz_name
, "%s%s", url
.psz_host
,
357 url
.psz_path
? url
.psz_path
: "" );
359 vlc_UrlClean( &url
);
361 p_i
->psz_name
=NULL
; /* recover from undefined value */
364 vlc_mutex_unlock( &p_i
->lock
);
367 vlc_tick_t
input_item_GetDuration( input_item_t
*p_i
)
369 vlc_mutex_lock( &p_i
->lock
);
371 vlc_tick_t i_duration
= p_i
->i_duration
;
373 vlc_mutex_unlock( &p_i
->lock
);
374 if (i_duration
== INPUT_DURATION_INDEFINITE
)
376 else if (i_duration
== INPUT_DURATION_UNSET
)
381 void input_item_SetDuration( input_item_t
*p_i
, vlc_tick_t i_duration
)
383 bool b_send_event
= false;
385 vlc_mutex_lock( &p_i
->lock
);
386 if( p_i
->i_duration
!= i_duration
)
388 p_i
->i_duration
= i_duration
;
391 vlc_mutex_unlock( &p_i
->lock
);
395 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
396 .type
= vlc_InputItemDurationChanged
,
397 .u
.input_item_duration_changed
.new_duration
= i_duration
} );
401 char *input_item_GetNowPlayingFb( input_item_t
*p_item
)
403 char *psz_meta
= input_item_GetMeta( p_item
, vlc_meta_NowPlaying
);
404 if( !psz_meta
|| strlen( psz_meta
) == 0 )
407 return input_item_GetMeta( p_item
, vlc_meta_ESNowPlaying
);
413 bool input_item_IsPreparsed( input_item_t
*p_item
)
415 vlc_mutex_lock( &p_item
->lock
);
416 bool b_preparsed
= vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_PREPARSED
;
417 vlc_mutex_unlock( &p_item
->lock
);
422 bool input_item_IsArtFetched( input_item_t
*p_item
)
424 vlc_mutex_lock( &p_item
->lock
);
425 bool b_fetched
= vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_ART_FETCHED
;
426 vlc_mutex_unlock( &p_item
->lock
);
431 bool input_item_ShouldPreparseSubItems( input_item_t
*p_item
)
435 vlc_mutex_lock( &p_item
->lock
);
436 b_ret
= p_item
->i_preparse_depth
== -1 ? true : p_item
->i_preparse_depth
> 0;
437 vlc_mutex_unlock( &p_item
->lock
);
442 input_item_t
*input_item_Hold( input_item_t
*p_item
)
444 input_item_owner_t
*owner
= item_owner(p_item
);
446 vlc_atomic_rc_inc( &owner
->rc
);
450 void input_item_Release( input_item_t
*p_item
)
452 input_item_owner_t
*owner
= item_owner(p_item
);
454 if( !vlc_atomic_rc_dec( &owner
->rc
) )
457 vlc_event_manager_fini( &p_item
->event_manager
);
459 free( p_item
->psz_name
);
460 free( p_item
->psz_uri
);
461 free( p_item
->p_stats
);
462 vlc_meta_Delete( p_item
->p_meta
);
464 for( input_item_opaque_t
*o
= p_item
->opaques
, *next
; o
!= NULL
; o
= next
)
470 for( int i
= 0; i
< p_item
->i_options
; i
++ )
471 free( p_item
->ppsz_options
[i
] );
472 TAB_CLEAN( p_item
->i_options
, p_item
->ppsz_options
);
473 free( p_item
->optflagv
);
475 for( int i
= 0; i
< p_item
->i_es
; i
++ )
477 es_format_Clean( p_item
->es
[i
] );
478 free( p_item
->es
[i
] );
480 TAB_CLEAN( p_item
->i_es
, p_item
->es
);
482 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
483 vlc_epg_Delete( p_item
->pp_epg
[i
] );
484 TAB_CLEAN( p_item
->i_epg
, p_item
->pp_epg
);
486 for( int i
= 0; i
< p_item
->i_categories
; i
++ )
487 info_category_Delete( p_item
->pp_categories
[i
] );
488 TAB_CLEAN( p_item
->i_categories
, p_item
->pp_categories
);
490 for( int i
= 0; i
< p_item
->i_slaves
; i
++ )
491 input_item_slave_Delete( p_item
->pp_slaves
[i
] );
492 TAB_CLEAN( p_item
->i_slaves
, p_item
->pp_slaves
);
497 int input_item_AddOption( input_item_t
*p_input
, const char *psz_option
,
500 int err
= VLC_SUCCESS
;
502 if( psz_option
== NULL
)
505 vlc_mutex_lock( &p_input
->lock
);
506 if (flags
& VLC_INPUT_OPTION_UNIQUE
)
508 for (int i
= 0 ; i
< p_input
->i_options
; i
++)
509 if( !strcmp( p_input
->ppsz_options
[i
], psz_option
) )
513 uint8_t *flagv
= realloc (p_input
->optflagv
, p_input
->optflagc
+ 1);
520 p_input
->optflagv
= flagv
;
522 char* psz_option_dup
= strdup( psz_option
);
523 if( unlikely( !psz_option_dup
) )
529 TAB_APPEND(p_input
->i_options
, p_input
->ppsz_options
, psz_option_dup
);
531 flagv
[p_input
->optflagc
++] = flags
;
534 vlc_mutex_unlock( &p_input
->lock
);
538 int input_item_AddOptions( input_item_t
*p_item
, int i_options
,
539 const char *const *ppsz_options
,
542 int i_ret
= VLC_SUCCESS
;
543 for( int i
= 0; i
< i_options
&& i_ret
== VLC_SUCCESS
; i
++ )
544 i_ret
= input_item_AddOption( p_item
, ppsz_options
[i
], i_flags
);
548 int input_item_AddOpaque(input_item_t
*item
, const char *name
, void *value
)
550 assert(name
!= NULL
);
552 size_t namelen
= strlen(name
);
553 input_item_opaque_t
*entry
= malloc(sizeof (*entry
) + namelen
);
554 if (unlikely(entry
== NULL
))
557 memcpy(entry
->name
, name
, namelen
+ 1);
558 entry
->value
= value
;
560 vlc_mutex_lock(&item
->lock
);
561 entry
->next
= item
->opaques
;
562 item
->opaques
= entry
;
563 vlc_mutex_unlock(&item
->lock
);
567 void input_item_ApplyOptions(vlc_object_t
*obj
, input_item_t
*item
)
569 vlc_mutex_lock(&item
->lock
);
570 assert(item
->optflagc
== (unsigned)item
->i_options
);
572 for (unsigned i
= 0; i
< (unsigned)item
->i_options
; i
++)
573 var_OptionParse(obj
, item
->ppsz_options
[i
],
574 !!(item
->optflagv
[i
] & VLC_INPUT_OPTION_TRUSTED
));
576 for (const input_item_opaque_t
*o
= item
->opaques
; o
!= NULL
; o
= o
->next
)
578 var_Create(obj
, o
->name
, VLC_VAR_ADDRESS
);
579 var_SetAddress(obj
, o
->name
, o
->value
);
582 vlc_mutex_unlock(&item
->lock
);
585 static int bsearch_strcmp_cb(const void *a
, const void *b
)
587 const char *const *entry
= b
;
588 return strcasecmp(a
, *entry
);
591 static bool input_item_IsMaster(const char *psz_filename
)
593 static const char *const ppsz_master_exts
[] = { MASTER_EXTENSIONS
};
595 const char *psz_ext
= strrchr(psz_filename
, '.');
596 if (psz_ext
== NULL
|| *(++psz_ext
) == '\0')
599 return bsearch(psz_ext
, ppsz_master_exts
, ARRAY_SIZE(ppsz_master_exts
),
600 sizeof(const char *), bsearch_strcmp_cb
) != NULL
;
603 bool input_item_slave_GetType(const char *psz_filename
,
604 enum slave_type
*p_slave_type
)
606 static const char *const ppsz_sub_exts
[] = { SLAVE_SPU_EXTENSIONS
};
607 static const char *const ppsz_audio_exts
[] = { SLAVE_AUDIO_EXTENSIONS
};
610 enum slave_type i_type
;
611 const char *const *ppsz_exts
;
614 { SLAVE_TYPE_SPU
, ppsz_sub_exts
, ARRAY_SIZE(ppsz_sub_exts
) },
615 { SLAVE_TYPE_AUDIO
, ppsz_audio_exts
, ARRAY_SIZE(ppsz_audio_exts
) },
618 const char *psz_ext
= strrchr(psz_filename
, '.');
619 if (psz_ext
== NULL
|| *(++psz_ext
) == '\0')
622 for (unsigned int i
= 0; i
< sizeof(p_slave_list
) / sizeof(*p_slave_list
); ++i
)
624 if (bsearch(psz_ext
, p_slave_list
[i
].ppsz_exts
, p_slave_list
[i
].nmemb
,
625 sizeof(const char *), bsearch_strcmp_cb
))
627 *p_slave_type
= p_slave_list
[i
].i_type
;
634 input_item_slave_t
*input_item_slave_New(const char *psz_uri
, enum slave_type i_type
,
635 enum slave_priority i_priority
)
640 input_item_slave_t
*p_slave
= malloc( sizeof( *p_slave
) + strlen( psz_uri
) + 1 );
644 p_slave
->i_type
= i_type
;
645 p_slave
->i_priority
= i_priority
;
646 p_slave
->b_forced
= false;
647 strcpy( p_slave
->psz_uri
, psz_uri
);
652 int input_item_AddSlave(input_item_t
*p_item
, input_item_slave_t
*p_slave
)
654 if( p_item
== NULL
|| p_slave
== NULL
655 || p_slave
->i_priority
< SLAVE_PRIORITY_MATCH_NONE
)
658 vlc_mutex_lock( &p_item
->lock
);
660 TAB_APPEND(p_item
->i_slaves
, p_item
->pp_slaves
, p_slave
);
662 vlc_mutex_unlock( &p_item
->lock
);
666 static info_category_t
*InputItemFindCat( input_item_t
*p_item
,
667 int *pi_index
, const char *psz_cat
)
669 vlc_mutex_assert( &p_item
->lock
);
670 for( int i
= 0; i
< p_item
->i_categories
&& psz_cat
; i
++ )
672 info_category_t
*p_cat
= p_item
->pp_categories
[i
];
674 if( !strcmp( p_cat
->psz_name
, psz_cat
) )
685 * Get a info item from a given category in a given input item.
687 * \param p_i The input item to get info from
688 * \param psz_cat String representing the category for the info
689 * \param psz_name String representing the name of the desired info
690 * \return A pointer to the string with the given info if found, or an
691 * empty string otherwise. The caller should free the returned
694 char *input_item_GetInfo( input_item_t
*p_i
,
696 const char *psz_name
)
698 vlc_mutex_lock( &p_i
->lock
);
700 const info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
703 info_t
*p_info
= info_category_FindInfo( p_cat
, psz_name
);
704 if( p_info
&& p_info
->psz_value
)
706 char *psz_ret
= strdup( p_info
->psz_value
);
707 vlc_mutex_unlock( &p_i
->lock
);
711 vlc_mutex_unlock( &p_i
->lock
);
715 static int InputItemVaAddInfo( input_item_t
*p_i
,
717 const char *psz_name
,
718 const char *psz_format
, va_list args
)
720 vlc_mutex_assert( &p_i
->lock
);
722 info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
725 p_cat
= info_category_New( psz_cat
);
728 TAB_APPEND(p_i
->i_categories
, p_i
->pp_categories
, p_cat
);
730 info_t
*p_info
= info_category_VaAddInfo( p_cat
, psz_name
, psz_format
, args
);
731 if( !p_info
|| !p_info
->psz_value
)
736 int input_item_AddInfo( input_item_t
*p_i
,
738 const char *psz_name
,
739 const char *psz_format
, ... )
743 vlc_mutex_lock( &p_i
->lock
);
745 va_start( args
, psz_format
);
746 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
749 vlc_mutex_unlock( &p_i
->lock
);
753 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
754 .type
= vlc_InputItemInfoChanged
} );
759 int input_item_DelInfo( input_item_t
*p_i
,
761 const char *psz_name
)
763 vlc_mutex_lock( &p_i
->lock
);
765 info_category_t
*p_cat
= InputItemFindCat( p_i
, &i_cat
, psz_cat
);
768 vlc_mutex_unlock( &p_i
->lock
);
774 /* Remove a specific info */
775 int i_ret
= info_category_DeleteInfo( p_cat
, psz_name
);
778 vlc_mutex_unlock( &p_i
->lock
);
784 /* Remove the complete categorie */
785 info_category_Delete( p_cat
);
786 TAB_ERASE(p_i
->i_categories
, p_i
->pp_categories
, i_cat
);
788 vlc_mutex_unlock( &p_i
->lock
);
790 vlc_event_send( &p_i
->event_manager
,
791 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
795 void input_item_ReplaceInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
797 vlc_mutex_lock( &p_item
->lock
);
799 info_category_t
*p_old
= InputItemFindCat( p_item
, &i_cat
, p_cat
->psz_name
);
802 info_category_Delete( p_old
);
803 p_item
->pp_categories
[i_cat
] = p_cat
;
806 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
807 vlc_mutex_unlock( &p_item
->lock
);
809 vlc_event_send( &p_item
->event_manager
,
810 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
813 void input_item_MergeInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
815 vlc_mutex_lock( &p_item
->lock
);
816 info_category_t
*p_old
= InputItemFindCat( p_item
, NULL
, p_cat
->psz_name
);
821 info_foreach(info
, &p_cat
->infos
)
822 info_category_ReplaceInfo( p_old
, info
);
823 vlc_list_init( &p_cat
->infos
);
824 info_category_Delete( p_cat
);
827 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
828 vlc_mutex_unlock( &p_item
->lock
);
830 vlc_event_send( &p_item
->event_manager
,
831 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
834 void input_item_SetEpgEvent( input_item_t
*p_item
, const vlc_epg_event_t
*p_epg_evt
)
836 bool b_changed
= false;
837 vlc_mutex_lock( &p_item
->lock
);
839 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
841 vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
842 for( size_t j
= 0; j
< p_epg
->i_event
; j
++ )
844 /* Same event can exist in more than one table */
845 if( p_epg
->pp_event
[j
]->i_id
== p_epg_evt
->i_id
)
847 vlc_epg_event_t
*p_dup
= vlc_epg_event_Duplicate( p_epg_evt
);
850 if( p_epg
->p_current
== p_epg
->pp_event
[j
] )
851 p_epg
->p_current
= p_dup
;
852 vlc_epg_event_Delete( p_epg
->pp_event
[j
] );
853 p_epg
->pp_event
[j
] = p_dup
;
860 vlc_mutex_unlock( &p_item
->lock
);
864 vlc_event_send( &p_item
->event_manager
,
865 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
871 static int InputItemAddInfo( input_item_t
*p_i
,
873 const char *psz_name
,
874 const char *psz_format
, ... )
878 va_start( args
, psz_format
);
879 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
886 void input_item_SetEpg( input_item_t
*p_item
, const vlc_epg_t
*p_update
, bool b_current_source
)
888 vlc_epg_t
*p_epg
= vlc_epg_Duplicate( p_update
);
892 vlc_mutex_lock( &p_item
->lock
);
895 vlc_epg_t
**pp_epg
= NULL
;
896 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
898 if( p_item
->pp_epg
[i
]->i_source_id
== p_update
->i_source_id
&&
899 p_item
->pp_epg
[i
]->i_id
== p_update
->i_id
)
901 pp_epg
= &p_item
->pp_epg
[i
];
906 /* replace with new version */
909 vlc_epg_Delete( *pp_epg
);
910 if( *pp_epg
== p_item
->p_epg_table
) /* current table can have changed */
911 p_item
->p_epg_table
= NULL
;
916 TAB_APPEND( p_item
->i_epg
, p_item
->pp_epg
, p_epg
);
919 if( b_current_source
&& p_epg
->b_present
)
920 p_item
->p_epg_table
= p_epg
;
922 vlc_mutex_unlock( &p_item
->lock
);
926 if( asprintf( &psz_epg
, "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
929 input_item_DelInfo( p_item
, psz_epg
, NULL
);
931 vlc_mutex_lock( &p_item
->lock
);
932 for( size_t i
= 0; i
< p_epg
->i_event
; i
++ )
934 const vlc_epg_event_t
*p_evt
= p_epg
->pp_event
[i
];
935 time_t t_start
= (time_t)p_evt
->i_start
;
939 localtime_r( &t_start
, &tm_start
);
941 snprintf( psz_start
, sizeof(psz_start
), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
942 1900 + tm_start
.tm_year
, 1 + tm_start
.tm_mon
, tm_start
.tm_mday
,
943 tm_start
.tm_hour
, tm_start
.tm_min
, tm_start
.tm_sec
);
944 if( p_evt
->psz_short_description
|| p_evt
->psz_description
)
945 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d) - %s %s",
947 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60,
948 p_evt
->psz_short_description
? p_evt
->psz_short_description
: "" ,
949 p_evt
->psz_description
? p_evt
->psz_description
: "" );
951 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d)",
953 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60 );
955 vlc_mutex_unlock( &p_item
->lock
);
959 vlc_event_send( &p_item
->event_manager
,
960 &(vlc_event_t
){ .type
= vlc_InputItemInfoChanged
, } );
963 void input_item_ChangeEPGSource( input_item_t
*p_item
, int i_source_id
)
965 vlc_mutex_lock( &p_item
->lock
);
966 p_item
->p_epg_table
= NULL
;
967 if( i_source_id
> 0 )
969 /* Update pointer to current/next table in the full schedule */
970 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
972 if( p_item
->pp_epg
[i
]->i_source_id
== i_source_id
&&
973 p_item
->pp_epg
[i
]->b_present
)
975 p_item
->p_epg_table
= p_item
->pp_epg
[i
];
980 vlc_mutex_unlock( &p_item
->lock
);
983 void input_item_SetEpgTime( input_item_t
*p_item
, int64_t i_time
)
985 vlc_mutex_lock( &p_item
->lock
);
986 p_item
->i_epg_time
= i_time
;
987 vlc_mutex_unlock( &p_item
->lock
);
990 void input_item_SetEpgOffline( input_item_t
*p_item
)
992 input_item_ChangeEPGSource( p_item
, -1 );
995 vlc_mutex_lock( &p_item
->lock
);
996 const int i_epg_info
= p_item
->i_epg
;
999 char *ppsz_epg_info
[i_epg_info
];
1000 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
1002 const vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
1003 if( asprintf( &ppsz_epg_info
[i
], "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
1004 ppsz_epg_info
[i
] = NULL
;
1006 vlc_mutex_unlock( &p_item
->lock
);
1008 for( int i
= 0; i
< i_epg_info
; i
++ )
1010 if( !ppsz_epg_info
[i
] )
1012 input_item_DelInfo( p_item
, ppsz_epg_info
[i
], NULL
);
1013 free( ppsz_epg_info
[i
] );
1017 vlc_mutex_unlock( &p_item
->lock
);
1020 vlc_event_send( &p_item
->event_manager
,
1021 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
1025 input_item_NewExt( const char *psz_uri
, const char *psz_name
,
1026 vlc_tick_t duration
, enum input_item_type_e type
, enum input_item_net_type i_net
)
1028 input_item_owner_t
*owner
= calloc( 1, sizeof( *owner
) );
1029 if( unlikely(owner
== NULL
) )
1032 vlc_atomic_rc_init( &owner
->rc
);
1034 input_item_t
*p_input
= &owner
->item
;
1035 vlc_event_manager_t
* p_em
= &p_input
->event_manager
;
1037 p_input
->p_meta
= vlc_meta_New();
1038 if( unlikely(p_input
->p_meta
== NULL
) )
1044 vlc_mutex_init( &p_input
->lock
);
1046 p_input
->psz_name
= NULL
;
1048 input_item_SetName( p_input
, psz_name
);
1050 p_input
->psz_uri
= NULL
;
1052 input_item_SetURI( p_input
, psz_uri
);
1055 p_input
->i_type
= ITEM_TYPE_UNKNOWN
;
1056 p_input
->b_net
= false;
1059 TAB_INIT( p_input
->i_options
, p_input
->ppsz_options
);
1060 p_input
->optflagc
= 0;
1061 p_input
->optflagv
= NULL
;
1062 p_input
->opaques
= NULL
;
1064 p_input
->i_duration
= duration
;
1065 TAB_INIT( p_input
->i_categories
, p_input
->pp_categories
);
1066 TAB_INIT( p_input
->i_es
, p_input
->es
);
1067 p_input
->p_stats
= NULL
;
1068 TAB_INIT( p_input
->i_epg
, p_input
->pp_epg
);
1069 TAB_INIT( p_input
->i_slaves
, p_input
->pp_slaves
);
1071 vlc_event_manager_init( p_em
, p_input
);
1073 if( type
!= ITEM_TYPE_UNKNOWN
)
1074 p_input
->i_type
= type
;
1075 p_input
->b_error_when_reading
= false;
1077 if( i_net
!= ITEM_NET_UNKNOWN
)
1078 p_input
->b_net
= i_net
== ITEM_NET
;
1082 input_item_t
*input_item_Copy( input_item_t
*p_input
)
1086 vlc_mutex_lock( &p_input
->lock
);
1088 item
= input_item_NewExt( p_input
->psz_uri
, p_input
->psz_name
,
1089 p_input
->i_duration
, p_input
->i_type
,
1091 if( unlikely(item
== NULL
) )
1093 vlc_mutex_unlock( &p_input
->lock
);
1097 vlc_meta_Merge( item
->p_meta
, p_input
->p_meta
);
1098 item
->b_net
= p_input
->b_net
;
1100 if( p_input
->i_slaves
> 0 )
1102 for( int i
= 0; i
< p_input
->i_slaves
; i
++ )
1104 input_item_slave_t
* slave
= input_item_slave_New(
1105 p_input
->pp_slaves
[i
]->psz_uri
,
1106 p_input
->pp_slaves
[i
]->i_type
,
1107 p_input
->pp_slaves
[i
]->i_priority
);
1108 if( unlikely(slave
!= NULL
) )
1110 TAB_APPEND(item
->i_slaves
, item
->pp_slaves
, slave
);
1115 vlc_mutex_unlock( &p_input
->lock
);
1117 /* No need to lock; no other thread has seen this new item yet. */
1118 input_item_CopyOptions( item
, p_input
);
1122 struct item_type_entry
1124 const char *psz_scheme
;
1125 enum input_item_type_e i_type
;
1129 static int typecmp( const void *key
, const void *entry
)
1131 const struct item_type_entry
*type
= entry
;
1132 const char *uri
= key
, *scheme
= type
->psz_scheme
;
1134 return strncmp( uri
, scheme
, strlen( scheme
) );
1137 /* Guess the type of the item using the beginning of the mrl */
1138 static enum input_item_type_e
GuessType( const input_item_t
*p_item
, bool *p_net
)
1140 static const struct item_type_entry tab
[] =
1141 { /* /!\ Alphabetical order /!\ */
1142 /* Short match work, not just exact match */
1143 { "alsa", ITEM_TYPE_CARD
, false },
1144 { "atsc", ITEM_TYPE_CARD
, false },
1145 { "bd", ITEM_TYPE_DISC
, false },
1146 { "bluray", ITEM_TYPE_DISC
, false },
1147 { "cable", ITEM_TYPE_CARD
, false },
1148 { "cdda", ITEM_TYPE_DISC
, false },
1149 { "cqam", ITEM_TYPE_CARD
, false },
1150 { "dc1394", ITEM_TYPE_CARD
, false },
1151 { "dccp", ITEM_TYPE_STREAM
, true },
1152 { "deckli", ITEM_TYPE_CARD
, false }, /* decklink */
1153 { "dir", ITEM_TYPE_DIRECTORY
, false },
1154 { "dshow", ITEM_TYPE_CARD
, false },
1155 { "dtv", ITEM_TYPE_CARD
, false },
1156 { "dvb", ITEM_TYPE_CARD
, false },
1157 { "dvd", ITEM_TYPE_DISC
, false },
1158 { "eyetv", ITEM_TYPE_CARD
, false },
1159 { "fd", ITEM_TYPE_UNKNOWN
, false },
1160 { "file", ITEM_TYPE_FILE
, false },
1161 { "ftp", ITEM_TYPE_FILE
, true },
1162 { "gopher", ITEM_TYPE_STREAM
, true },
1163 { "http", ITEM_TYPE_FILE
, true },
1164 { "icyx", ITEM_TYPE_STREAM
, true },
1165 { "imem", ITEM_TYPE_UNKNOWN
, false },
1166 { "isdb-", ITEM_TYPE_CARD
, false },
1167 { "itpc", ITEM_TYPE_PLAYLIST
, true },
1168 { "jack", ITEM_TYPE_CARD
, false },
1169 { "linsys", ITEM_TYPE_CARD
, false },
1170 { "live", ITEM_TYPE_STREAM
, true }, /* livedotcom */
1171 { "mms", ITEM_TYPE_STREAM
, true },
1172 { "mtp", ITEM_TYPE_DISC
, false },
1173 { "nfs", ITEM_TYPE_FILE
, true },
1174 { "ofdm", ITEM_TYPE_CARD
, false },
1175 { "oss", ITEM_TYPE_CARD
, false },
1176 { "pnm", ITEM_TYPE_STREAM
, true },
1177 { "pulse", ITEM_TYPE_CARD
, false },
1178 { "qam", ITEM_TYPE_CARD
, false },
1179 { "qpsk", ITEM_TYPE_CARD
, false },
1180 { "qtcapt", ITEM_TYPE_CARD
, false }, /* qtcapture */
1181 { "qtsound",ITEM_TYPE_CARD
, false },
1182 { "raw139", ITEM_TYPE_CARD
, false }, /* raw1394 */
1183 { "rt", ITEM_TYPE_STREAM
, true }, /* rtp, rtsp, rtmp */
1184 { "satell", ITEM_TYPE_CARD
, false }, /* satellite */
1185 { "satip", ITEM_TYPE_STREAM
, true }, /* satellite over ip */
1186 { "screen", ITEM_TYPE_CARD
, false },
1187 { "sdp", ITEM_TYPE_STREAM
, true },
1188 { "sftp", ITEM_TYPE_FILE
, true },
1189 { "shm", ITEM_TYPE_CARD
, false },
1190 { "smb", ITEM_TYPE_FILE
, true },
1191 { "stream", ITEM_TYPE_STREAM
, false },
1192 { "svcd", ITEM_TYPE_DISC
, false },
1193 { "tcp", ITEM_TYPE_STREAM
, true },
1194 { "terres", ITEM_TYPE_CARD
, false }, /* terrestrial */
1195 { "udp", ITEM_TYPE_STREAM
, true }, /* udplite too */
1196 { "unsv", ITEM_TYPE_STREAM
, true },
1197 { "upnp", ITEM_TYPE_FILE
, true },
1198 { "usdigi", ITEM_TYPE_CARD
, false }, /* usdigital */
1199 { "v4l", ITEM_TYPE_CARD
, false },
1200 { "vcd", ITEM_TYPE_DISC
, false },
1201 { "vdr", ITEM_TYPE_STREAM
, true },
1202 { "wasapi", ITEM_TYPE_CARD
, false },
1203 { "window", ITEM_TYPE_CARD
, false },
1207 for( size_t i
= 1; i
< ARRAY_SIZE( tab
); i
++ )
1208 assert( typecmp( (tab
+ i
)->psz_scheme
, tab
+ i
- 1 ) > 0 );
1213 if( strstr( p_item
->psz_uri
, "://" ) == NULL
)
1214 return ITEM_TYPE_UNKNOWN
; /* invalid URI */
1216 const struct item_type_entry
*e
=
1217 bsearch( p_item
->psz_uri
, tab
, ARRAY_SIZE( tab
),
1218 sizeof( tab
[0] ), typecmp
);
1220 return ITEM_TYPE_UNKNOWN
;
1226 input_item_node_t
*input_item_node_Create( input_item_t
*p_input
)
1228 input_item_node_t
* p_node
= malloc( sizeof( input_item_node_t
) );
1234 p_node
->p_item
= p_input
;
1235 input_item_Hold( p_input
);
1237 p_node
->i_children
= 0;
1238 p_node
->pp_children
= NULL
;
1243 void input_item_node_Delete( input_item_node_t
*p_node
)
1245 for( int i
= 0; i
< p_node
->i_children
; i
++ )
1246 input_item_node_Delete( p_node
->pp_children
[i
] );
1248 input_item_Release( p_node
->p_item
);
1249 free( p_node
->pp_children
);
1253 input_item_node_t
*input_item_node_AppendItem( input_item_node_t
*p_node
, input_item_t
*p_item
)
1255 int i_preparse_depth
;
1256 input_item_node_t
*p_new_child
= input_item_node_Create( p_item
);
1257 if( !p_new_child
) return NULL
;
1259 vlc_mutex_lock( &p_node
->p_item
->lock
);
1260 i_preparse_depth
= p_node
->p_item
->i_preparse_depth
;
1261 vlc_mutex_unlock( &p_node
->p_item
->lock
);
1263 vlc_mutex_lock( &p_item
->lock
);
1264 p_item
->i_preparse_depth
= i_preparse_depth
> 0 ?
1265 i_preparse_depth
-1 :
1267 vlc_mutex_unlock( &p_item
->lock
);
1269 input_item_node_AppendNode( p_node
, p_new_child
);
1273 void input_item_node_AppendNode( input_item_node_t
*p_parent
,
1274 input_item_node_t
*p_child
)
1276 assert(p_parent
!= NULL
);
1277 assert(p_child
!= NULL
);
1278 TAB_APPEND(p_parent
->i_children
, p_parent
->pp_children
, p_child
);
1281 void input_item_node_RemoveNode( input_item_node_t
*parent
,
1282 input_item_node_t
*child
)
1284 TAB_REMOVE(parent
->i_children
, parent
->pp_children
, child
);
1287 /* Called by es_out when a new Elementary Stream is added or updated. */
1288 void input_item_UpdateTracksInfo(input_item_t
*item
, const es_format_t
*fmt
)
1291 es_format_t
*fmt_copy
= malloc(sizeof *fmt_copy
);
1295 es_format_Copy(fmt_copy
, fmt
);
1297 vlc_mutex_lock( &item
->lock
);
1299 for( i
= 0; i
< item
->i_es
; i
++ )
1301 if (item
->es
[i
]->i_id
!= fmt
->i_id
)
1304 /* We've found the right ES, replace it */
1305 es_format_Clean(item
->es
[i
]);
1307 item
->es
[i
] = fmt_copy
;
1308 vlc_mutex_unlock( &item
->lock
);
1312 /* ES not found, insert it */
1313 TAB_APPEND(item
->i_es
, item
->es
, fmt_copy
);
1314 vlc_mutex_unlock( &item
->lock
);
1317 char *input_item_CreateFilename(input_item_t
*item
,
1318 const char *dir
, const char *filenamefmt
,
1322 char *filename
= str_format(NULL
, item
, filenamefmt
);
1323 if (unlikely(filename
== NULL
))
1326 filename_sanitize(filename
);
1329 ? asprintf(&path
, "%s"DIR_SEP
"%s.%s", dir
, filename
, ext
)
1330 : asprintf(&path
, "%s"DIR_SEP
"%s", dir
, filename
)) < 0)
1337 struct input_item_parser_id_t
1339 input_thread_t
*input
;
1340 input_state_e state
;
1341 const input_item_parser_cbs_t
*cbs
;
1346 input_item_parser_InputEvent(input_thread_t
*input
,
1347 const struct vlc_input_event
*event
, void *parser_
)
1349 input_item_parser_id_t
*parser
= parser_
;
1351 switch (event
->type
)
1353 case INPUT_EVENT_TIMES
:
1354 input_item_SetDuration(input_GetItem(input
), event
->times
.length
);
1356 case INPUT_EVENT_STATE
:
1357 parser
->state
= event
->state
.value
;
1359 case INPUT_EVENT_DEAD
:
1361 int status
= parser
->state
== END_S
? VLC_SUCCESS
: VLC_EGENERIC
;
1362 parser
->cbs
->on_ended(input_GetItem(input
), status
, parser
->userdata
);
1365 case INPUT_EVENT_SUBITEMS
:
1366 if (parser
->cbs
->on_subtree_added
)
1367 parser
->cbs
->on_subtree_added(input_GetItem(input
),
1368 event
->subitems
, parser
->userdata
);
1375 input_item_parser_id_t
*
1376 input_item_Parse(input_item_t
*item
, vlc_object_t
*obj
,
1377 const input_item_parser_cbs_t
*cbs
, void *userdata
)
1379 assert(cbs
&& cbs
->on_ended
);
1380 input_item_parser_id_t
*parser
= malloc(sizeof(*parser
));
1384 parser
->state
= INIT_S
;
1386 parser
->userdata
= userdata
;
1387 parser
->input
= input_CreatePreparser(obj
, input_item_parser_InputEvent
,
1389 if (!parser
->input
|| input_Start(parser
->input
))
1392 input_Close(parser
->input
);
1400 input_item_parser_id_Interrupt(input_item_parser_id_t
*parser
)
1402 input_Stop(parser
->input
);
1406 input_item_parser_id_Release(input_item_parser_id_t
*parser
)
1408 input_item_parser_id_Interrupt(parser
);
1409 input_Close(parser
->input
);
1413 static int rdh_compar_type(input_item_t
*p1
, input_item_t
*p2
)
1415 if (p1
->i_type
!= p2
->i_type
)
1417 if (p1
->i_type
== ITEM_TYPE_DIRECTORY
)
1419 if (p2
->i_type
== ITEM_TYPE_DIRECTORY
)
1425 static int rdh_compar_filename(const void *a
, const void *b
)
1427 input_item_node_t
*const *na
= a
, *const *nb
= b
;
1428 input_item_t
*ia
= (*na
)->p_item
, *ib
= (*nb
)->p_item
;
1430 int i_ret
= rdh_compar_type(ia
, ib
);
1434 return vlc_filenamecmp(ia
->psz_name
, ib
->psz_name
);
1437 static void rdh_sort(input_item_node_t
*p_node
)
1439 if (p_node
->i_children
<= 0)
1442 /* Sort current node */
1443 qsort(p_node
->pp_children
, p_node
->i_children
,
1444 sizeof(input_item_node_t
*), rdh_compar_filename
);
1446 /* Sort all children */
1447 for (int i
= 0; i
< p_node
->i_children
; i
++)
1448 rdh_sort(p_node
->pp_children
[i
]);
1452 * Does the provided file name has one of the extension provided ?
1454 static bool rdh_file_has_ext(const char *psz_filename
,
1455 const char *psz_ignored_exts
)
1457 if (psz_ignored_exts
== NULL
)
1460 const char *ext
= strrchr(psz_filename
, '.');
1464 size_t extlen
= strlen(++ext
);
1466 for (const char *type
= psz_ignored_exts
, *end
; type
[0]; type
= end
+ 1)
1468 end
= strchr(type
, ',');
1470 end
= type
+ strlen(type
);
1472 if (type
+ extlen
== end
&& !strncasecmp(ext
, type
, extlen
))
1482 static bool rdh_file_is_ignored(struct vlc_readdir_helper
*p_rdh
,
1483 const char *psz_filename
)
1485 return (psz_filename
[0] == '\0'
1486 || strcmp(psz_filename
, ".") == 0
1487 || strcmp(psz_filename
, "..") == 0
1488 || (!p_rdh
->b_show_hiddenfiles
&& psz_filename
[0] == '.')
1489 || rdh_file_has_ext(psz_filename
, p_rdh
->psz_ignored_exts
));
1494 input_item_slave_t
*p_slave
;
1496 input_item_node_t
*p_node
;
1501 input_item_node_t
*p_node
;
1505 static char *rdh_name_from_filename(const char *psz_filename
)
1507 /* remove leading white spaces */
1508 while (*psz_filename
!= '\0' && *psz_filename
== ' ')
1511 char *psz_name
= strdup(psz_filename
);
1515 /* remove extension */
1516 char *psz_ptr
= strrchr(psz_name
, '.');
1517 if (psz_ptr
&& psz_ptr
!= psz_name
)
1520 /* remove trailing white spaces */
1521 int i
= strlen(psz_name
) - 1;
1522 while (psz_name
[i
] == ' ' && i
>= 0)
1523 psz_name
[i
--] = '\0';
1525 /* convert to lower case */
1527 while (*psz_ptr
!= '\0')
1529 *psz_ptr
= tolower(*psz_ptr
);
1536 static uint8_t rdh_get_slave_priority(input_item_t
*p_item
,
1537 input_item_slave_t
*p_slave
,
1538 const char *psz_slave_filename
)
1540 uint8_t i_priority
= SLAVE_PRIORITY_MATCH_NONE
;
1541 char *psz_item_name
= rdh_name_from_filename(p_item
->psz_name
);
1542 char *psz_slave_name
= rdh_name_from_filename(psz_slave_filename
);
1544 if (!psz_item_name
|| !psz_slave_name
)
1547 size_t i_item_len
= strlen(psz_item_name
);
1548 size_t i_slave_len
= strlen(psz_slave_name
);
1550 /* The slave name len should not be twice longer than the item name len. */
1551 if (i_item_len
> i_slave_len
|| i_slave_len
> 2 * i_item_len
)
1554 /* check if the names match exactly */
1555 if (!strcmp(psz_item_name
, psz_slave_name
))
1557 i_priority
= SLAVE_PRIORITY_MATCH_ALL
;
1561 /* "cdg" slaves have to be a full match */
1562 if (p_slave
->i_type
== SLAVE_TYPE_SPU
)
1564 char *psz_ext
= strrchr(psz_slave_name
, '.');
1565 if (psz_ext
!= NULL
&& strcasecmp(++psz_ext
, "cdg") == 0)
1569 /* check if the item name is a substring of the slave name */
1570 const char *psz_sub
= strstr(psz_slave_name
, psz_item_name
);
1574 /* check if the item name was found at the end of the slave name */
1575 if (strlen(psz_sub
+ strlen(psz_item_name
)) == 0)
1577 i_priority
= SLAVE_PRIORITY_MATCH_RIGHT
;
1582 i_priority
= SLAVE_PRIORITY_MATCH_LEFT
;
1588 free(psz_item_name
);
1589 free(psz_slave_name
);
1593 static int rdh_should_match_idx(struct vlc_readdir_helper
*p_rdh
,
1594 struct rdh_slave
*p_rdh_sub
)
1596 char *psz_ext
= strrchr(p_rdh_sub
->psz_filename
, '.');
1601 if (strcasecmp(psz_ext
, "sub") != 0)
1604 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1606 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1608 if (p_rdh_slave
== NULL
|| p_rdh_slave
== p_rdh_sub
)
1611 /* check that priorities match */
1612 if (p_rdh_slave
->p_slave
->i_priority
!=
1613 p_rdh_sub
->p_slave
->i_priority
)
1616 /* check that the filenames without extension match */
1617 if (strncasecmp(p_rdh_sub
->psz_filename
, p_rdh_slave
->psz_filename
,
1618 strlen(p_rdh_sub
->psz_filename
) - 3 ) != 0)
1621 /* check that we have an idx file */
1622 char *psz_ext_idx
= strrchr(p_rdh_slave
->psz_filename
, '.');
1623 if (psz_ext_idx
== NULL
)
1626 if (strcasecmp(psz_ext_idx
, "idx" ) == 0)
1632 static void rdh_attach_slaves(struct vlc_readdir_helper
*p_rdh
,
1633 input_item_node_t
*p_parent_node
)
1635 if (p_rdh
->i_sub_autodetect_fuzzy
== 0)
1638 /* Try to match slaves for each items of the node */
1639 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1641 input_item_node_t
*p_node
= p_parent_node
->pp_children
[i
];
1642 input_item_t
*p_item
= p_node
->p_item
;
1644 enum slave_type unused
;
1645 if (!input_item_IsMaster(p_item
->psz_name
)
1646 || input_item_slave_GetType(p_item
->psz_name
, &unused
))
1647 continue; /* don't match 2 possible slaves between each others */
1649 for (size_t j
= 0; j
< p_rdh
->i_slaves
; j
++)
1651 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[j
];
1653 /* Don't try to match slaves with themselves or slaves already
1654 * attached with the higher priority */
1655 if (p_rdh_slave
->p_node
== p_node
1656 || p_rdh_slave
->p_slave
->i_priority
== SLAVE_PRIORITY_MATCH_ALL
)
1659 uint8_t i_priority
=
1660 rdh_get_slave_priority(p_item
, p_rdh_slave
->p_slave
,
1661 p_rdh_slave
->psz_filename
);
1663 if (i_priority
< p_rdh
->i_sub_autodetect_fuzzy
)
1666 /* Drop the ".sub" slave if a ".idx" slave matches */
1667 if (p_rdh_slave
->p_slave
->i_type
== SLAVE_TYPE_SPU
1668 && rdh_should_match_idx(p_rdh
, p_rdh_slave
))
1671 input_item_slave_t
*p_slave
=
1672 input_item_slave_New(p_rdh_slave
->p_slave
->psz_uri
,
1673 p_rdh_slave
->p_slave
->i_type
,
1675 if (p_slave
== NULL
)
1678 if (input_item_AddSlave(p_item
, p_slave
) != VLC_SUCCESS
)
1680 input_item_slave_Delete(p_slave
);
1684 /* Remove the corresponding node if any: This slave won't be
1685 * added in the parent node */
1686 if (p_rdh_slave
->p_node
!= NULL
)
1688 input_item_node_RemoveNode(p_parent_node
, p_rdh_slave
->p_node
);
1689 input_item_node_Delete(p_rdh_slave
->p_node
);
1690 p_rdh_slave
->p_node
= NULL
;
1693 p_rdh_slave
->p_slave
->i_priority
= i_priority
;
1697 /* Attach all children */
1698 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1699 rdh_attach_slaves(p_rdh
, p_parent_node
->pp_children
[i
]);
1702 static int rdh_unflatten(struct vlc_readdir_helper
*p_rdh
,
1703 input_item_node_t
**pp_node
, const char *psz_path
,
1706 /* Create an input input for each sub folders that is contained in the full
1707 * path. Update pp_node to point to the direct parent of the future item to
1710 assert(psz_path
!= NULL
);
1711 const char *psz_subpaths
= psz_path
;
1713 while ((psz_subpaths
= strchr(psz_subpaths
, '/')))
1715 input_item_node_t
*p_subnode
= NULL
;
1717 /* Check if this sub folder item was already added */
1718 for (size_t i
= 0; i
< p_rdh
->i_dirs
&& p_subnode
== NULL
; i
++)
1720 struct rdh_dir
*rdh_dir
= p_rdh
->pp_dirs
[i
];
1721 if (!strncmp(rdh_dir
->psz_path
, psz_path
, psz_subpaths
- psz_path
))
1722 p_subnode
= rdh_dir
->p_node
;
1725 /* The sub folder item doesn't exist, so create it */
1726 if (p_subnode
== NULL
)
1728 size_t i_sub_path_len
= psz_subpaths
- psz_path
;
1729 struct rdh_dir
*p_rdh_dir
=
1730 malloc(sizeof(struct rdh_dir
) + 1 + i_sub_path_len
);
1731 if (p_rdh_dir
== NULL
)
1733 strncpy(p_rdh_dir
->psz_path
, psz_path
, i_sub_path_len
);
1734 p_rdh_dir
->psz_path
[i_sub_path_len
] = 0;
1736 const char *psz_subpathname
= strrchr(p_rdh_dir
->psz_path
, '/');
1737 if (psz_subpathname
!= NULL
)
1740 psz_subpathname
= p_rdh_dir
->psz_path
;
1742 input_item_t
*p_item
=
1743 input_item_NewExt(INPUT_ITEM_URI_NOP
, psz_subpathname
, INPUT_DURATION_UNSET
,
1744 ITEM_TYPE_DIRECTORY
, i_net
);
1750 input_item_CopyOptions(p_item
, (*pp_node
)->p_item
);
1751 *pp_node
= input_item_node_AppendItem(*pp_node
, p_item
);
1752 input_item_Release(p_item
);
1753 if (*pp_node
== NULL
)
1758 p_rdh_dir
->p_node
= *pp_node
;
1759 TAB_APPEND(p_rdh
->i_dirs
, p_rdh
->pp_dirs
, p_rdh_dir
);
1762 *pp_node
= p_subnode
;
1768 #undef vlc_readdir_helper_init
1769 void vlc_readdir_helper_init(struct vlc_readdir_helper
*p_rdh
,
1770 vlc_object_t
*p_obj
, input_item_node_t
*p_node
)
1772 /* Read options from the parent item. This allows vlc_stream_ReadDir()
1773 * users to specify options without affecting any exisitng vlc_object_t.
1774 * Apply options on a temporary object in order to not apply options (which
1775 * can be insecure) to the current object. */
1776 vlc_object_t
*p_var_obj
= vlc_object_create(p_obj
, sizeof(vlc_object_t
));
1777 if (p_var_obj
!= NULL
)
1779 input_item_ApplyOptions(p_var_obj
, p_node
->p_item
);
1783 p_rdh
->p_node
= p_node
;
1784 p_rdh
->b_show_hiddenfiles
= var_InheritBool(p_obj
, "show-hiddenfiles");
1785 p_rdh
->psz_ignored_exts
= var_InheritString(p_obj
, "ignore-filetypes");
1786 bool b_autodetect
= var_InheritBool(p_obj
, "sub-autodetect-file");
1787 p_rdh
->i_sub_autodetect_fuzzy
= !b_autodetect
? 0 :
1788 var_InheritInteger(p_obj
, "sub-autodetect-fuzzy");
1789 p_rdh
->b_flatten
= var_InheritBool(p_obj
, "extractor-flatten");
1790 TAB_INIT(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1791 TAB_INIT(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1793 if (p_var_obj
!= NULL
)
1794 vlc_object_delete(p_var_obj
);
1797 void vlc_readdir_helper_finish(struct vlc_readdir_helper
*p_rdh
, bool b_success
)
1801 rdh_sort(p_rdh
->p_node
);
1802 rdh_attach_slaves(p_rdh
, p_rdh
->p_node
);
1804 free(p_rdh
->psz_ignored_exts
);
1806 /* Remove unmatched slaves */
1807 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1809 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1810 if (p_rdh_slave
!= NULL
)
1812 input_item_slave_Delete(p_rdh_slave
->p_slave
);
1813 free(p_rdh_slave
->psz_filename
);
1817 TAB_CLEAN(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1819 for (size_t i
= 0; i
< p_rdh
->i_dirs
; i
++)
1820 free(p_rdh
->pp_dirs
[i
]);
1821 TAB_CLEAN(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1824 int vlc_readdir_helper_additem(struct vlc_readdir_helper
*p_rdh
,
1825 const char *psz_uri
, const char *psz_flatpath
,
1826 const char *psz_filename
, int i_type
, int i_net
)
1828 enum slave_type i_slave_type
;
1829 struct rdh_slave
*p_rdh_slave
= NULL
;
1830 assert(psz_flatpath
|| psz_filename
);
1832 if (!p_rdh
->b_flatten
)
1834 if (psz_filename
== NULL
)
1836 psz_filename
= strrchr(psz_flatpath
, '/');
1837 if (psz_filename
!= NULL
)
1840 psz_filename
= psz_flatpath
;
1845 if (psz_filename
== NULL
)
1846 psz_filename
= psz_flatpath
;
1847 psz_flatpath
= NULL
;
1850 if (p_rdh
->i_sub_autodetect_fuzzy
!= 0
1851 && input_item_slave_GetType(psz_filename
, &i_slave_type
))
1853 p_rdh_slave
= malloc(sizeof(*p_rdh_slave
));
1857 p_rdh_slave
->p_node
= NULL
;
1858 p_rdh_slave
->psz_filename
= strdup(psz_filename
);
1859 p_rdh_slave
->p_slave
= input_item_slave_New(psz_uri
, i_slave_type
,
1860 SLAVE_PRIORITY_MATCH_NONE
);
1861 if (!p_rdh_slave
->p_slave
|| !p_rdh_slave
->psz_filename
)
1863 free(p_rdh_slave
->psz_filename
);
1868 TAB_APPEND(p_rdh
->i_slaves
, p_rdh
->pp_slaves
, p_rdh_slave
);
1871 if (rdh_file_is_ignored(p_rdh
, psz_filename
))
1874 input_item_node_t
*p_node
= p_rdh
->p_node
;
1876 if (psz_flatpath
!= NULL
)
1878 int i_ret
= rdh_unflatten(p_rdh
, &p_node
, psz_flatpath
, i_net
);
1879 if (i_ret
!= VLC_SUCCESS
)
1883 input_item_t
*p_item
= input_item_NewExt(psz_uri
, psz_filename
, INPUT_DURATION_UNSET
, i_type
,
1888 input_item_CopyOptions(p_item
, p_node
->p_item
);
1889 p_node
= input_item_node_AppendItem(p_node
, p_item
);
1890 input_item_Release(p_item
);
1894 /* A slave can also be an item. If there is a match, this item will be
1895 * removed from the parent node. This is not a common case, since most
1896 * slaves will be ignored by rdh_file_is_ignored() */
1897 if (p_rdh_slave
!= NULL
)
1898 p_rdh_slave
->p_node
= p_node
;