1 /*****************************************************************************
2 * item.c: input_item management
3 *****************************************************************************
4 * Copyright (C) 1998-2004 VLC authors and VideoLAN
7 * Authors: Clément Stenac <zorglub@videolan.org>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU Lesser General Public License as published by
11 * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
32 #include <vlc_common.h>
34 #include <vlc_interface.h>
35 #include <vlc_charset.h>
36 #include <vlc_strings.h>
40 #include "input_internal.h"
42 struct input_item_opaque
44 struct input_item_opaque
*next
;
49 static int GuessType( const input_item_t
*p_item
, bool *p_net
);
51 void input_item_SetErrorWhenReading( input_item_t
*p_i
, bool b_error
)
55 vlc_mutex_lock( &p_i
->lock
);
57 b_changed
= p_i
->b_error_when_reading
!= b_error
;
58 p_i
->b_error_when_reading
= b_error
;
60 vlc_mutex_unlock( &p_i
->lock
);
64 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
65 .type
= vlc_InputItemErrorWhenReadingChanged
,
66 .u
.input_item_error_when_reading_changed
.new_value
= b_error
} );
69 void input_item_SignalPreparseEnded( input_item_t
*p_i
, int status
)
71 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
72 .type
= vlc_InputItemPreparseEnded
,
73 .u
.input_item_preparse_ended
.new_status
= status
} );
76 void input_item_SetPreparsed( input_item_t
*p_i
, bool b_preparsed
)
78 bool b_send_event
= false;
80 vlc_mutex_lock( &p_i
->lock
);
83 p_i
->p_meta
= vlc_meta_New();
85 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
88 new_status
= status
| ITEM_PREPARSED
;
90 new_status
= status
& ~ITEM_PREPARSED
;
91 if( status
!= new_status
)
93 vlc_meta_SetStatus(p_i
->p_meta
, new_status
);
97 vlc_mutex_unlock( &p_i
->lock
);
101 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
102 .type
= vlc_InputItemPreparsedChanged
,
103 .u
.input_item_preparsed_changed
.new_status
= new_status
} );
107 void input_item_SetArtNotFound( input_item_t
*p_i
, bool b_not_found
)
109 vlc_mutex_lock( &p_i
->lock
);
112 p_i
->p_meta
= vlc_meta_New();
114 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
117 status
|= ITEM_ART_NOTFOUND
;
119 status
&= ~ITEM_ART_NOTFOUND
;
121 vlc_meta_SetStatus(p_i
->p_meta
, status
);
123 vlc_mutex_unlock( &p_i
->lock
);
126 void input_item_SetArtFetched( input_item_t
*p_i
, bool b_art_fetched
)
128 vlc_mutex_lock( &p_i
->lock
);
131 p_i
->p_meta
= vlc_meta_New();
133 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
136 status
|= ITEM_ART_FETCHED
;
138 status
&= ~ITEM_ART_FETCHED
;
140 vlc_meta_SetStatus(p_i
->p_meta
, status
);
142 vlc_mutex_unlock( &p_i
->lock
);
145 void input_item_SetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
, const char *psz_val
)
147 vlc_mutex_lock( &p_i
->lock
);
149 p_i
->p_meta
= vlc_meta_New();
150 vlc_meta_Set( p_i
->p_meta
, meta_type
, psz_val
);
151 vlc_mutex_unlock( &p_i
->lock
);
153 /* Notify interested third parties */
154 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
155 .type
= vlc_InputItemMetaChanged
,
156 .u
.input_item_meta_changed
.meta_type
= meta_type
} );
159 void input_item_CopyOptions( input_item_t
*p_child
,
160 input_item_t
*p_parent
)
163 uint8_t *flagv
= NULL
;
165 char **optv_realloc
= NULL
;
166 uint8_t *flagv_realloc
= NULL
;
168 vlc_mutex_lock( &p_parent
->lock
);
170 if( p_parent
->i_options
> 0 )
172 optv
= malloc( p_parent
->i_options
* sizeof (*optv
) );
174 flagv
= malloc( p_parent
->i_options
* sizeof (*flagv
) );
178 for( int i
= 0; i
< p_parent
->i_options
; i
++ )
180 char *psz_dup
= strdup( p_parent
->ppsz_options
[i
] );
181 if( likely(psz_dup
) )
183 flagv
[optc
] = p_parent
->optflagv
[i
];
184 optv
[optc
++] = psz_dup
;
190 vlc_mutex_unlock( &p_parent
->lock
);
192 if( likely(optv
&& flagv
&& optc
) )
194 vlc_mutex_lock( &p_child
->lock
);
196 if( INT_MAX
- p_child
->i_options
>= optc
&&
197 SIZE_MAX
/ sizeof (*flagv
) >= (size_t) (p_child
->i_options
+ optc
) )
198 flagv_realloc
= realloc( p_child
->optflagv
,
199 (p_child
->i_options
+ optc
) * sizeof (*flagv
) );
200 if( likely(flagv_realloc
) )
202 p_child
->optflagv
= flagv_realloc
;
203 if( SIZE_MAX
/ sizeof (*optv
) >= (size_t) (p_child
->i_options
+ optc
) )
204 optv_realloc
= realloc( p_child
->ppsz_options
,
205 (p_child
->i_options
+ optc
) * sizeof (*optv
) );
206 if( likely(optv_realloc
) )
208 p_child
->ppsz_options
= optv_realloc
;
209 memcpy( p_child
->ppsz_options
+ p_child
->i_options
, optv
,
210 optc
* sizeof (*optv
) );
211 memcpy( p_child
->optflagv
+ p_child
->i_options
, flagv
,
212 optc
* sizeof (*flagv
) );
213 p_child
->i_options
+= optc
;
214 p_child
->optflagc
+= optc
;
218 vlc_mutex_unlock( &p_child
->lock
);
221 if( unlikely(!flagv_realloc
|| !optv_realloc
) )
223 /* Didn't copy pointers, so need to free the strdup() */
224 for( int i
=0; i
<optc
; i
++ )
232 bool input_item_HasErrorWhenReading( input_item_t
*p_item
)
234 vlc_mutex_lock( &p_item
->lock
);
236 bool b_error
= p_item
->b_error_when_reading
;
238 vlc_mutex_unlock( &p_item
->lock
);
243 bool input_item_MetaMatch( input_item_t
*p_i
,
244 vlc_meta_type_t meta_type
, const char *psz
)
246 vlc_mutex_lock( &p_i
->lock
);
250 vlc_mutex_unlock( &p_i
->lock
);
253 const char *psz_meta
= vlc_meta_Get( p_i
->p_meta
, meta_type
);
254 bool b_ret
= psz_meta
&& strcasestr( psz_meta
, psz
);
256 vlc_mutex_unlock( &p_i
->lock
);
261 char *input_item_GetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
)
263 vlc_mutex_lock( &p_i
->lock
);
267 vlc_mutex_unlock( &p_i
->lock
);
272 if( vlc_meta_Get( p_i
->p_meta
, meta_type
) )
273 psz
= strdup( vlc_meta_Get( p_i
->p_meta
, meta_type
) );
275 vlc_mutex_unlock( &p_i
->lock
);
279 /* Get the title of a given item or fallback to the name if the title is empty */
280 char *input_item_GetTitleFbName( input_item_t
*p_item
)
283 vlc_mutex_lock( &p_item
->lock
);
285 if( !p_item
->p_meta
)
287 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
288 vlc_mutex_unlock( &p_item
->lock
);
292 const char *psz_title
= vlc_meta_Get( p_item
->p_meta
, vlc_meta_Title
);
293 if( !EMPTY_STR( psz_title
) )
294 psz_ret
= strdup( psz_title
);
296 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
298 vlc_mutex_unlock( &p_item
->lock
);
302 char *input_item_GetName( input_item_t
*p_item
)
304 vlc_mutex_lock( &p_item
->lock
);
306 char *psz_name
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
308 vlc_mutex_unlock( &p_item
->lock
);
311 void input_item_SetName( input_item_t
*p_item
, const char *psz_name
)
313 vlc_mutex_lock( &p_item
->lock
);
315 free( p_item
->psz_name
);
316 p_item
->psz_name
= strdup( psz_name
);
318 vlc_mutex_unlock( &p_item
->lock
);
321 char *input_item_GetURI( input_item_t
*p_i
)
323 vlc_mutex_lock( &p_i
->lock
);
325 char *psz_s
= p_i
->psz_uri
? strdup( p_i
->psz_uri
) : NULL
;
327 vlc_mutex_unlock( &p_i
->lock
);
331 void input_item_SetURI( input_item_t
*p_i
, const char *psz_uri
)
335 if( !strstr( psz_uri
, "://" )
336 || strchr( psz_uri
, ' ' ) || strchr( psz_uri
, '"' ) )
337 fprintf( stderr
, "Warning: %s(\"%s\"): file path instead of URL.\n",
340 vlc_mutex_lock( &p_i
->lock
);
341 free( p_i
->psz_uri
);
342 p_i
->psz_uri
= strdup( psz_uri
);
344 p_i
->i_type
= GuessType( p_i
, &p_i
->b_net
);
349 if( p_i
->i_type
== ITEM_TYPE_FILE
|| p_i
->i_type
== ITEM_TYPE_DIRECTORY
)
351 const char *psz_filename
= strrchr( p_i
->psz_uri
, '/' );
353 if( psz_filename
&& *psz_filename
== '/' )
355 if( psz_filename
&& *psz_filename
)
356 p_i
->psz_name
= strdup( psz_filename
);
358 /* Make the name more readable */
361 vlc_uri_decode( p_i
->psz_name
);
362 EnsureUTF8( p_i
->psz_name
);
366 { /* Strip login and password from title */
370 vlc_UrlParse( &url
, psz_uri
);
371 if( url
.psz_protocol
)
374 r
=asprintf( &p_i
->psz_name
, "%s://%s:%d%s", url
.psz_protocol
,
375 url
.psz_host
, url
.i_port
,
376 url
.psz_path
? url
.psz_path
: "" );
378 r
=asprintf( &p_i
->psz_name
, "%s://%s%s", url
.psz_protocol
,
379 url
.psz_host
? url
.psz_host
: "",
380 url
.psz_path
? url
.psz_path
: "" );
385 r
=asprintf( &p_i
->psz_name
, "%s:%d%s", url
.psz_host
, url
.i_port
,
386 url
.psz_path
? url
.psz_path
: "" );
388 r
=asprintf( &p_i
->psz_name
, "%s%s", url
.psz_host
,
389 url
.psz_path
? url
.psz_path
: "" );
391 vlc_UrlClean( &url
);
393 p_i
->psz_name
=NULL
; /* recover from undefined value */
396 vlc_mutex_unlock( &p_i
->lock
);
399 mtime_t
input_item_GetDuration( input_item_t
*p_i
)
401 vlc_mutex_lock( &p_i
->lock
);
403 mtime_t i_duration
= p_i
->i_duration
;
405 vlc_mutex_unlock( &p_i
->lock
);
409 void input_item_SetDuration( input_item_t
*p_i
, mtime_t i_duration
)
411 bool b_send_event
= false;
413 vlc_mutex_lock( &p_i
->lock
);
414 if( p_i
->i_duration
!= i_duration
)
416 p_i
->i_duration
= i_duration
;
419 vlc_mutex_unlock( &p_i
->lock
);
423 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
424 .type
= vlc_InputItemDurationChanged
,
425 .u
.input_item_duration_changed
.new_duration
= i_duration
} );
429 char *input_item_GetNowPlayingFb( input_item_t
*p_item
)
431 char *psz_meta
= input_item_GetMeta( p_item
, vlc_meta_NowPlaying
);
432 if( !psz_meta
|| strlen( psz_meta
) == 0 )
435 return input_item_GetMeta( p_item
, vlc_meta_ESNowPlaying
);
441 bool input_item_IsPreparsed( input_item_t
*p_item
)
443 vlc_mutex_lock( &p_item
->lock
);
444 bool b_preparsed
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_PREPARSED
) != 0 : false;
445 vlc_mutex_unlock( &p_item
->lock
);
450 bool input_item_IsArtFetched( input_item_t
*p_item
)
452 vlc_mutex_lock( &p_item
->lock
);
453 bool b_fetched
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_ART_FETCHED
) != 0 : false;
454 vlc_mutex_unlock( &p_item
->lock
);
459 bool input_item_ShouldPreparseSubItems( input_item_t
*p_item
)
463 vlc_mutex_lock( &p_item
->lock
);
464 b_ret
= p_item
->i_preparse_depth
== -1 ? true : p_item
->i_preparse_depth
> 0;
465 vlc_mutex_unlock( &p_item
->lock
);
470 input_item_t
*input_item_Hold( input_item_t
*p_item
)
472 input_item_owner_t
*owner
= item_owner(p_item
);
474 atomic_fetch_add( &owner
->refs
, 1 );
478 void input_item_Release( input_item_t
*p_item
)
480 input_item_owner_t
*owner
= item_owner(p_item
);
482 if( atomic_fetch_sub(&owner
->refs
, 1) != 1 )
485 vlc_event_manager_fini( &p_item
->event_manager
);
487 free( p_item
->psz_name
);
488 free( p_item
->psz_uri
);
489 if( p_item
->p_stats
!= NULL
)
491 vlc_mutex_destroy( &p_item
->p_stats
->lock
);
492 free( p_item
->p_stats
);
495 if( p_item
->p_meta
!= NULL
)
496 vlc_meta_Delete( p_item
->p_meta
);
498 for( input_item_opaque_t
*o
= p_item
->opaques
, *next
; o
!= NULL
; o
= next
)
504 for( int i
= 0; i
< p_item
->i_options
; i
++ )
505 free( p_item
->ppsz_options
[i
] );
506 TAB_CLEAN( p_item
->i_options
, p_item
->ppsz_options
);
507 free( p_item
->optflagv
);
509 for( int i
= 0; i
< p_item
->i_es
; i
++ )
511 es_format_Clean( p_item
->es
[i
] );
512 free( p_item
->es
[i
] );
514 TAB_CLEAN( p_item
->i_es
, p_item
->es
);
516 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
517 vlc_epg_Delete( p_item
->pp_epg
[i
] );
518 TAB_CLEAN( p_item
->i_epg
, p_item
->pp_epg
);
520 for( int i
= 0; i
< p_item
->i_categories
; i
++ )
521 info_category_Delete( p_item
->pp_categories
[i
] );
522 TAB_CLEAN( p_item
->i_categories
, p_item
->pp_categories
);
524 for( int i
= 0; i
< p_item
->i_slaves
; i
++ )
525 input_item_slave_Delete( p_item
->pp_slaves
[i
] );
526 TAB_CLEAN( p_item
->i_slaves
, p_item
->pp_slaves
);
528 vlc_mutex_destroy( &p_item
->lock
);
532 int input_item_AddOption( input_item_t
*p_input
, const char *psz_option
,
535 int err
= VLC_SUCCESS
;
537 if( psz_option
== NULL
)
540 vlc_mutex_lock( &p_input
->lock
);
541 if (flags
& VLC_INPUT_OPTION_UNIQUE
)
543 for (int i
= 0 ; i
< p_input
->i_options
; i
++)
544 if( !strcmp( p_input
->ppsz_options
[i
], psz_option
) )
548 uint8_t *flagv
= realloc (p_input
->optflagv
, p_input
->optflagc
+ 1);
555 p_input
->optflagv
= flagv
;
557 char* psz_option_dup
= strdup( psz_option
);
558 if( unlikely( !psz_option_dup
) )
564 TAB_APPEND(p_input
->i_options
, p_input
->ppsz_options
, psz_option_dup
);
566 flagv
[p_input
->optflagc
++] = flags
;
569 vlc_mutex_unlock( &p_input
->lock
);
573 int input_item_AddOptions( input_item_t
*p_item
, int i_options
,
574 const char *const *ppsz_options
,
577 int i_ret
= VLC_SUCCESS
;
578 for( int i
= 0; i
< i_options
&& i_ret
== VLC_SUCCESS
; i
++ )
579 i_ret
= input_item_AddOption( p_item
, ppsz_options
[i
], i_flags
);
583 int input_item_AddOpaque(input_item_t
*item
, const char *name
, void *value
)
585 assert(name
!= NULL
);
587 size_t namelen
= strlen(name
);
588 input_item_opaque_t
*entry
= malloc(sizeof (*entry
) + namelen
);
589 if (unlikely(entry
== NULL
))
592 memcpy(entry
->name
, name
, namelen
+ 1);
593 entry
->value
= value
;
595 vlc_mutex_lock(&item
->lock
);
596 entry
->next
= item
->opaques
;
597 item
->opaques
= entry
;
598 vlc_mutex_unlock(&item
->lock
);
602 void input_item_ApplyOptions(vlc_object_t
*obj
, input_item_t
*item
)
604 vlc_mutex_lock(&item
->lock
);
605 assert(item
->optflagc
== (unsigned)item
->i_options
);
607 for (unsigned i
= 0; i
< (unsigned)item
->i_options
; i
++)
608 var_OptionParse(obj
, item
->ppsz_options
[i
],
609 !!(item
->optflagv
[i
] & VLC_INPUT_OPTION_TRUSTED
));
611 for (const input_item_opaque_t
*o
= item
->opaques
; o
!= NULL
; o
= o
->next
)
613 var_Create(obj
, o
->name
, VLC_VAR_ADDRESS
);
614 var_SetAddress(obj
, o
->name
, o
->value
);
617 vlc_mutex_unlock(&item
->lock
);
620 bool input_item_slave_GetType(const char *psz_filename
,
621 enum slave_type
*p_slave_type
)
623 static const char *const ppsz_sub_exts
[] = { SLAVE_SPU_EXTENSIONS
, NULL
};
624 static const char *const ppsz_audio_exts
[] = { SLAVE_AUDIO_EXTENSIONS
, NULL
};
627 enum slave_type i_type
;
628 const char *const *ppsz_exts
;
630 { SLAVE_TYPE_SPU
, ppsz_sub_exts
},
631 { SLAVE_TYPE_AUDIO
, ppsz_audio_exts
},
634 const char *psz_ext
= strrchr(psz_filename
, '.');
635 if (psz_ext
== NULL
|| *(++psz_ext
) == '\0')
638 for (unsigned int i
= 0; i
< sizeof(p_slave_list
) / sizeof(*p_slave_list
); ++i
)
640 for (const char *const *ppsz_slave_ext
= p_slave_list
[i
].ppsz_exts
;
641 *ppsz_slave_ext
!= NULL
; ppsz_slave_ext
++)
643 if (!strcasecmp(psz_ext
, *ppsz_slave_ext
))
645 *p_slave_type
= p_slave_list
[i
].i_type
;
653 input_item_slave_t
*input_item_slave_New(const char *psz_uri
, enum slave_type i_type
,
654 enum slave_priority i_priority
)
659 input_item_slave_t
*p_slave
= malloc( sizeof( *p_slave
) + strlen( psz_uri
) + 1 );
663 p_slave
->i_type
= i_type
;
664 p_slave
->i_priority
= i_priority
;
665 p_slave
->b_forced
= false;
666 strcpy( p_slave
->psz_uri
, psz_uri
);
671 int input_item_AddSlave(input_item_t
*p_item
, input_item_slave_t
*p_slave
)
673 if( p_item
== NULL
|| p_slave
== NULL
674 || p_slave
->i_priority
< SLAVE_PRIORITY_MATCH_NONE
)
677 vlc_mutex_lock( &p_item
->lock
);
679 TAB_APPEND(p_item
->i_slaves
, p_item
->pp_slaves
, p_slave
);
681 vlc_mutex_unlock( &p_item
->lock
);
685 static info_category_t
*InputItemFindCat( input_item_t
*p_item
,
686 int *pi_index
, const char *psz_cat
)
688 vlc_assert_locked( &p_item
->lock
);
689 for( int i
= 0; i
< p_item
->i_categories
&& psz_cat
; i
++ )
691 info_category_t
*p_cat
= p_item
->pp_categories
[i
];
693 if( !strcmp( p_cat
->psz_name
, psz_cat
) )
704 * Get a info item from a given category in a given input item.
706 * \param p_i The input item to get info from
707 * \param psz_cat String representing the category for the info
708 * \param psz_name String representing the name of the desired info
709 * \return A pointer to the string with the given info if found, or an
710 * empty string otherwise. The caller should free the returned
713 char *input_item_GetInfo( input_item_t
*p_i
,
715 const char *psz_name
)
717 vlc_mutex_lock( &p_i
->lock
);
719 const info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
722 info_t
*p_info
= info_category_FindInfo( p_cat
, NULL
, psz_name
);
723 if( p_info
&& p_info
->psz_value
)
725 char *psz_ret
= strdup( p_info
->psz_value
);
726 vlc_mutex_unlock( &p_i
->lock
);
730 vlc_mutex_unlock( &p_i
->lock
);
734 static int InputItemVaAddInfo( input_item_t
*p_i
,
736 const char *psz_name
,
737 const char *psz_format
, va_list args
)
739 vlc_assert_locked( &p_i
->lock
);
741 info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
744 p_cat
= info_category_New( psz_cat
);
747 TAB_APPEND(p_i
->i_categories
, p_i
->pp_categories
, p_cat
);
749 info_t
*p_info
= info_category_VaAddInfo( p_cat
, psz_name
, psz_format
, args
);
750 if( !p_info
|| !p_info
->psz_value
)
755 int input_item_AddInfo( input_item_t
*p_i
,
757 const char *psz_name
,
758 const char *psz_format
, ... )
762 vlc_mutex_lock( &p_i
->lock
);
764 va_start( args
, psz_format
);
765 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
768 vlc_mutex_unlock( &p_i
->lock
);
772 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
773 .type
= vlc_InputItemInfoChanged
} );
778 int input_item_DelInfo( input_item_t
*p_i
,
780 const char *psz_name
)
782 vlc_mutex_lock( &p_i
->lock
);
784 info_category_t
*p_cat
= InputItemFindCat( p_i
, &i_cat
, psz_cat
);
787 vlc_mutex_unlock( &p_i
->lock
);
793 /* Remove a specific info */
794 int i_ret
= info_category_DeleteInfo( p_cat
, psz_name
);
797 vlc_mutex_unlock( &p_i
->lock
);
803 /* Remove the complete categorie */
804 info_category_Delete( p_cat
);
805 TAB_ERASE(p_i
->i_categories
, p_i
->pp_categories
, i_cat
);
807 vlc_mutex_unlock( &p_i
->lock
);
809 vlc_event_send( &p_i
->event_manager
,
810 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
814 void input_item_ReplaceInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
816 vlc_mutex_lock( &p_item
->lock
);
818 info_category_t
*p_old
= InputItemFindCat( p_item
, &i_cat
, p_cat
->psz_name
);
821 info_category_Delete( p_old
);
822 p_item
->pp_categories
[i_cat
] = p_cat
;
825 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
826 vlc_mutex_unlock( &p_item
->lock
);
828 vlc_event_send( &p_item
->event_manager
,
829 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
832 void input_item_MergeInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
834 vlc_mutex_lock( &p_item
->lock
);
835 info_category_t
*p_old
= InputItemFindCat( p_item
, NULL
, p_cat
->psz_name
);
838 for( int i
= 0; i
< p_cat
->i_infos
; i
++ )
839 info_category_ReplaceInfo( p_old
, p_cat
->pp_infos
[i
] );
840 TAB_CLEAN( p_cat
->i_infos
, p_cat
->pp_infos
);
841 info_category_Delete( p_cat
);
844 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
845 vlc_mutex_unlock( &p_item
->lock
);
847 vlc_event_send( &p_item
->event_manager
,
848 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
851 void input_item_SetEpgEvent( input_item_t
*p_item
, const vlc_epg_event_t
*p_epg_evt
)
853 bool b_changed
= false;
854 vlc_mutex_lock( &p_item
->lock
);
856 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
858 vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
859 for( size_t j
= 0; j
< p_epg
->i_event
; j
++ )
861 /* Same event can exist in more than one table */
862 if( p_epg
->pp_event
[j
]->i_id
== p_epg_evt
->i_id
)
864 vlc_epg_event_t
*p_dup
= vlc_epg_event_Duplicate( p_epg_evt
);
867 if( p_epg
->p_current
== p_epg
->pp_event
[j
] )
868 p_epg
->p_current
= p_dup
;
869 vlc_epg_event_Delete( p_epg
->pp_event
[j
] );
870 p_epg
->pp_event
[j
] = p_dup
;
877 vlc_mutex_unlock( &p_item
->lock
);
881 vlc_event_send( &p_item
->event_manager
,
882 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
888 static int InputItemAddInfo( input_item_t
*p_i
,
890 const char *psz_name
,
891 const char *psz_format
, ... )
895 va_start( args
, psz_format
);
896 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
903 void input_item_SetEpg( input_item_t
*p_item
, const vlc_epg_t
*p_update
, bool b_current_source
)
905 vlc_epg_t
*p_epg
= vlc_epg_Duplicate( p_update
);
909 vlc_mutex_lock( &p_item
->lock
);
912 vlc_epg_t
**pp_epg
= NULL
;
913 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
915 if( p_item
->pp_epg
[i
]->i_source_id
== p_update
->i_source_id
&&
916 p_item
->pp_epg
[i
]->i_id
== p_update
->i_id
)
918 pp_epg
= &p_item
->pp_epg
[i
];
923 /* replace with new version */
926 vlc_epg_Delete( *pp_epg
);
927 if( *pp_epg
== p_item
->p_epg_table
) /* current table can have changed */
928 p_item
->p_epg_table
= NULL
;
933 TAB_APPEND( p_item
->i_epg
, p_item
->pp_epg
, p_epg
);
936 if( b_current_source
&& p_epg
->b_present
)
937 p_item
->p_epg_table
= p_epg
;
939 vlc_mutex_unlock( &p_item
->lock
);
943 if( asprintf( &psz_epg
, "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
946 input_item_DelInfo( p_item
, psz_epg
, NULL
);
948 vlc_mutex_lock( &p_item
->lock
);
949 for( size_t i
= 0; i
< p_epg
->i_event
; i
++ )
951 const vlc_epg_event_t
*p_evt
= p_epg
->pp_event
[i
];
952 time_t t_start
= (time_t)p_evt
->i_start
;
956 localtime_r( &t_start
, &tm_start
);
958 snprintf( psz_start
, sizeof(psz_start
), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
959 1900 + tm_start
.tm_year
, 1 + tm_start
.tm_mon
, tm_start
.tm_mday
,
960 tm_start
.tm_hour
, tm_start
.tm_min
, tm_start
.tm_sec
);
961 if( p_evt
->psz_short_description
|| p_evt
->psz_description
)
962 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d) - %s %s",
964 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60,
965 p_evt
->psz_short_description
? p_evt
->psz_short_description
: "" ,
966 p_evt
->psz_description
? p_evt
->psz_description
: "" );
968 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d)",
970 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60 );
972 vlc_mutex_unlock( &p_item
->lock
);
976 vlc_event_send( &p_item
->event_manager
,
977 &(vlc_event_t
){ .type
= vlc_InputItemInfoChanged
, } );
980 void input_item_ChangeEPGSource( input_item_t
*p_item
, int i_source_id
)
982 vlc_mutex_lock( &p_item
->lock
);
983 p_item
->p_epg_table
= NULL
;
984 if( i_source_id
> 0 )
986 /* Update pointer to current/next table in the full schedule */
987 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
989 if( p_item
->pp_epg
[i
]->i_source_id
== i_source_id
&&
990 p_item
->pp_epg
[i
]->b_present
)
992 p_item
->p_epg_table
= p_item
->pp_epg
[i
];
997 vlc_mutex_unlock( &p_item
->lock
);
1000 void input_item_SetEpgTime( input_item_t
*p_item
, int64_t i_time
)
1002 vlc_mutex_lock( &p_item
->lock
);
1003 p_item
->i_epg_time
= i_time
;
1004 vlc_mutex_unlock( &p_item
->lock
);
1007 void input_item_SetEpgOffline( input_item_t
*p_item
)
1009 input_item_ChangeEPGSource( p_item
, -1 );
1012 vlc_mutex_lock( &p_item
->lock
);
1013 const int i_epg_info
= p_item
->i_epg
;
1014 if( i_epg_info
> 0 )
1016 char *ppsz_epg_info
[i_epg_info
];
1017 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
1019 const vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
1020 if( asprintf( &ppsz_epg_info
[i
], "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
1021 ppsz_epg_info
[i
] = NULL
;
1023 vlc_mutex_unlock( &p_item
->lock
);
1025 for( int i
= 0; i
< i_epg_info
; i
++ )
1027 if( !ppsz_epg_info
[i
] )
1029 input_item_DelInfo( p_item
, ppsz_epg_info
[i
], NULL
);
1030 free( ppsz_epg_info
[i
] );
1034 vlc_mutex_unlock( &p_item
->lock
);
1037 vlc_event_send( &p_item
->event_manager
,
1038 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
1042 input_item_NewExt( const char *psz_uri
, const char *psz_name
,
1043 mtime_t duration
, int type
, enum input_item_net_type i_net
)
1045 input_item_owner_t
*owner
= calloc( 1, sizeof( *owner
) );
1046 if( unlikely(owner
== NULL
) )
1049 atomic_init( &owner
->refs
, 1 );
1051 input_item_t
*p_input
= &owner
->item
;
1052 vlc_event_manager_t
* p_em
= &p_input
->event_manager
;
1054 vlc_mutex_init( &p_input
->lock
);
1056 p_input
->psz_name
= NULL
;
1058 input_item_SetName( p_input
, psz_name
);
1060 p_input
->psz_uri
= NULL
;
1062 input_item_SetURI( p_input
, psz_uri
);
1065 p_input
->i_type
= ITEM_TYPE_UNKNOWN
;
1066 p_input
->b_net
= false;
1069 TAB_INIT( p_input
->i_options
, p_input
->ppsz_options
);
1070 p_input
->optflagc
= 0;
1071 p_input
->optflagv
= NULL
;
1072 p_input
->opaques
= NULL
;
1074 p_input
->i_duration
= duration
;
1075 TAB_INIT( p_input
->i_categories
, p_input
->pp_categories
);
1076 TAB_INIT( p_input
->i_es
, p_input
->es
);
1077 p_input
->p_stats
= NULL
;
1078 p_input
->p_meta
= NULL
;
1079 TAB_INIT( p_input
->i_epg
, p_input
->pp_epg
);
1080 TAB_INIT( p_input
->i_slaves
, p_input
->pp_slaves
);
1082 vlc_event_manager_init( p_em
, p_input
);
1084 if( type
!= ITEM_TYPE_UNKNOWN
)
1085 p_input
->i_type
= type
;
1086 p_input
->b_error_when_reading
= false;
1088 if( i_net
!= ITEM_NET_UNKNOWN
)
1089 p_input
->b_net
= i_net
== ITEM_NET
;
1093 input_item_t
*input_item_Copy( input_item_t
*p_input
)
1095 vlc_meta_t
*meta
= NULL
;
1099 vlc_mutex_lock( &p_input
->lock
);
1101 item
= input_item_NewExt( p_input
->psz_uri
, p_input
->psz_name
,
1102 p_input
->i_duration
, p_input
->i_type
,
1104 if( likely(item
!= NULL
) && p_input
->p_meta
!= NULL
)
1106 meta
= vlc_meta_New();
1107 vlc_meta_Merge( meta
, p_input
->p_meta
);
1109 b_net
= p_input
->b_net
;
1110 vlc_mutex_unlock( &p_input
->lock
);
1112 if( likely(item
!= NULL
) )
1113 { /* No need to lock; no other thread has seen this new item yet. */
1114 input_item_CopyOptions( item
, p_input
);
1115 item
->p_meta
= meta
;
1116 item
->b_net
= b_net
;
1122 struct item_type_entry
1124 const char *psz_scheme
;
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 int 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 { "http", ITEM_TYPE_FILE
, true },
1163 { "icyx", ITEM_TYPE_STREAM
, true },
1164 { "imem", ITEM_TYPE_UNKNOWN
, false },
1165 { "isdb-", ITEM_TYPE_CARD
, false },
1166 { "itpc", ITEM_TYPE_PLAYLIST
, true },
1167 { "jack", ITEM_TYPE_CARD
, false },
1168 { "linsys", ITEM_TYPE_CARD
, false },
1169 { "live", ITEM_TYPE_STREAM
, true }, /* livedotcom */
1170 { "mms", ITEM_TYPE_STREAM
, true },
1171 { "mtp", ITEM_TYPE_DISC
, false },
1172 { "nfs", ITEM_TYPE_FILE
, true },
1173 { "ofdm", ITEM_TYPE_CARD
, false },
1174 { "oss", ITEM_TYPE_CARD
, false },
1175 { "pnm", ITEM_TYPE_STREAM
, true },
1176 { "pulse", ITEM_TYPE_CARD
, false },
1177 { "qam", ITEM_TYPE_CARD
, false },
1178 { "qpsk", ITEM_TYPE_CARD
, false },
1179 { "qtcapt", ITEM_TYPE_CARD
, false }, /* qtcapture */
1180 { "qtsound",ITEM_TYPE_CARD
, false },
1181 { "raw139", ITEM_TYPE_CARD
, false }, /* raw1394 */
1182 { "rt", ITEM_TYPE_STREAM
, true }, /* rtp, rtsp, rtmp */
1183 { "satell", ITEM_TYPE_CARD
, false }, /* satellite */
1184 { "satip", ITEM_TYPE_STREAM
, true }, /* satellite over ip */
1185 { "screen", ITEM_TYPE_CARD
, false },
1186 { "sdp", ITEM_TYPE_STREAM
, true },
1187 { "sftp", ITEM_TYPE_FILE
, true },
1188 { "shm", ITEM_TYPE_CARD
, false },
1189 { "smb", ITEM_TYPE_FILE
, true },
1190 { "stream", ITEM_TYPE_STREAM
, false },
1191 { "svcd", ITEM_TYPE_DISC
, false },
1192 { "tcp", ITEM_TYPE_STREAM
, true },
1193 { "terres", ITEM_TYPE_CARD
, false }, /* terrestrial */
1194 { "udp", ITEM_TYPE_STREAM
, true }, /* udplite too */
1195 { "unsv", ITEM_TYPE_STREAM
, true },
1196 { "upnp", ITEM_TYPE_FILE
, true },
1197 { "usdigi", ITEM_TYPE_CARD
, false }, /* usdigital */
1198 { "v4l", ITEM_TYPE_CARD
, false },
1199 { "vcd", ITEM_TYPE_DISC
, false },
1200 { "vdr", ITEM_TYPE_STREAM
, true },
1201 { "wasapi", ITEM_TYPE_CARD
, false },
1202 { "window", ITEM_TYPE_CARD
, false },
1206 for( size_t i
= 1; i
< ARRAY_SIZE( tab
); i
++ )
1207 assert( typecmp( (tab
+ i
)->psz_scheme
, tab
+ i
- 1 ) > 0 );
1212 if( strstr( p_item
->psz_uri
, "://" ) == NULL
)
1213 return ITEM_TYPE_UNKNOWN
; /* invalid URI */
1215 const struct item_type_entry
*e
=
1216 bsearch( p_item
->psz_uri
, tab
, ARRAY_SIZE( tab
),
1217 sizeof( tab
[0] ), typecmp
);
1219 return ITEM_TYPE_UNKNOWN
;
1225 input_item_node_t
*input_item_node_Create( input_item_t
*p_input
)
1227 input_item_node_t
* p_node
= malloc( sizeof( input_item_node_t
) );
1233 p_node
->p_item
= p_input
;
1234 input_item_Hold( p_input
);
1236 p_node
->i_children
= 0;
1237 p_node
->pp_children
= NULL
;
1242 void input_item_node_Delete( input_item_node_t
*p_node
)
1244 for( int i
= 0; i
< p_node
->i_children
; i
++ )
1245 input_item_node_Delete( p_node
->pp_children
[i
] );
1247 input_item_Release( p_node
->p_item
);
1248 free( p_node
->pp_children
);
1252 input_item_node_t
*input_item_node_AppendItem( input_item_node_t
*p_node
, input_item_t
*p_item
)
1254 int i_preparse_depth
;
1255 input_item_node_t
*p_new_child
= input_item_node_Create( p_item
);
1256 if( !p_new_child
) return NULL
;
1258 vlc_mutex_lock( &p_node
->p_item
->lock
);
1259 i_preparse_depth
= p_node
->p_item
->i_preparse_depth
;
1260 vlc_mutex_unlock( &p_node
->p_item
->lock
);
1262 vlc_mutex_lock( &p_item
->lock
);
1263 p_item
->i_preparse_depth
= i_preparse_depth
> 0 ?
1264 i_preparse_depth
-1 :
1266 vlc_mutex_unlock( &p_item
->lock
);
1268 input_item_node_AppendNode( p_node
, p_new_child
);
1272 void input_item_node_AppendNode( input_item_node_t
*p_parent
,
1273 input_item_node_t
*p_child
)
1275 assert(p_parent
!= NULL
);
1276 assert(p_child
!= NULL
);
1277 TAB_APPEND(p_parent
->i_children
, p_parent
->pp_children
, p_child
);
1280 void input_item_node_RemoveNode( input_item_node_t
*parent
,
1281 input_item_node_t
*child
)
1283 TAB_REMOVE(parent
->i_children
, parent
->pp_children
, child
);
1286 void input_item_node_PostAndDelete( input_item_node_t
*p_root
)
1288 vlc_event_send( &p_root
->p_item
->event_manager
, &(vlc_event_t
) {
1289 .type
= vlc_InputItemSubItemTreeAdded
,
1290 .u
.input_item_subitem_tree_added
.p_root
= p_root
} );
1292 input_item_node_Delete( p_root
);
1295 /* Called by es_out when a new Elementary Stream is added or updated. */
1296 void input_item_UpdateTracksInfo(input_item_t
*item
, const es_format_t
*fmt
)
1299 es_format_t
*fmt_copy
= malloc(sizeof *fmt_copy
);
1303 es_format_Copy(fmt_copy
, fmt
);
1305 vlc_mutex_lock( &item
->lock
);
1307 for( i
= 0; i
< item
->i_es
; i
++ )
1309 if (item
->es
[i
]->i_id
!= fmt
->i_id
)
1312 /* We've found the right ES, replace it */
1313 es_format_Clean(item
->es
[i
]);
1315 item
->es
[i
] = fmt_copy
;
1316 vlc_mutex_unlock( &item
->lock
);
1320 /* ES not found, insert it */
1321 TAB_APPEND(item
->i_es
, item
->es
, fmt_copy
);
1322 vlc_mutex_unlock( &item
->lock
);
1325 static int rdh_compar_type(input_item_t
*p1
, input_item_t
*p2
)
1327 if (p1
->i_type
!= p2
->i_type
)
1329 if (p1
->i_type
== ITEM_TYPE_DIRECTORY
)
1331 if (p2
->i_type
== ITEM_TYPE_DIRECTORY
)
1337 static int rdh_compar_filename(const void *a
, const void *b
)
1339 input_item_node_t
*const *na
= a
, *const *nb
= b
;
1340 input_item_t
*ia
= (*na
)->p_item
, *ib
= (*nb
)->p_item
;
1342 int i_ret
= rdh_compar_type(ia
, ib
);
1346 return vlc_filenamecmp(ia
->psz_name
, ib
->psz_name
);
1349 static void rdh_sort(input_item_node_t
*p_node
)
1351 if (p_node
->i_children
<= 0)
1354 /* Sort current node */
1355 qsort(p_node
->pp_children
, p_node
->i_children
,
1356 sizeof(input_item_node_t
*), rdh_compar_filename
);
1358 /* Sort all children */
1359 for (int i
= 0; i
< p_node
->i_children
; i
++)
1360 rdh_sort(p_node
->pp_children
[i
]);
1364 * Does the provided file name has one of the extension provided ?
1366 static bool rdh_file_has_ext(const char *psz_filename
,
1367 const char *psz_ignored_exts
)
1369 if (psz_ignored_exts
== NULL
)
1372 const char *ext
= strrchr(psz_filename
, '.');
1376 size_t extlen
= strlen(++ext
);
1378 for (const char *type
= psz_ignored_exts
, *end
; type
[0]; type
= end
+ 1)
1380 end
= strchr(type
, ',');
1382 end
= type
+ strlen(type
);
1384 if (type
+ extlen
== end
&& !strncasecmp(ext
, type
, extlen
))
1394 static bool rdh_file_is_ignored(struct vlc_readdir_helper
*p_rdh
,
1395 const char *psz_filename
)
1397 return (psz_filename
[0] == '\0'
1398 || strcmp(psz_filename
, ".") == 0
1399 || strcmp(psz_filename
, "..") == 0
1400 || (!p_rdh
->b_show_hiddenfiles
&& psz_filename
[0] == '.')
1401 || rdh_file_has_ext(psz_filename
, p_rdh
->psz_ignored_exts
));
1406 input_item_slave_t
*p_slave
;
1408 input_item_node_t
*p_node
;
1413 input_item_node_t
*p_node
;
1417 static char *rdh_name_from_filename(const char *psz_filename
)
1419 /* remove leading white spaces */
1420 while (*psz_filename
!= '\0' && *psz_filename
== ' ')
1423 char *psz_name
= strdup(psz_filename
);
1427 /* remove extension */
1428 char *psz_ptr
= strrchr(psz_name
, '.');
1429 if (psz_ptr
&& psz_ptr
!= psz_name
)
1432 /* remove trailing white spaces */
1433 int i
= strlen(psz_name
) - 1;
1434 while (psz_name
[i
] == ' ' && i
>= 0)
1435 psz_name
[i
--] = '\0';
1437 /* convert to lower case */
1439 while (*psz_ptr
!= '\0')
1441 *psz_ptr
= tolower(*psz_ptr
);
1448 static uint8_t rdh_get_slave_priority(input_item_t
*p_item
,
1449 input_item_slave_t
*p_slave
,
1450 const char *psz_slave_filename
)
1452 uint8_t i_priority
= SLAVE_PRIORITY_MATCH_NONE
;
1453 char *psz_item_name
= rdh_name_from_filename(p_item
->psz_name
);
1454 char *psz_slave_name
= rdh_name_from_filename(psz_slave_filename
);
1456 if (!psz_item_name
|| !psz_slave_name
)
1459 size_t i_item_len
= strlen(psz_item_name
);
1460 size_t i_slave_len
= strlen(psz_slave_name
);
1462 /* The slave name len should not be twice longer than the item name len. */
1463 if (i_item_len
> i_slave_len
|| i_slave_len
> 2 * i_item_len
)
1466 /* check if the names match exactly */
1467 if (!strcmp(psz_item_name
, psz_slave_name
))
1469 i_priority
= SLAVE_PRIORITY_MATCH_ALL
;
1473 /* "cdg" slaves have to be a full match */
1474 if (p_slave
->i_type
== SLAVE_TYPE_SPU
)
1476 char *psz_ext
= strrchr(psz_slave_name
, '.');
1477 if (psz_ext
!= NULL
&& strcasecmp(++psz_ext
, "cdg") == 0)
1481 /* check if the item name is a substring of the slave name */
1482 const char *psz_sub
= strstr(psz_slave_name
, psz_item_name
);
1486 /* check if the item name was found at the end of the slave name */
1487 if (strlen(psz_sub
+ strlen(psz_item_name
)) == 0)
1489 i_priority
= SLAVE_PRIORITY_MATCH_RIGHT
;
1494 i_priority
= SLAVE_PRIORITY_MATCH_LEFT
;
1500 free(psz_item_name
);
1501 free(psz_slave_name
);
1505 static int rdh_should_match_idx(struct vlc_readdir_helper
*p_rdh
,
1506 struct rdh_slave
*p_rdh_sub
)
1508 char *psz_ext
= strrchr(p_rdh_sub
->psz_filename
, '.');
1513 if (strcasecmp(psz_ext
, "sub") != 0)
1516 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1518 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1520 if (p_rdh_slave
== NULL
|| p_rdh_slave
== p_rdh_sub
)
1523 /* check that priorities match */
1524 if (p_rdh_slave
->p_slave
->i_priority
!=
1525 p_rdh_sub
->p_slave
->i_priority
)
1528 /* check that the filenames without extension match */
1529 if (strncasecmp(p_rdh_sub
->psz_filename
, p_rdh_slave
->psz_filename
,
1530 strlen(p_rdh_sub
->psz_filename
) - 3 ) != 0)
1533 /* check that we have an idx file */
1534 char *psz_ext_idx
= strrchr(p_rdh_slave
->psz_filename
, '.');
1535 if (psz_ext_idx
== NULL
)
1538 if (strcasecmp(psz_ext_idx
, "idx" ) == 0)
1544 static void rdh_attach_slaves(struct vlc_readdir_helper
*p_rdh
,
1545 input_item_node_t
*p_parent_node
)
1547 if (p_rdh
->i_sub_autodetect_fuzzy
== 0)
1550 /* Try to match slaves for each items of the node */
1551 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1553 input_item_node_t
*p_node
= p_parent_node
->pp_children
[i
];
1554 input_item_t
*p_item
= p_node
->p_item
;
1556 enum slave_type unused
;
1557 if (input_item_slave_GetType(p_item
->psz_name
, &unused
))
1558 continue; /* don't match 2 possible slaves between each others */
1560 for (size_t j
= 0; j
< p_rdh
->i_slaves
; j
++)
1562 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[j
];
1564 /* Don't try to match slaves with themselves or slaves already
1565 * attached with the higher priority */
1566 if (p_rdh_slave
->p_node
== p_node
1567 || p_rdh_slave
->p_slave
->i_priority
== SLAVE_PRIORITY_MATCH_ALL
)
1570 uint8_t i_priority
=
1571 rdh_get_slave_priority(p_item
, p_rdh_slave
->p_slave
,
1572 p_rdh_slave
->psz_filename
);
1574 if (i_priority
< p_rdh
->i_sub_autodetect_fuzzy
)
1577 /* Drop the ".sub" slave if a ".idx" slave matches */
1578 if (p_rdh_slave
->p_slave
->i_type
== SLAVE_TYPE_SPU
1579 && rdh_should_match_idx(p_rdh
, p_rdh_slave
))
1582 input_item_slave_t
*p_slave
=
1583 input_item_slave_New(p_rdh_slave
->p_slave
->psz_uri
,
1584 p_rdh_slave
->p_slave
->i_type
,
1586 if (p_slave
== NULL
)
1589 if (input_item_AddSlave(p_item
, p_slave
) != VLC_SUCCESS
)
1591 input_item_slave_Delete(p_slave
);
1595 /* Remove the corresponding node if any: This slave won't be
1596 * added in the parent node */
1597 if (p_rdh_slave
->p_node
!= NULL
)
1599 input_item_node_RemoveNode(p_parent_node
, p_rdh_slave
->p_node
);
1600 input_item_node_Delete(p_rdh_slave
->p_node
);
1601 p_rdh_slave
->p_node
= NULL
;
1604 p_rdh_slave
->p_slave
->i_priority
= i_priority
;
1608 /* Attach all children */
1609 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1610 rdh_attach_slaves(p_rdh
, p_parent_node
->pp_children
[i
]);
1613 static int rdh_unflatten(struct vlc_readdir_helper
*p_rdh
,
1614 input_item_node_t
**pp_node
, const char *psz_path
,
1617 /* Create an input input for each sub folders that is contained in the full
1618 * path. Update pp_node to point to the direct parent of the future item to
1621 assert(psz_path
!= NULL
);
1622 const char *psz_subpaths
= psz_path
;
1624 while ((psz_subpaths
= strchr(psz_subpaths
, '/')))
1626 input_item_node_t
*p_subnode
= NULL
;
1628 /* Check if this sub folder item was already added */
1629 for (size_t i
= 0; i
< p_rdh
->i_dirs
&& p_subnode
== NULL
; i
++)
1631 struct rdh_dir
*rdh_dir
= p_rdh
->pp_dirs
[i
];
1632 if (!strncmp(rdh_dir
->psz_path
, psz_path
, psz_subpaths
- psz_path
))
1633 p_subnode
= rdh_dir
->p_node
;
1636 /* The sub folder item doesn't exist, so create it */
1637 if (p_subnode
== NULL
)
1639 size_t i_sub_path_len
= psz_subpaths
- psz_path
;
1640 struct rdh_dir
*p_rdh_dir
=
1641 malloc(sizeof(struct rdh_dir
) + 1 + i_sub_path_len
);
1642 if (p_rdh_dir
== NULL
)
1644 strncpy(p_rdh_dir
->psz_path
, psz_path
, i_sub_path_len
);
1645 p_rdh_dir
->psz_path
[i_sub_path_len
] = 0;
1647 const char *psz_subpathname
= strrchr(p_rdh_dir
->psz_path
, '/');
1648 if (psz_subpathname
!= NULL
)
1651 psz_subpathname
= p_rdh_dir
->psz_path
;
1653 input_item_t
*p_item
=
1654 input_item_NewExt("vlc://nop", psz_subpathname
, -1,
1655 ITEM_TYPE_DIRECTORY
, i_net
);
1661 input_item_CopyOptions(p_item
, (*pp_node
)->p_item
);
1662 *pp_node
= input_item_node_AppendItem(*pp_node
, p_item
);
1663 input_item_Release(p_item
);
1664 if (*pp_node
== NULL
)
1669 p_rdh_dir
->p_node
= *pp_node
;
1670 TAB_APPEND(p_rdh
->i_dirs
, p_rdh
->pp_dirs
, p_rdh_dir
);
1673 *pp_node
= p_subnode
;
1679 #undef vlc_readdir_helper_init
1680 void vlc_readdir_helper_init(struct vlc_readdir_helper
*p_rdh
,
1681 vlc_object_t
*p_obj
, input_item_node_t
*p_node
)
1683 /* Read options from the parent item. This allows vlc_stream_ReadDir()
1684 * users to specify options whitout touhing any vlc_object_t. Apply options
1685 * on a temporary object in order to not apply options (that can be
1686 * insecure) to the current object. */
1687 vlc_object_t
*p_var_obj
= vlc_object_create(p_obj
, sizeof(vlc_object_t
));
1688 if (p_var_obj
!= NULL
)
1690 input_item_ApplyOptions(p_var_obj
, p_node
->p_item
);
1694 p_rdh
->p_node
= p_node
;
1695 p_rdh
->b_show_hiddenfiles
= var_InheritBool(p_obj
, "show-hiddenfiles");
1696 p_rdh
->psz_ignored_exts
= var_InheritString(p_obj
, "ignore-filetypes");
1697 bool b_autodetect
= var_InheritBool(p_obj
, "sub-autodetect-file");
1698 p_rdh
->i_sub_autodetect_fuzzy
= !b_autodetect
? 0 :
1699 var_InheritInteger(p_obj
, "sub-autodetect-fuzzy");
1700 p_rdh
->b_flatten
= var_InheritBool(p_obj
, "extractor-flatten");
1701 TAB_INIT(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1702 TAB_INIT(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1704 if (p_var_obj
!= NULL
)
1705 vlc_object_release(p_var_obj
);
1708 void vlc_readdir_helper_finish(struct vlc_readdir_helper
*p_rdh
, bool b_success
)
1712 rdh_attach_slaves(p_rdh
, p_rdh
->p_node
);
1713 rdh_sort(p_rdh
->p_node
);
1715 free(p_rdh
->psz_ignored_exts
);
1717 /* Remove unmatched slaves */
1718 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1720 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1721 if (p_rdh_slave
!= NULL
)
1723 input_item_slave_Delete(p_rdh_slave
->p_slave
);
1724 free(p_rdh_slave
->psz_filename
);
1728 TAB_CLEAN(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1730 for (size_t i
= 0; i
< p_rdh
->i_dirs
; i
++)
1731 free(p_rdh
->pp_dirs
[i
]);
1732 TAB_CLEAN(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1735 int vlc_readdir_helper_additem(struct vlc_readdir_helper
*p_rdh
,
1736 const char *psz_uri
, const char *psz_flatpath
,
1737 const char *psz_filename
, int i_type
, int i_net
)
1739 enum slave_type i_slave_type
;
1740 struct rdh_slave
*p_rdh_slave
= NULL
;
1741 assert(psz_flatpath
|| psz_filename
);
1743 if (!p_rdh
->b_flatten
)
1745 if (psz_filename
== NULL
)
1747 psz_filename
= strrchr(psz_flatpath
, '/');
1748 if (psz_filename
!= NULL
)
1751 psz_filename
= psz_flatpath
;
1756 if (psz_filename
== NULL
)
1757 psz_filename
= psz_flatpath
;
1758 psz_flatpath
= NULL
;
1761 if (p_rdh
->i_sub_autodetect_fuzzy
!= 0
1762 && input_item_slave_GetType(psz_filename
, &i_slave_type
))
1764 p_rdh_slave
= malloc(sizeof(*p_rdh_slave
));
1768 p_rdh_slave
->p_node
= NULL
;
1769 p_rdh_slave
->psz_filename
= strdup(psz_filename
);
1770 p_rdh_slave
->p_slave
= input_item_slave_New(psz_uri
, i_slave_type
,
1771 SLAVE_PRIORITY_MATCH_NONE
);
1772 if (!p_rdh_slave
->p_slave
|| !p_rdh_slave
->psz_filename
)
1774 free(p_rdh_slave
->psz_filename
);
1779 TAB_APPEND(p_rdh
->i_slaves
, p_rdh
->pp_slaves
, p_rdh_slave
);
1782 if (rdh_file_is_ignored(p_rdh
, psz_filename
))
1785 input_item_node_t
*p_node
= p_rdh
->p_node
;
1787 if (psz_flatpath
!= NULL
)
1789 int i_ret
= rdh_unflatten(p_rdh
, &p_node
, psz_flatpath
, i_net
);
1790 if (i_ret
!= VLC_SUCCESS
)
1794 input_item_t
*p_item
= input_item_NewExt(psz_uri
, psz_filename
, -1, i_type
,
1799 input_item_CopyOptions(p_item
, p_node
->p_item
);
1800 p_node
= input_item_node_AppendItem(p_node
, p_item
);
1801 input_item_Release(p_item
);
1805 /* A slave can also be an item. If there is a match, this item will be
1806 * removed from the parent node. This is not a common case, since most
1807 * slaves will be ignored by rdh_file_is_ignored() */
1808 if (p_rdh_slave
!= NULL
)
1809 p_rdh_slave
->p_node
= p_node
;