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
);
75 p_i
->p_meta
= vlc_meta_New();
77 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
80 new_status
= status
| ITEM_PREPARSED
;
82 new_status
= status
& ~ITEM_PREPARSED
;
83 if( status
!= new_status
)
85 vlc_meta_SetStatus(p_i
->p_meta
, new_status
);
89 vlc_mutex_unlock( &p_i
->lock
);
93 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
94 .type
= vlc_InputItemPreparsedChanged
,
95 .u
.input_item_preparsed_changed
.new_status
= new_status
} );
99 void input_item_SetArtNotFound( input_item_t
*p_i
, bool b_not_found
)
101 vlc_mutex_lock( &p_i
->lock
);
104 p_i
->p_meta
= vlc_meta_New();
106 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
109 status
|= ITEM_ART_NOTFOUND
;
111 status
&= ~ITEM_ART_NOTFOUND
;
113 vlc_meta_SetStatus(p_i
->p_meta
, status
);
115 vlc_mutex_unlock( &p_i
->lock
);
118 void input_item_SetArtFetched( input_item_t
*p_i
, bool b_art_fetched
)
120 vlc_mutex_lock( &p_i
->lock
);
123 p_i
->p_meta
= vlc_meta_New();
125 int status
= vlc_meta_GetStatus(p_i
->p_meta
);
128 status
|= ITEM_ART_FETCHED
;
130 status
&= ~ITEM_ART_FETCHED
;
132 vlc_meta_SetStatus(p_i
->p_meta
, status
);
134 vlc_mutex_unlock( &p_i
->lock
);
137 void input_item_SetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
, const char *psz_val
)
139 vlc_mutex_lock( &p_i
->lock
);
141 p_i
->p_meta
= vlc_meta_New();
142 vlc_meta_Set( p_i
->p_meta
, meta_type
, psz_val
);
143 vlc_mutex_unlock( &p_i
->lock
);
145 /* Notify interested third parties */
146 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
147 .type
= vlc_InputItemMetaChanged
,
148 .u
.input_item_meta_changed
.meta_type
= meta_type
} );
151 void input_item_CopyOptions( input_item_t
*p_child
,
152 input_item_t
*p_parent
)
155 uint8_t *flagv
= NULL
;
157 char **optv_realloc
= NULL
;
158 uint8_t *flagv_realloc
= NULL
;
160 vlc_mutex_lock( &p_parent
->lock
);
162 if( p_parent
->i_options
> 0 )
164 optv
= vlc_alloc( p_parent
->i_options
, sizeof (*optv
) );
166 flagv
= vlc_alloc( p_parent
->i_options
, sizeof (*flagv
) );
170 for( int i
= 0; i
< p_parent
->i_options
; i
++ )
172 char *psz_dup
= strdup( p_parent
->ppsz_options
[i
] );
173 if( likely(psz_dup
) )
175 flagv
[optc
] = p_parent
->optflagv
[i
];
176 optv
[optc
++] = psz_dup
;
182 vlc_mutex_unlock( &p_parent
->lock
);
184 if( likely(optv
&& flagv
&& optc
) )
186 vlc_mutex_lock( &p_child
->lock
);
188 if( INT_MAX
- p_child
->i_options
>= optc
&&
189 SIZE_MAX
/ sizeof (*flagv
) >= (size_t) (p_child
->i_options
+ optc
) )
190 flagv_realloc
= realloc( p_child
->optflagv
,
191 (p_child
->i_options
+ optc
) * sizeof (*flagv
) );
192 if( likely(flagv_realloc
) )
194 p_child
->optflagv
= flagv_realloc
;
195 if( SIZE_MAX
/ sizeof (*optv
) >= (size_t) (p_child
->i_options
+ optc
) )
196 optv_realloc
= realloc( p_child
->ppsz_options
,
197 (p_child
->i_options
+ optc
) * sizeof (*optv
) );
198 if( likely(optv_realloc
) )
200 p_child
->ppsz_options
= optv_realloc
;
201 memcpy( p_child
->ppsz_options
+ p_child
->i_options
, optv
,
202 optc
* sizeof (*optv
) );
203 memcpy( p_child
->optflagv
+ p_child
->i_options
, flagv
,
204 optc
* sizeof (*flagv
) );
205 p_child
->i_options
+= optc
;
206 p_child
->optflagc
+= optc
;
210 vlc_mutex_unlock( &p_child
->lock
);
213 if( unlikely(!flagv_realloc
|| !optv_realloc
) )
215 /* Didn't copy pointers, so need to free the strdup() */
216 for( int i
=0; i
<optc
; i
++ )
224 bool input_item_HasErrorWhenReading( input_item_t
*p_item
)
226 vlc_mutex_lock( &p_item
->lock
);
228 bool b_error
= p_item
->b_error_when_reading
;
230 vlc_mutex_unlock( &p_item
->lock
);
235 bool input_item_MetaMatch( input_item_t
*p_i
,
236 vlc_meta_type_t meta_type
, const char *psz
)
238 vlc_mutex_lock( &p_i
->lock
);
242 vlc_mutex_unlock( &p_i
->lock
);
245 const char *psz_meta
= vlc_meta_Get( p_i
->p_meta
, meta_type
);
246 bool b_ret
= psz_meta
&& strcasestr( psz_meta
, psz
);
248 vlc_mutex_unlock( &p_i
->lock
);
253 const char *input_item_GetMetaLocked(input_item_t
*item
,
254 vlc_meta_type_t meta_type
)
256 vlc_mutex_assert(&item
->lock
);
261 return vlc_meta_Get(item
->p_meta
, meta_type
);
264 char *input_item_GetMeta( input_item_t
*p_i
, vlc_meta_type_t meta_type
)
266 vlc_mutex_lock( &p_i
->lock
);
267 const char *value
= input_item_GetMetaLocked( p_i
, meta_type
);
268 char *psz
= value
? strdup( value
) : NULL
;
269 vlc_mutex_unlock( &p_i
->lock
);
273 /* Get the title of a given item or fallback to the name if the title is empty */
274 char *input_item_GetTitleFbName( input_item_t
*p_item
)
277 vlc_mutex_lock( &p_item
->lock
);
279 if( !p_item
->p_meta
)
281 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
282 vlc_mutex_unlock( &p_item
->lock
);
286 const char *psz_title
= vlc_meta_Get( p_item
->p_meta
, vlc_meta_Title
);
287 if( !EMPTY_STR( psz_title
) )
288 psz_ret
= strdup( psz_title
);
290 psz_ret
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
292 vlc_mutex_unlock( &p_item
->lock
);
296 char *input_item_GetName( input_item_t
*p_item
)
298 vlc_mutex_lock( &p_item
->lock
);
300 char *psz_name
= p_item
->psz_name
? strdup( p_item
->psz_name
) : NULL
;
302 vlc_mutex_unlock( &p_item
->lock
);
305 void input_item_SetName( input_item_t
*p_item
, const char *psz_name
)
307 vlc_mutex_lock( &p_item
->lock
);
309 free( p_item
->psz_name
);
310 p_item
->psz_name
= strdup( psz_name
);
312 vlc_mutex_unlock( &p_item
->lock
);
315 char *input_item_GetURI( input_item_t
*p_i
)
317 vlc_mutex_lock( &p_i
->lock
);
319 char *psz_s
= p_i
->psz_uri
? strdup( p_i
->psz_uri
) : NULL
;
321 vlc_mutex_unlock( &p_i
->lock
);
325 void input_item_SetURI( input_item_t
*p_i
, const char *psz_uri
)
329 if( !strstr( psz_uri
, "://" )
330 || strchr( psz_uri
, ' ' ) || strchr( psz_uri
, '"' ) )
331 fprintf( stderr
, "Warning: %s(\"%s\"): file path instead of URL.\n",
334 vlc_mutex_lock( &p_i
->lock
);
335 free( p_i
->psz_uri
);
336 p_i
->psz_uri
= strdup( psz_uri
);
338 p_i
->i_type
= GuessType( p_i
, &p_i
->b_net
);
343 if( p_i
->i_type
== ITEM_TYPE_FILE
|| p_i
->i_type
== ITEM_TYPE_DIRECTORY
)
345 const char *psz_filename
= strrchr( p_i
->psz_uri
, '/' );
347 if( psz_filename
&& *psz_filename
== '/' )
349 if( psz_filename
&& *psz_filename
)
350 p_i
->psz_name
= strdup( psz_filename
);
352 /* Make the name more readable */
355 vlc_uri_decode( p_i
->psz_name
);
356 EnsureUTF8( p_i
->psz_name
);
360 { /* Strip login and password from title */
364 vlc_UrlParse( &url
, psz_uri
);
365 if( url
.psz_protocol
)
368 r
=asprintf( &p_i
->psz_name
, "%s://%s:%u%s", url
.psz_protocol
,
369 url
.psz_host
, url
.i_port
,
370 url
.psz_path
? url
.psz_path
: "" );
372 r
=asprintf( &p_i
->psz_name
, "%s://%s%s", url
.psz_protocol
,
373 url
.psz_host
? url
.psz_host
: "",
374 url
.psz_path
? url
.psz_path
: "" );
379 r
=asprintf( &p_i
->psz_name
, "%s:%u%s", url
.psz_host
, url
.i_port
,
380 url
.psz_path
? url
.psz_path
: "" );
382 r
=asprintf( &p_i
->psz_name
, "%s%s", url
.psz_host
,
383 url
.psz_path
? url
.psz_path
: "" );
385 vlc_UrlClean( &url
);
387 p_i
->psz_name
=NULL
; /* recover from undefined value */
390 vlc_mutex_unlock( &p_i
->lock
);
393 vlc_tick_t
input_item_GetDuration( input_item_t
*p_i
)
395 vlc_mutex_lock( &p_i
->lock
);
397 vlc_tick_t i_duration
= p_i
->i_duration
;
399 vlc_mutex_unlock( &p_i
->lock
);
400 if (i_duration
== INPUT_DURATION_INDEFINITE
)
402 else if (i_duration
== INPUT_DURATION_UNSET
)
407 void input_item_SetDuration( input_item_t
*p_i
, vlc_tick_t i_duration
)
409 bool b_send_event
= false;
411 vlc_mutex_lock( &p_i
->lock
);
412 if( p_i
->i_duration
!= i_duration
)
414 p_i
->i_duration
= i_duration
;
417 vlc_mutex_unlock( &p_i
->lock
);
421 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
422 .type
= vlc_InputItemDurationChanged
,
423 .u
.input_item_duration_changed
.new_duration
= i_duration
} );
427 char *input_item_GetNowPlayingFb( input_item_t
*p_item
)
429 char *psz_meta
= input_item_GetMeta( p_item
, vlc_meta_NowPlaying
);
430 if( !psz_meta
|| strlen( psz_meta
) == 0 )
433 return input_item_GetMeta( p_item
, vlc_meta_ESNowPlaying
);
439 bool input_item_IsPreparsed( input_item_t
*p_item
)
441 vlc_mutex_lock( &p_item
->lock
);
442 bool b_preparsed
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_PREPARSED
) != 0 : false;
443 vlc_mutex_unlock( &p_item
->lock
);
448 bool input_item_IsArtFetched( input_item_t
*p_item
)
450 vlc_mutex_lock( &p_item
->lock
);
451 bool b_fetched
= p_item
->p_meta
? ( vlc_meta_GetStatus(p_item
->p_meta
) & ITEM_ART_FETCHED
) != 0 : false;
452 vlc_mutex_unlock( &p_item
->lock
);
457 bool input_item_ShouldPreparseSubItems( input_item_t
*p_item
)
461 vlc_mutex_lock( &p_item
->lock
);
462 b_ret
= p_item
->i_preparse_depth
== -1 ? true : p_item
->i_preparse_depth
> 0;
463 vlc_mutex_unlock( &p_item
->lock
);
468 input_item_t
*input_item_Hold( input_item_t
*p_item
)
470 input_item_owner_t
*owner
= item_owner(p_item
);
472 vlc_atomic_rc_inc( &owner
->rc
);
476 void input_item_Release( input_item_t
*p_item
)
478 input_item_owner_t
*owner
= item_owner(p_item
);
480 if( !vlc_atomic_rc_dec( &owner
->rc
) )
483 vlc_event_manager_fini( &p_item
->event_manager
);
485 free( p_item
->psz_name
);
486 free( p_item
->psz_uri
);
487 free( p_item
->p_stats
);
489 if( p_item
->p_meta
!= NULL
)
490 vlc_meta_Delete( p_item
->p_meta
);
492 for( input_item_opaque_t
*o
= p_item
->opaques
, *next
; o
!= NULL
; o
= next
)
498 for( int i
= 0; i
< p_item
->i_options
; i
++ )
499 free( p_item
->ppsz_options
[i
] );
500 TAB_CLEAN( p_item
->i_options
, p_item
->ppsz_options
);
501 free( p_item
->optflagv
);
503 for( int i
= 0; i
< p_item
->i_es
; i
++ )
505 es_format_Clean( p_item
->es
[i
] );
506 free( p_item
->es
[i
] );
508 TAB_CLEAN( p_item
->i_es
, p_item
->es
);
510 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
511 vlc_epg_Delete( p_item
->pp_epg
[i
] );
512 TAB_CLEAN( p_item
->i_epg
, p_item
->pp_epg
);
514 for( int i
= 0; i
< p_item
->i_categories
; i
++ )
515 info_category_Delete( p_item
->pp_categories
[i
] );
516 TAB_CLEAN( p_item
->i_categories
, p_item
->pp_categories
);
518 for( int i
= 0; i
< p_item
->i_slaves
; i
++ )
519 input_item_slave_Delete( p_item
->pp_slaves
[i
] );
520 TAB_CLEAN( p_item
->i_slaves
, p_item
->pp_slaves
);
522 vlc_mutex_destroy( &p_item
->lock
);
526 int input_item_AddOption( input_item_t
*p_input
, const char *psz_option
,
529 int err
= VLC_SUCCESS
;
531 if( psz_option
== NULL
)
534 vlc_mutex_lock( &p_input
->lock
);
535 if (flags
& VLC_INPUT_OPTION_UNIQUE
)
537 for (int i
= 0 ; i
< p_input
->i_options
; i
++)
538 if( !strcmp( p_input
->ppsz_options
[i
], psz_option
) )
542 uint8_t *flagv
= realloc (p_input
->optflagv
, p_input
->optflagc
+ 1);
549 p_input
->optflagv
= flagv
;
551 char* psz_option_dup
= strdup( psz_option
);
552 if( unlikely( !psz_option_dup
) )
558 TAB_APPEND(p_input
->i_options
, p_input
->ppsz_options
, psz_option_dup
);
560 flagv
[p_input
->optflagc
++] = flags
;
563 vlc_mutex_unlock( &p_input
->lock
);
567 int input_item_AddOptions( input_item_t
*p_item
, int i_options
,
568 const char *const *ppsz_options
,
571 int i_ret
= VLC_SUCCESS
;
572 for( int i
= 0; i
< i_options
&& i_ret
== VLC_SUCCESS
; i
++ )
573 i_ret
= input_item_AddOption( p_item
, ppsz_options
[i
], i_flags
);
577 int input_item_AddOpaque(input_item_t
*item
, const char *name
, void *value
)
579 assert(name
!= NULL
);
581 size_t namelen
= strlen(name
);
582 input_item_opaque_t
*entry
= malloc(sizeof (*entry
) + namelen
);
583 if (unlikely(entry
== NULL
))
586 memcpy(entry
->name
, name
, namelen
+ 1);
587 entry
->value
= value
;
589 vlc_mutex_lock(&item
->lock
);
590 entry
->next
= item
->opaques
;
591 item
->opaques
= entry
;
592 vlc_mutex_unlock(&item
->lock
);
596 void input_item_ApplyOptions(vlc_object_t
*obj
, input_item_t
*item
)
598 vlc_mutex_lock(&item
->lock
);
599 assert(item
->optflagc
== (unsigned)item
->i_options
);
601 for (unsigned i
= 0; i
< (unsigned)item
->i_options
; i
++)
602 var_OptionParse(obj
, item
->ppsz_options
[i
],
603 !!(item
->optflagv
[i
] & VLC_INPUT_OPTION_TRUSTED
));
605 for (const input_item_opaque_t
*o
= item
->opaques
; o
!= NULL
; o
= o
->next
)
607 var_Create(obj
, o
->name
, VLC_VAR_ADDRESS
);
608 var_SetAddress(obj
, o
->name
, o
->value
);
611 vlc_mutex_unlock(&item
->lock
);
614 static int bsearch_strcmp_cb(const void *a
, const void *b
)
616 const char *const *entry
= b
;
617 return strcasecmp(a
, *entry
);
620 static bool input_item_IsMaster(const char *psz_filename
)
622 static const char *const ppsz_master_exts
[] = { MASTER_EXTENSIONS
};
624 const char *psz_ext
= strrchr(psz_filename
, '.');
625 if (psz_ext
== NULL
|| *(++psz_ext
) == '\0')
628 return bsearch(psz_ext
, ppsz_master_exts
, ARRAY_SIZE(ppsz_master_exts
),
629 sizeof(const char *), bsearch_strcmp_cb
) != NULL
;
632 bool input_item_slave_GetType(const char *psz_filename
,
633 enum slave_type
*p_slave_type
)
635 static const char *const ppsz_sub_exts
[] = { SLAVE_SPU_EXTENSIONS
};
636 static const char *const ppsz_audio_exts
[] = { SLAVE_AUDIO_EXTENSIONS
};
639 enum slave_type i_type
;
640 const char *const *ppsz_exts
;
643 { SLAVE_TYPE_SPU
, ppsz_sub_exts
, ARRAY_SIZE(ppsz_sub_exts
) },
644 { SLAVE_TYPE_AUDIO
, ppsz_audio_exts
, ARRAY_SIZE(ppsz_audio_exts
) },
647 const char *psz_ext
= strrchr(psz_filename
, '.');
648 if (psz_ext
== NULL
|| *(++psz_ext
) == '\0')
651 for (unsigned int i
= 0; i
< sizeof(p_slave_list
) / sizeof(*p_slave_list
); ++i
)
653 if (bsearch(psz_ext
, p_slave_list
[i
].ppsz_exts
, p_slave_list
[i
].nmemb
,
654 sizeof(const char *), bsearch_strcmp_cb
))
656 *p_slave_type
= p_slave_list
[i
].i_type
;
663 input_item_slave_t
*input_item_slave_New(const char *psz_uri
, enum slave_type i_type
,
664 enum slave_priority i_priority
)
669 input_item_slave_t
*p_slave
= malloc( sizeof( *p_slave
) + strlen( psz_uri
) + 1 );
673 p_slave
->i_type
= i_type
;
674 p_slave
->i_priority
= i_priority
;
675 p_slave
->b_forced
= false;
676 strcpy( p_slave
->psz_uri
, psz_uri
);
681 int input_item_AddSlave(input_item_t
*p_item
, input_item_slave_t
*p_slave
)
683 if( p_item
== NULL
|| p_slave
== NULL
684 || p_slave
->i_priority
< SLAVE_PRIORITY_MATCH_NONE
)
687 vlc_mutex_lock( &p_item
->lock
);
689 TAB_APPEND(p_item
->i_slaves
, p_item
->pp_slaves
, p_slave
);
691 vlc_mutex_unlock( &p_item
->lock
);
695 static info_category_t
*InputItemFindCat( input_item_t
*p_item
,
696 int *pi_index
, const char *psz_cat
)
698 vlc_mutex_assert( &p_item
->lock
);
699 for( int i
= 0; i
< p_item
->i_categories
&& psz_cat
; i
++ )
701 info_category_t
*p_cat
= p_item
->pp_categories
[i
];
703 if( !strcmp( p_cat
->psz_name
, psz_cat
) )
714 * Get a info item from a given category in a given input item.
716 * \param p_i The input item to get info from
717 * \param psz_cat String representing the category for the info
718 * \param psz_name String representing the name of the desired info
719 * \return A pointer to the string with the given info if found, or an
720 * empty string otherwise. The caller should free the returned
723 char *input_item_GetInfo( input_item_t
*p_i
,
725 const char *psz_name
)
727 vlc_mutex_lock( &p_i
->lock
);
729 const info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
732 info_t
*p_info
= info_category_FindInfo( p_cat
, psz_name
);
733 if( p_info
&& p_info
->psz_value
)
735 char *psz_ret
= strdup( p_info
->psz_value
);
736 vlc_mutex_unlock( &p_i
->lock
);
740 vlc_mutex_unlock( &p_i
->lock
);
744 static int InputItemVaAddInfo( input_item_t
*p_i
,
746 const char *psz_name
,
747 const char *psz_format
, va_list args
)
749 vlc_mutex_assert( &p_i
->lock
);
751 info_category_t
*p_cat
= InputItemFindCat( p_i
, NULL
, psz_cat
);
754 p_cat
= info_category_New( psz_cat
);
757 TAB_APPEND(p_i
->i_categories
, p_i
->pp_categories
, p_cat
);
759 info_t
*p_info
= info_category_VaAddInfo( p_cat
, psz_name
, psz_format
, args
);
760 if( !p_info
|| !p_info
->psz_value
)
765 int input_item_AddInfo( input_item_t
*p_i
,
767 const char *psz_name
,
768 const char *psz_format
, ... )
772 vlc_mutex_lock( &p_i
->lock
);
774 va_start( args
, psz_format
);
775 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
778 vlc_mutex_unlock( &p_i
->lock
);
782 vlc_event_send( &p_i
->event_manager
, &(vlc_event_t
) {
783 .type
= vlc_InputItemInfoChanged
} );
788 int input_item_DelInfo( input_item_t
*p_i
,
790 const char *psz_name
)
792 vlc_mutex_lock( &p_i
->lock
);
794 info_category_t
*p_cat
= InputItemFindCat( p_i
, &i_cat
, psz_cat
);
797 vlc_mutex_unlock( &p_i
->lock
);
803 /* Remove a specific info */
804 int i_ret
= info_category_DeleteInfo( p_cat
, psz_name
);
807 vlc_mutex_unlock( &p_i
->lock
);
813 /* Remove the complete categorie */
814 info_category_Delete( p_cat
);
815 TAB_ERASE(p_i
->i_categories
, p_i
->pp_categories
, i_cat
);
817 vlc_mutex_unlock( &p_i
->lock
);
819 vlc_event_send( &p_i
->event_manager
,
820 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
824 void input_item_ReplaceInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
826 vlc_mutex_lock( &p_item
->lock
);
828 info_category_t
*p_old
= InputItemFindCat( p_item
, &i_cat
, p_cat
->psz_name
);
831 info_category_Delete( p_old
);
832 p_item
->pp_categories
[i_cat
] = p_cat
;
835 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
836 vlc_mutex_unlock( &p_item
->lock
);
838 vlc_event_send( &p_item
->event_manager
,
839 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
842 void input_item_MergeInfos( input_item_t
*p_item
, info_category_t
*p_cat
)
844 vlc_mutex_lock( &p_item
->lock
);
845 info_category_t
*p_old
= InputItemFindCat( p_item
, NULL
, p_cat
->psz_name
);
850 info_foreach(info
, &p_cat
->infos
)
851 info_category_ReplaceInfo( p_old
, info
);
852 vlc_list_init( &p_cat
->infos
);
853 info_category_Delete( p_cat
);
856 TAB_APPEND(p_item
->i_categories
, p_item
->pp_categories
, p_cat
);
857 vlc_mutex_unlock( &p_item
->lock
);
859 vlc_event_send( &p_item
->event_manager
,
860 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
863 void input_item_SetEpgEvent( input_item_t
*p_item
, const vlc_epg_event_t
*p_epg_evt
)
865 bool b_changed
= false;
866 vlc_mutex_lock( &p_item
->lock
);
868 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
870 vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
871 for( size_t j
= 0; j
< p_epg
->i_event
; j
++ )
873 /* Same event can exist in more than one table */
874 if( p_epg
->pp_event
[j
]->i_id
== p_epg_evt
->i_id
)
876 vlc_epg_event_t
*p_dup
= vlc_epg_event_Duplicate( p_epg_evt
);
879 if( p_epg
->p_current
== p_epg
->pp_event
[j
] )
880 p_epg
->p_current
= p_dup
;
881 vlc_epg_event_Delete( p_epg
->pp_event
[j
] );
882 p_epg
->pp_event
[j
] = p_dup
;
889 vlc_mutex_unlock( &p_item
->lock
);
893 vlc_event_send( &p_item
->event_manager
,
894 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
900 static int InputItemAddInfo( input_item_t
*p_i
,
902 const char *psz_name
,
903 const char *psz_format
, ... )
907 va_start( args
, psz_format
);
908 const int i_ret
= InputItemVaAddInfo( p_i
, psz_cat
, psz_name
, psz_format
, args
);
915 void input_item_SetEpg( input_item_t
*p_item
, const vlc_epg_t
*p_update
, bool b_current_source
)
917 vlc_epg_t
*p_epg
= vlc_epg_Duplicate( p_update
);
921 vlc_mutex_lock( &p_item
->lock
);
924 vlc_epg_t
**pp_epg
= NULL
;
925 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
927 if( p_item
->pp_epg
[i
]->i_source_id
== p_update
->i_source_id
&&
928 p_item
->pp_epg
[i
]->i_id
== p_update
->i_id
)
930 pp_epg
= &p_item
->pp_epg
[i
];
935 /* replace with new version */
938 vlc_epg_Delete( *pp_epg
);
939 if( *pp_epg
== p_item
->p_epg_table
) /* current table can have changed */
940 p_item
->p_epg_table
= NULL
;
945 TAB_APPEND( p_item
->i_epg
, p_item
->pp_epg
, p_epg
);
948 if( b_current_source
&& p_epg
->b_present
)
949 p_item
->p_epg_table
= p_epg
;
951 vlc_mutex_unlock( &p_item
->lock
);
955 if( asprintf( &psz_epg
, "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
958 input_item_DelInfo( p_item
, psz_epg
, NULL
);
960 vlc_mutex_lock( &p_item
->lock
);
961 for( size_t i
= 0; i
< p_epg
->i_event
; i
++ )
963 const vlc_epg_event_t
*p_evt
= p_epg
->pp_event
[i
];
964 time_t t_start
= (time_t)p_evt
->i_start
;
968 localtime_r( &t_start
, &tm_start
);
970 snprintf( psz_start
, sizeof(psz_start
), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
971 1900 + tm_start
.tm_year
, 1 + tm_start
.tm_mon
, tm_start
.tm_mday
,
972 tm_start
.tm_hour
, tm_start
.tm_min
, tm_start
.tm_sec
);
973 if( p_evt
->psz_short_description
|| p_evt
->psz_description
)
974 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d) - %s %s",
976 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60,
977 p_evt
->psz_short_description
? p_evt
->psz_short_description
: "" ,
978 p_evt
->psz_description
? p_evt
->psz_description
: "" );
980 InputItemAddInfo( p_item
, psz_epg
, psz_start
, "%s (%2.2d:%2.2d)",
982 p_evt
->i_duration
/60/60, (p_evt
->i_duration
/60)%60 );
984 vlc_mutex_unlock( &p_item
->lock
);
988 vlc_event_send( &p_item
->event_manager
,
989 &(vlc_event_t
){ .type
= vlc_InputItemInfoChanged
, } );
992 void input_item_ChangeEPGSource( input_item_t
*p_item
, int i_source_id
)
994 vlc_mutex_lock( &p_item
->lock
);
995 p_item
->p_epg_table
= NULL
;
996 if( i_source_id
> 0 )
998 /* Update pointer to current/next table in the full schedule */
999 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
1001 if( p_item
->pp_epg
[i
]->i_source_id
== i_source_id
&&
1002 p_item
->pp_epg
[i
]->b_present
)
1004 p_item
->p_epg_table
= p_item
->pp_epg
[i
];
1009 vlc_mutex_unlock( &p_item
->lock
);
1012 void input_item_SetEpgTime( input_item_t
*p_item
, int64_t i_time
)
1014 vlc_mutex_lock( &p_item
->lock
);
1015 p_item
->i_epg_time
= i_time
;
1016 vlc_mutex_unlock( &p_item
->lock
);
1019 void input_item_SetEpgOffline( input_item_t
*p_item
)
1021 input_item_ChangeEPGSource( p_item
, -1 );
1024 vlc_mutex_lock( &p_item
->lock
);
1025 const int i_epg_info
= p_item
->i_epg
;
1026 if( i_epg_info
> 0 )
1028 char *ppsz_epg_info
[i_epg_info
];
1029 for( int i
= 0; i
< p_item
->i_epg
; i
++ )
1031 const vlc_epg_t
*p_epg
= p_item
->pp_epg
[i
];
1032 if( asprintf( &ppsz_epg_info
[i
], "EPG %s", p_epg
->psz_name
? p_epg
->psz_name
: "unknown" ) < 0 )
1033 ppsz_epg_info
[i
] = NULL
;
1035 vlc_mutex_unlock( &p_item
->lock
);
1037 for( int i
= 0; i
< i_epg_info
; i
++ )
1039 if( !ppsz_epg_info
[i
] )
1041 input_item_DelInfo( p_item
, ppsz_epg_info
[i
], NULL
);
1042 free( ppsz_epg_info
[i
] );
1046 vlc_mutex_unlock( &p_item
->lock
);
1049 vlc_event_send( &p_item
->event_manager
,
1050 &(vlc_event_t
) { .type
= vlc_InputItemInfoChanged
} );
1054 input_item_NewExt( const char *psz_uri
, const char *psz_name
,
1055 vlc_tick_t duration
, enum input_item_type_e type
, enum input_item_net_type i_net
)
1057 input_item_owner_t
*owner
= calloc( 1, sizeof( *owner
) );
1058 if( unlikely(owner
== NULL
) )
1061 vlc_atomic_rc_init( &owner
->rc
);
1063 input_item_t
*p_input
= &owner
->item
;
1064 vlc_event_manager_t
* p_em
= &p_input
->event_manager
;
1066 vlc_mutex_init( &p_input
->lock
);
1068 p_input
->psz_name
= NULL
;
1070 input_item_SetName( p_input
, psz_name
);
1072 p_input
->psz_uri
= NULL
;
1074 input_item_SetURI( p_input
, psz_uri
);
1077 p_input
->i_type
= ITEM_TYPE_UNKNOWN
;
1078 p_input
->b_net
= false;
1081 TAB_INIT( p_input
->i_options
, p_input
->ppsz_options
);
1082 p_input
->optflagc
= 0;
1083 p_input
->optflagv
= NULL
;
1084 p_input
->opaques
= NULL
;
1086 p_input
->i_duration
= duration
;
1087 TAB_INIT( p_input
->i_categories
, p_input
->pp_categories
);
1088 TAB_INIT( p_input
->i_es
, p_input
->es
);
1089 p_input
->p_stats
= NULL
;
1090 p_input
->p_meta
= NULL
;
1091 TAB_INIT( p_input
->i_epg
, p_input
->pp_epg
);
1092 TAB_INIT( p_input
->i_slaves
, p_input
->pp_slaves
);
1094 vlc_event_manager_init( p_em
, p_input
);
1096 if( type
!= ITEM_TYPE_UNKNOWN
)
1097 p_input
->i_type
= type
;
1098 p_input
->b_error_when_reading
= false;
1100 if( i_net
!= ITEM_NET_UNKNOWN
)
1101 p_input
->b_net
= i_net
== ITEM_NET
;
1105 input_item_t
*input_item_Copy( input_item_t
*p_input
)
1107 vlc_meta_t
*meta
= NULL
;
1111 vlc_mutex_lock( &p_input
->lock
);
1113 item
= input_item_NewExt( p_input
->psz_uri
, p_input
->psz_name
,
1114 p_input
->i_duration
, p_input
->i_type
,
1116 if( likely(item
!= NULL
) && p_input
->p_meta
!= NULL
)
1118 meta
= vlc_meta_New();
1119 vlc_meta_Merge( meta
, p_input
->p_meta
);
1121 b_net
= p_input
->b_net
;
1122 vlc_mutex_unlock( &p_input
->lock
);
1124 if( likely(item
!= NULL
) )
1125 { /* No need to lock; no other thread has seen this new item yet. */
1126 input_item_CopyOptions( item
, p_input
);
1127 item
->p_meta
= meta
;
1128 item
->b_net
= b_net
;
1134 struct item_type_entry
1136 const char *psz_scheme
;
1137 enum input_item_type_e i_type
;
1141 static int typecmp( const void *key
, const void *entry
)
1143 const struct item_type_entry
*type
= entry
;
1144 const char *uri
= key
, *scheme
= type
->psz_scheme
;
1146 return strncmp( uri
, scheme
, strlen( scheme
) );
1149 /* Guess the type of the item using the beginning of the mrl */
1150 static enum input_item_type_e
GuessType( const input_item_t
*p_item
, bool *p_net
)
1152 static const struct item_type_entry tab
[] =
1153 { /* /!\ Alphabetical order /!\ */
1154 /* Short match work, not just exact match */
1155 { "alsa", ITEM_TYPE_CARD
, false },
1156 { "atsc", ITEM_TYPE_CARD
, false },
1157 { "bd", ITEM_TYPE_DISC
, false },
1158 { "bluray", ITEM_TYPE_DISC
, false },
1159 { "cable", ITEM_TYPE_CARD
, false },
1160 { "cdda", ITEM_TYPE_DISC
, false },
1161 { "cqam", ITEM_TYPE_CARD
, false },
1162 { "dc1394", ITEM_TYPE_CARD
, false },
1163 { "dccp", ITEM_TYPE_STREAM
, true },
1164 { "deckli", ITEM_TYPE_CARD
, false }, /* decklink */
1165 { "dir", ITEM_TYPE_DIRECTORY
, false },
1166 { "dshow", ITEM_TYPE_CARD
, false },
1167 { "dtv", ITEM_TYPE_CARD
, false },
1168 { "dvb", ITEM_TYPE_CARD
, false },
1169 { "dvd", ITEM_TYPE_DISC
, false },
1170 { "eyetv", ITEM_TYPE_CARD
, false },
1171 { "fd", ITEM_TYPE_UNKNOWN
, false },
1172 { "file", ITEM_TYPE_FILE
, false },
1173 { "ftp", ITEM_TYPE_FILE
, true },
1174 { "http", ITEM_TYPE_FILE
, true },
1175 { "icyx", ITEM_TYPE_STREAM
, true },
1176 { "imem", ITEM_TYPE_UNKNOWN
, false },
1177 { "isdb-", ITEM_TYPE_CARD
, false },
1178 { "itpc", ITEM_TYPE_PLAYLIST
, true },
1179 { "jack", ITEM_TYPE_CARD
, false },
1180 { "linsys", ITEM_TYPE_CARD
, false },
1181 { "live", ITEM_TYPE_STREAM
, true }, /* livedotcom */
1182 { "mms", ITEM_TYPE_STREAM
, true },
1183 { "mtp", ITEM_TYPE_DISC
, false },
1184 { "nfs", ITEM_TYPE_FILE
, true },
1185 { "ofdm", ITEM_TYPE_CARD
, false },
1186 { "oss", ITEM_TYPE_CARD
, false },
1187 { "pnm", ITEM_TYPE_STREAM
, true },
1188 { "pulse", ITEM_TYPE_CARD
, false },
1189 { "qam", ITEM_TYPE_CARD
, false },
1190 { "qpsk", ITEM_TYPE_CARD
, false },
1191 { "qtcapt", ITEM_TYPE_CARD
, false }, /* qtcapture */
1192 { "qtsound",ITEM_TYPE_CARD
, false },
1193 { "raw139", ITEM_TYPE_CARD
, false }, /* raw1394 */
1194 { "rt", ITEM_TYPE_STREAM
, true }, /* rtp, rtsp, rtmp */
1195 { "satell", ITEM_TYPE_CARD
, false }, /* satellite */
1196 { "satip", ITEM_TYPE_STREAM
, true }, /* satellite over ip */
1197 { "screen", ITEM_TYPE_CARD
, false },
1198 { "sdp", ITEM_TYPE_STREAM
, true },
1199 { "sftp", ITEM_TYPE_FILE
, true },
1200 { "shm", ITEM_TYPE_CARD
, false },
1201 { "smb", ITEM_TYPE_FILE
, true },
1202 { "stream", ITEM_TYPE_STREAM
, false },
1203 { "svcd", ITEM_TYPE_DISC
, false },
1204 { "tcp", ITEM_TYPE_STREAM
, true },
1205 { "terres", ITEM_TYPE_CARD
, false }, /* terrestrial */
1206 { "udp", ITEM_TYPE_STREAM
, true }, /* udplite too */
1207 { "unsv", ITEM_TYPE_STREAM
, true },
1208 { "upnp", ITEM_TYPE_FILE
, true },
1209 { "usdigi", ITEM_TYPE_CARD
, false }, /* usdigital */
1210 { "v4l", ITEM_TYPE_CARD
, false },
1211 { "vcd", ITEM_TYPE_DISC
, false },
1212 { "vdr", ITEM_TYPE_STREAM
, true },
1213 { "wasapi", ITEM_TYPE_CARD
, false },
1214 { "window", ITEM_TYPE_CARD
, false },
1218 for( size_t i
= 1; i
< ARRAY_SIZE( tab
); i
++ )
1219 assert( typecmp( (tab
+ i
)->psz_scheme
, tab
+ i
- 1 ) > 0 );
1224 if( strstr( p_item
->psz_uri
, "://" ) == NULL
)
1225 return ITEM_TYPE_UNKNOWN
; /* invalid URI */
1227 const struct item_type_entry
*e
=
1228 bsearch( p_item
->psz_uri
, tab
, ARRAY_SIZE( tab
),
1229 sizeof( tab
[0] ), typecmp
);
1231 return ITEM_TYPE_UNKNOWN
;
1237 input_item_node_t
*input_item_node_Create( input_item_t
*p_input
)
1239 input_item_node_t
* p_node
= malloc( sizeof( input_item_node_t
) );
1245 p_node
->p_item
= p_input
;
1246 input_item_Hold( p_input
);
1248 p_node
->i_children
= 0;
1249 p_node
->pp_children
= NULL
;
1254 void input_item_node_Delete( input_item_node_t
*p_node
)
1256 for( int i
= 0; i
< p_node
->i_children
; i
++ )
1257 input_item_node_Delete( p_node
->pp_children
[i
] );
1259 input_item_Release( p_node
->p_item
);
1260 free( p_node
->pp_children
);
1264 input_item_node_t
*input_item_node_AppendItem( input_item_node_t
*p_node
, input_item_t
*p_item
)
1266 int i_preparse_depth
;
1267 input_item_node_t
*p_new_child
= input_item_node_Create( p_item
);
1268 if( !p_new_child
) return NULL
;
1270 vlc_mutex_lock( &p_node
->p_item
->lock
);
1271 i_preparse_depth
= p_node
->p_item
->i_preparse_depth
;
1272 vlc_mutex_unlock( &p_node
->p_item
->lock
);
1274 vlc_mutex_lock( &p_item
->lock
);
1275 p_item
->i_preparse_depth
= i_preparse_depth
> 0 ?
1276 i_preparse_depth
-1 :
1278 vlc_mutex_unlock( &p_item
->lock
);
1280 input_item_node_AppendNode( p_node
, p_new_child
);
1284 void input_item_node_AppendNode( input_item_node_t
*p_parent
,
1285 input_item_node_t
*p_child
)
1287 assert(p_parent
!= NULL
);
1288 assert(p_child
!= NULL
);
1289 TAB_APPEND(p_parent
->i_children
, p_parent
->pp_children
, p_child
);
1292 void input_item_node_RemoveNode( input_item_node_t
*parent
,
1293 input_item_node_t
*child
)
1295 TAB_REMOVE(parent
->i_children
, parent
->pp_children
, child
);
1298 /* Called by es_out when a new Elementary Stream is added or updated. */
1299 void input_item_UpdateTracksInfo(input_item_t
*item
, const es_format_t
*fmt
)
1302 es_format_t
*fmt_copy
= malloc(sizeof *fmt_copy
);
1306 es_format_Copy(fmt_copy
, fmt
);
1308 vlc_mutex_lock( &item
->lock
);
1310 for( i
= 0; i
< item
->i_es
; i
++ )
1312 if (item
->es
[i
]->i_id
!= fmt
->i_id
)
1315 /* We've found the right ES, replace it */
1316 es_format_Clean(item
->es
[i
]);
1318 item
->es
[i
] = fmt_copy
;
1319 vlc_mutex_unlock( &item
->lock
);
1323 /* ES not found, insert it */
1324 TAB_APPEND(item
->i_es
, item
->es
, fmt_copy
);
1325 vlc_mutex_unlock( &item
->lock
);
1328 static int rdh_compar_type(input_item_t
*p1
, input_item_t
*p2
)
1330 if (p1
->i_type
!= p2
->i_type
)
1332 if (p1
->i_type
== ITEM_TYPE_DIRECTORY
)
1334 if (p2
->i_type
== ITEM_TYPE_DIRECTORY
)
1340 static int rdh_compar_filename(const void *a
, const void *b
)
1342 input_item_node_t
*const *na
= a
, *const *nb
= b
;
1343 input_item_t
*ia
= (*na
)->p_item
, *ib
= (*nb
)->p_item
;
1345 int i_ret
= rdh_compar_type(ia
, ib
);
1349 return vlc_filenamecmp(ia
->psz_name
, ib
->psz_name
);
1352 static void rdh_sort(input_item_node_t
*p_node
)
1354 if (p_node
->i_children
<= 0)
1357 /* Sort current node */
1358 qsort(p_node
->pp_children
, p_node
->i_children
,
1359 sizeof(input_item_node_t
*), rdh_compar_filename
);
1361 /* Sort all children */
1362 for (int i
= 0; i
< p_node
->i_children
; i
++)
1363 rdh_sort(p_node
->pp_children
[i
]);
1367 * Does the provided file name has one of the extension provided ?
1369 static bool rdh_file_has_ext(const char *psz_filename
,
1370 const char *psz_ignored_exts
)
1372 if (psz_ignored_exts
== NULL
)
1375 const char *ext
= strrchr(psz_filename
, '.');
1379 size_t extlen
= strlen(++ext
);
1381 for (const char *type
= psz_ignored_exts
, *end
; type
[0]; type
= end
+ 1)
1383 end
= strchr(type
, ',');
1385 end
= type
+ strlen(type
);
1387 if (type
+ extlen
== end
&& !strncasecmp(ext
, type
, extlen
))
1397 static bool rdh_file_is_ignored(struct vlc_readdir_helper
*p_rdh
,
1398 const char *psz_filename
)
1400 return (psz_filename
[0] == '\0'
1401 || strcmp(psz_filename
, ".") == 0
1402 || strcmp(psz_filename
, "..") == 0
1403 || (!p_rdh
->b_show_hiddenfiles
&& psz_filename
[0] == '.')
1404 || rdh_file_has_ext(psz_filename
, p_rdh
->psz_ignored_exts
));
1409 input_item_slave_t
*p_slave
;
1411 input_item_node_t
*p_node
;
1416 input_item_node_t
*p_node
;
1420 static char *rdh_name_from_filename(const char *psz_filename
)
1422 /* remove leading white spaces */
1423 while (*psz_filename
!= '\0' && *psz_filename
== ' ')
1426 char *psz_name
= strdup(psz_filename
);
1430 /* remove extension */
1431 char *psz_ptr
= strrchr(psz_name
, '.');
1432 if (psz_ptr
&& psz_ptr
!= psz_name
)
1435 /* remove trailing white spaces */
1436 int i
= strlen(psz_name
) - 1;
1437 while (psz_name
[i
] == ' ' && i
>= 0)
1438 psz_name
[i
--] = '\0';
1440 /* convert to lower case */
1442 while (*psz_ptr
!= '\0')
1444 *psz_ptr
= tolower(*psz_ptr
);
1451 static uint8_t rdh_get_slave_priority(input_item_t
*p_item
,
1452 input_item_slave_t
*p_slave
,
1453 const char *psz_slave_filename
)
1455 uint8_t i_priority
= SLAVE_PRIORITY_MATCH_NONE
;
1456 char *psz_item_name
= rdh_name_from_filename(p_item
->psz_name
);
1457 char *psz_slave_name
= rdh_name_from_filename(psz_slave_filename
);
1459 if (!psz_item_name
|| !psz_slave_name
)
1462 size_t i_item_len
= strlen(psz_item_name
);
1463 size_t i_slave_len
= strlen(psz_slave_name
);
1465 /* The slave name len should not be twice longer than the item name len. */
1466 if (i_item_len
> i_slave_len
|| i_slave_len
> 2 * i_item_len
)
1469 /* check if the names match exactly */
1470 if (!strcmp(psz_item_name
, psz_slave_name
))
1472 i_priority
= SLAVE_PRIORITY_MATCH_ALL
;
1476 /* "cdg" slaves have to be a full match */
1477 if (p_slave
->i_type
== SLAVE_TYPE_SPU
)
1479 char *psz_ext
= strrchr(psz_slave_name
, '.');
1480 if (psz_ext
!= NULL
&& strcasecmp(++psz_ext
, "cdg") == 0)
1484 /* check if the item name is a substring of the slave name */
1485 const char *psz_sub
= strstr(psz_slave_name
, psz_item_name
);
1489 /* check if the item name was found at the end of the slave name */
1490 if (strlen(psz_sub
+ strlen(psz_item_name
)) == 0)
1492 i_priority
= SLAVE_PRIORITY_MATCH_RIGHT
;
1497 i_priority
= SLAVE_PRIORITY_MATCH_LEFT
;
1503 free(psz_item_name
);
1504 free(psz_slave_name
);
1508 static int rdh_should_match_idx(struct vlc_readdir_helper
*p_rdh
,
1509 struct rdh_slave
*p_rdh_sub
)
1511 char *psz_ext
= strrchr(p_rdh_sub
->psz_filename
, '.');
1516 if (strcasecmp(psz_ext
, "sub") != 0)
1519 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1521 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1523 if (p_rdh_slave
== NULL
|| p_rdh_slave
== p_rdh_sub
)
1526 /* check that priorities match */
1527 if (p_rdh_slave
->p_slave
->i_priority
!=
1528 p_rdh_sub
->p_slave
->i_priority
)
1531 /* check that the filenames without extension match */
1532 if (strncasecmp(p_rdh_sub
->psz_filename
, p_rdh_slave
->psz_filename
,
1533 strlen(p_rdh_sub
->psz_filename
) - 3 ) != 0)
1536 /* check that we have an idx file */
1537 char *psz_ext_idx
= strrchr(p_rdh_slave
->psz_filename
, '.');
1538 if (psz_ext_idx
== NULL
)
1541 if (strcasecmp(psz_ext_idx
, "idx" ) == 0)
1547 static void rdh_attach_slaves(struct vlc_readdir_helper
*p_rdh
,
1548 input_item_node_t
*p_parent_node
)
1550 if (p_rdh
->i_sub_autodetect_fuzzy
== 0)
1553 /* Try to match slaves for each items of the node */
1554 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1556 input_item_node_t
*p_node
= p_parent_node
->pp_children
[i
];
1557 input_item_t
*p_item
= p_node
->p_item
;
1559 enum slave_type unused
;
1560 if (!input_item_IsMaster(p_item
->psz_name
)
1561 || input_item_slave_GetType(p_item
->psz_name
, &unused
))
1562 continue; /* don't match 2 possible slaves between each others */
1564 for (size_t j
= 0; j
< p_rdh
->i_slaves
; j
++)
1566 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[j
];
1568 /* Don't try to match slaves with themselves or slaves already
1569 * attached with the higher priority */
1570 if (p_rdh_slave
->p_node
== p_node
1571 || p_rdh_slave
->p_slave
->i_priority
== SLAVE_PRIORITY_MATCH_ALL
)
1574 uint8_t i_priority
=
1575 rdh_get_slave_priority(p_item
, p_rdh_slave
->p_slave
,
1576 p_rdh_slave
->psz_filename
);
1578 if (i_priority
< p_rdh
->i_sub_autodetect_fuzzy
)
1581 /* Drop the ".sub" slave if a ".idx" slave matches */
1582 if (p_rdh_slave
->p_slave
->i_type
== SLAVE_TYPE_SPU
1583 && rdh_should_match_idx(p_rdh
, p_rdh_slave
))
1586 input_item_slave_t
*p_slave
=
1587 input_item_slave_New(p_rdh_slave
->p_slave
->psz_uri
,
1588 p_rdh_slave
->p_slave
->i_type
,
1590 if (p_slave
== NULL
)
1593 if (input_item_AddSlave(p_item
, p_slave
) != VLC_SUCCESS
)
1595 input_item_slave_Delete(p_slave
);
1599 /* Remove the corresponding node if any: This slave won't be
1600 * added in the parent node */
1601 if (p_rdh_slave
->p_node
!= NULL
)
1603 input_item_node_RemoveNode(p_parent_node
, p_rdh_slave
->p_node
);
1604 input_item_node_Delete(p_rdh_slave
->p_node
);
1605 p_rdh_slave
->p_node
= NULL
;
1608 p_rdh_slave
->p_slave
->i_priority
= i_priority
;
1612 /* Attach all children */
1613 for (int i
= 0; i
< p_parent_node
->i_children
; i
++)
1614 rdh_attach_slaves(p_rdh
, p_parent_node
->pp_children
[i
]);
1617 static int rdh_unflatten(struct vlc_readdir_helper
*p_rdh
,
1618 input_item_node_t
**pp_node
, const char *psz_path
,
1621 /* Create an input input for each sub folders that is contained in the full
1622 * path. Update pp_node to point to the direct parent of the future item to
1625 assert(psz_path
!= NULL
);
1626 const char *psz_subpaths
= psz_path
;
1628 while ((psz_subpaths
= strchr(psz_subpaths
, '/')))
1630 input_item_node_t
*p_subnode
= NULL
;
1632 /* Check if this sub folder item was already added */
1633 for (size_t i
= 0; i
< p_rdh
->i_dirs
&& p_subnode
== NULL
; i
++)
1635 struct rdh_dir
*rdh_dir
= p_rdh
->pp_dirs
[i
];
1636 if (!strncmp(rdh_dir
->psz_path
, psz_path
, psz_subpaths
- psz_path
))
1637 p_subnode
= rdh_dir
->p_node
;
1640 /* The sub folder item doesn't exist, so create it */
1641 if (p_subnode
== NULL
)
1643 size_t i_sub_path_len
= psz_subpaths
- psz_path
;
1644 struct rdh_dir
*p_rdh_dir
=
1645 malloc(sizeof(struct rdh_dir
) + 1 + i_sub_path_len
);
1646 if (p_rdh_dir
== NULL
)
1648 strncpy(p_rdh_dir
->psz_path
, psz_path
, i_sub_path_len
);
1649 p_rdh_dir
->psz_path
[i_sub_path_len
] = 0;
1651 const char *psz_subpathname
= strrchr(p_rdh_dir
->psz_path
, '/');
1652 if (psz_subpathname
!= NULL
)
1655 psz_subpathname
= p_rdh_dir
->psz_path
;
1657 input_item_t
*p_item
=
1658 input_item_NewExt(INPUT_ITEM_URI_NOP
, psz_subpathname
, INPUT_DURATION_UNSET
,
1659 ITEM_TYPE_DIRECTORY
, i_net
);
1665 input_item_CopyOptions(p_item
, (*pp_node
)->p_item
);
1666 *pp_node
= input_item_node_AppendItem(*pp_node
, p_item
);
1667 input_item_Release(p_item
);
1668 if (*pp_node
== NULL
)
1673 p_rdh_dir
->p_node
= *pp_node
;
1674 TAB_APPEND(p_rdh
->i_dirs
, p_rdh
->pp_dirs
, p_rdh_dir
);
1677 *pp_node
= p_subnode
;
1683 #undef vlc_readdir_helper_init
1684 void vlc_readdir_helper_init(struct vlc_readdir_helper
*p_rdh
,
1685 vlc_object_t
*p_obj
, input_item_node_t
*p_node
)
1687 /* Read options from the parent item. This allows vlc_stream_ReadDir()
1688 * users to specify options whitout touhing any vlc_object_t. Apply options
1689 * on a temporary object in order to not apply options (that can be
1690 * insecure) to the current object. */
1691 vlc_object_t
*p_var_obj
= vlc_object_create(p_obj
, sizeof(vlc_object_t
));
1692 if (p_var_obj
!= NULL
)
1694 input_item_ApplyOptions(p_var_obj
, p_node
->p_item
);
1698 p_rdh
->p_node
= p_node
;
1699 p_rdh
->b_show_hiddenfiles
= var_InheritBool(p_obj
, "show-hiddenfiles");
1700 p_rdh
->psz_ignored_exts
= var_InheritString(p_obj
, "ignore-filetypes");
1701 bool b_autodetect
= var_InheritBool(p_obj
, "sub-autodetect-file");
1702 p_rdh
->i_sub_autodetect_fuzzy
= !b_autodetect
? 0 :
1703 var_InheritInteger(p_obj
, "sub-autodetect-fuzzy");
1704 p_rdh
->b_flatten
= var_InheritBool(p_obj
, "extractor-flatten");
1705 TAB_INIT(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1706 TAB_INIT(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1708 if (p_var_obj
!= NULL
)
1709 vlc_object_release(p_var_obj
);
1712 void vlc_readdir_helper_finish(struct vlc_readdir_helper
*p_rdh
, bool b_success
)
1716 rdh_attach_slaves(p_rdh
, p_rdh
->p_node
);
1717 rdh_sort(p_rdh
->p_node
);
1719 free(p_rdh
->psz_ignored_exts
);
1721 /* Remove unmatched slaves */
1722 for (size_t i
= 0; i
< p_rdh
->i_slaves
; i
++)
1724 struct rdh_slave
*p_rdh_slave
= p_rdh
->pp_slaves
[i
];
1725 if (p_rdh_slave
!= NULL
)
1727 input_item_slave_Delete(p_rdh_slave
->p_slave
);
1728 free(p_rdh_slave
->psz_filename
);
1732 TAB_CLEAN(p_rdh
->i_slaves
, p_rdh
->pp_slaves
);
1734 for (size_t i
= 0; i
< p_rdh
->i_dirs
; i
++)
1735 free(p_rdh
->pp_dirs
[i
]);
1736 TAB_CLEAN(p_rdh
->i_dirs
, p_rdh
->pp_dirs
);
1739 int vlc_readdir_helper_additem(struct vlc_readdir_helper
*p_rdh
,
1740 const char *psz_uri
, const char *psz_flatpath
,
1741 const char *psz_filename
, int i_type
, int i_net
)
1743 enum slave_type i_slave_type
;
1744 struct rdh_slave
*p_rdh_slave
= NULL
;
1745 assert(psz_flatpath
|| psz_filename
);
1747 if (!p_rdh
->b_flatten
)
1749 if (psz_filename
== NULL
)
1751 psz_filename
= strrchr(psz_flatpath
, '/');
1752 if (psz_filename
!= NULL
)
1755 psz_filename
= psz_flatpath
;
1760 if (psz_filename
== NULL
)
1761 psz_filename
= psz_flatpath
;
1762 psz_flatpath
= NULL
;
1765 if (p_rdh
->i_sub_autodetect_fuzzy
!= 0
1766 && input_item_slave_GetType(psz_filename
, &i_slave_type
))
1768 p_rdh_slave
= malloc(sizeof(*p_rdh_slave
));
1772 p_rdh_slave
->p_node
= NULL
;
1773 p_rdh_slave
->psz_filename
= strdup(psz_filename
);
1774 p_rdh_slave
->p_slave
= input_item_slave_New(psz_uri
, i_slave_type
,
1775 SLAVE_PRIORITY_MATCH_NONE
);
1776 if (!p_rdh_slave
->p_slave
|| !p_rdh_slave
->psz_filename
)
1778 free(p_rdh_slave
->psz_filename
);
1783 TAB_APPEND(p_rdh
->i_slaves
, p_rdh
->pp_slaves
, p_rdh_slave
);
1786 if (rdh_file_is_ignored(p_rdh
, psz_filename
))
1789 input_item_node_t
*p_node
= p_rdh
->p_node
;
1791 if (psz_flatpath
!= NULL
)
1793 int i_ret
= rdh_unflatten(p_rdh
, &p_node
, psz_flatpath
, i_net
);
1794 if (i_ret
!= VLC_SUCCESS
)
1798 input_item_t
*p_item
= input_item_NewExt(psz_uri
, psz_filename
, INPUT_DURATION_UNSET
, i_type
,
1803 input_item_CopyOptions(p_item
, p_node
->p_item
);
1804 p_node
= input_item_node_AppendItem(p_node
, p_item
);
1805 input_item_Release(p_item
);
1809 /* A slave can also be an item. If there is a match, this item will be
1810 * removed from the parent node. This is not a common case, since most
1811 * slaves will be ignored by rdh_file_is_ignored() */
1812 if (p_rdh_slave
!= NULL
)
1813 p_rdh_slave
->p_node
= p_node
;