item.c 40.3 KB
Newer Older
1 2 3
/*****************************************************************************
 * item.c: input_item management
 *****************************************************************************
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
4
 * Copyright (C) 1998-2004 VLC authors and VideoLAN
5 6 7 8
 * $Id$
 *
 * Authors: Clément Stenac <zorglub@videolan.org>
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
9 10 11
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
12 13 14 15
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
16 17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
18
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
19 20 21
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 23
 *****************************************************************************/

24 25 26
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
27
#include <assert.h>
28
#include <time.h>
29
#include <limits.h>
30

31
#include <vlc_common.h>
32
#include <vlc_url.h>
33
#include <vlc_interface.h>
34
#include <vlc_charset.h>
35

36
#include "item.h"
37
#include "info.h"
38

39 40 41 42 43 44 45
struct input_item_opaque
{
    struct input_item_opaque *next;
    void *value;
    char name[1];
};

46
static int GuessType( const input_item_t *p_item, bool *p_net );
47

48 49 50 51 52 53 54 55 56 57
void input_item_SetErrorWhenReading( input_item_t *p_i, bool b_error )
{
    bool b_changed;

    vlc_mutex_lock( &p_i->lock );

    b_changed = p_i->b_error_when_reading != b_error;
    p_i->b_error_when_reading = b_error;

    vlc_mutex_unlock( &p_i->lock );
58

59 60
    if( b_changed )
    {
61 62 63
        vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
            .type = vlc_InputItemErrorWhenReadingChanged,
            .u.input_item_error_when_reading_changed.new_value = b_error } );
64 65
    }
}
66
void input_item_SignalPreparseEnded( input_item_t *p_i, int status )
67
{
68 69 70
    vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
        .type = vlc_InputItemPreparseEnded,
        .u.input_item_preparse_ended.new_status = status } );
71 72
}

73
void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
74
{
75
    bool b_send_event = false;
76

77
    vlc_mutex_lock( &p_i->lock );
78

79 80
    if( !p_i->p_meta )
        p_i->p_meta = vlc_meta_New();
81

82 83
    int status = vlc_meta_GetStatus(p_i->p_meta);
    int new_status;
84
    if( b_preparsed )
85
        new_status = status | ITEM_PREPARSED;
86
    else
87 88
        new_status = status & ~ITEM_PREPARSED;
    if( status != new_status )
89
    {
90
        vlc_meta_SetStatus(p_i->p_meta, new_status);
91 92 93 94 95 96 97
        b_send_event = true;
    }

    vlc_mutex_unlock( &p_i->lock );

    if( b_send_event )
    {
98 99 100
        vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
            .type = vlc_InputItemPreparsedChanged,
            .u.input_item_preparsed_changed.new_status = new_status } );
101 102
    }
}
103

104 105 106 107 108 109 110
void input_item_SetArtNotFound( input_item_t *p_i, bool b_not_found )
{
    vlc_mutex_lock( &p_i->lock );

    if( !p_i->p_meta )
        p_i->p_meta = vlc_meta_New();

111
    int status = vlc_meta_GetStatus(p_i->p_meta);
112

113
    if( b_not_found )
114
        status |= ITEM_ART_NOTFOUND;
115
    else
116
        status &= ~ITEM_ART_NOTFOUND;
117

118
    vlc_meta_SetStatus(p_i->p_meta, status);
119

120 121
    vlc_mutex_unlock( &p_i->lock );
}
122

123 124 125 126 127 128 129
void input_item_SetArtFetched( input_item_t *p_i, bool b_art_fetched )
{
    vlc_mutex_lock( &p_i->lock );

    if( !p_i->p_meta )
        p_i->p_meta = vlc_meta_New();

130
    int status = vlc_meta_GetStatus(p_i->p_meta);
131

132
    if( b_art_fetched )
133
        status |= ITEM_ART_FETCHED;
134
    else
135 136 137
        status &= ~ITEM_ART_FETCHED;

    vlc_meta_SetStatus(p_i->p_meta, status);
138 139

    vlc_mutex_unlock( &p_i->lock );
140 141
}

142 143 144 145 146 147 148 149 150
void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
{
    vlc_mutex_lock( &p_i->lock );
    if( !p_i->p_meta )
        p_i->p_meta = vlc_meta_New();
    vlc_meta_Set( p_i->p_meta, meta_type, psz_val );
    vlc_mutex_unlock( &p_i->lock );

    /* Notify interested third parties */
151 152 153
    vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
        .type = vlc_InputItemMetaChanged,
        .u.input_item_meta_changed.meta_type = meta_type } );
154 155
}

156 157
void input_item_CopyOptions( input_item_t *p_child,
                             input_item_t *p_parent )
158
{
159 160
    char **optv = NULL;
    uint8_t *flagv = NULL;
161 162 163
    int optc = 0;
    char **optv_realloc = NULL;
    uint8_t *flagv_realloc = NULL;
164

165 166
    vlc_mutex_lock( &p_parent->lock );

167
    if( p_parent->i_options > 0 )
168
    {
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
        optv = malloc( p_parent->i_options * sizeof (*optv) );
        if( likely(optv) )
            flagv = malloc( p_parent->i_options * sizeof (*flagv) );

        if( likely(flagv) )
        {
            for( int i = 0; i < p_parent->i_options; i++ )
            {
                char *psz_dup = strdup( p_parent->ppsz_options[i] );
                if( likely(psz_dup) )
                {
                    flagv[optc] = p_parent->optflagv[i];
                    optv[optc++] = psz_dup;
                }
            }
        }
185
    }
186

187
    vlc_mutex_unlock( &p_parent->lock );
188

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
    if( likely(optv && flagv && optc ) )
    {
        vlc_mutex_lock( &p_child->lock );

        if( INT_MAX - p_child->i_options >= optc &&
            SIZE_MAX / sizeof (*flagv) >= (size_t) (p_child->i_options + optc) )
            flagv_realloc = realloc( p_child->optflagv,
                                    (p_child->i_options + optc) * sizeof (*flagv) );
        if( likely(flagv_realloc) )
        {
            p_child->optflagv = flagv_realloc;
            if( SIZE_MAX / sizeof (*optv) >= (size_t) (p_child->i_options + optc) )
                optv_realloc = realloc( p_child->ppsz_options,
                                       (p_child->i_options + optc) * sizeof (*optv) );
            if( likely(optv_realloc) )
            {
                p_child->ppsz_options = optv_realloc;
                memcpy( p_child->ppsz_options + p_child->i_options, optv,
                        optc * sizeof (*optv) );
                memcpy( p_child->optflagv + p_child->i_options, flagv,
                        optc * sizeof (*flagv) );
                p_child->i_options += optc;
                p_child->optflagc += optc;
            }
        }

        vlc_mutex_unlock( &p_child->lock );
    }
217

218 219 220 221 222 223
    if( unlikely(!flagv_realloc || !optv_realloc) )
    {
        /* Didn't copy pointers, so need to free the strdup() */
        for( int i=0; i<optc; i++ )
            free( optv[i] );
    }
224 225 226

    free( flagv );
    free( optv );
227 228
}

229
static void post_subitems( input_item_node_t *p_node )
230
{
231 232
    for( int i = 0; i < p_node->i_children; i++ )
    {
233 234 235 236
        vlc_event_send( &p_node->p_item->event_manager, &(vlc_event_t) {
            .type = vlc_InputItemSubItemAdded,
            .u.input_item_subitem_added.p_new_child =
                p_node->pp_children[i]->p_item } );
237 238 239

        post_subitems( p_node->pp_children[i] );
    }
240 241
}

242 243
/* This won't hold the item, but can tell to interested third parties
 * Like the playlist, that there is a new sub item. With this design
244
 * It is not the input item's responsibility to keep all the ref of
245
 * the input item children. */
246
void input_item_PostSubItem( input_item_t *p_parent, input_item_t *p_child )
247
{
248 249
    input_item_node_t *p_node = input_item_node_Create( p_parent );
    input_item_node_AppendItem( p_node, p_child );
250
    input_item_node_PostAndDelete( p_node );
251 252
}

253
bool input_item_HasErrorWhenReading( input_item_t *p_item )
254
{
255 256 257 258 259 260 261
    vlc_mutex_lock( &p_item->lock );

    bool b_error = p_item->b_error_when_reading;

    vlc_mutex_unlock( &p_item->lock );

    return b_error;
262 263
}

264 265
bool input_item_MetaMatch( input_item_t *p_i,
                           vlc_meta_type_t meta_type, const char *psz )
266 267
{
    vlc_mutex_lock( &p_i->lock );
268

269 270 271 272 273
    if( !p_i->p_meta )
    {
        vlc_mutex_unlock( &p_i->lock );
        return false;
    }
274 275 276
    const char *psz_meta = vlc_meta_Get( p_i->p_meta, meta_type );
    bool b_ret = psz_meta && strcasestr( psz_meta, psz );

277 278
    vlc_mutex_unlock( &p_i->lock );

279
    return b_ret;
280 281
}

282
char *input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
283 284 285 286 287 288 289 290 291
{
    vlc_mutex_lock( &p_i->lock );

    if( !p_i->p_meta )
    {
        vlc_mutex_unlock( &p_i->lock );
        return NULL;
    }

292
    char *psz = NULL;
293 294 295 296 297 298 299
    if( vlc_meta_Get( p_i->p_meta, meta_type ) )
        psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );

    vlc_mutex_unlock( &p_i->lock );
    return psz;
}

300 301 302 303 304 305 306 307
/* Get the title of a given item or fallback to the name if the title is empty */
char *input_item_GetTitleFbName( input_item_t *p_item )
{
    char *psz_ret;
    vlc_mutex_lock( &p_item->lock );

    if( !p_item->p_meta )
    {
308
        psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
309
        vlc_mutex_unlock( &p_item->lock );
310
        return psz_ret;
311 312
    }

313 314 315
    const char *psz_title = vlc_meta_Get( p_item->p_meta, vlc_meta_Title );
    if( !EMPTY_STR( psz_title ) )
        psz_ret = strdup( psz_title );
316 317 318 319 320 321 322
    else
        psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;

    vlc_mutex_unlock( &p_item->lock );
    return psz_ret;
}

323
char *input_item_GetName( input_item_t *p_item )
324
{
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
    vlc_mutex_lock( &p_item->lock );

    char *psz_name = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;

    vlc_mutex_unlock( &p_item->lock );
    return psz_name;
}
void input_item_SetName( input_item_t *p_item, const char *psz_name )
{
    vlc_mutex_lock( &p_item->lock );

    free( p_item->psz_name );
    p_item->psz_name = strdup( psz_name );

    vlc_mutex_unlock( &p_item->lock );
340 341
}

342
char *input_item_GetURI( input_item_t *p_i )
343 344
{
    vlc_mutex_lock( &p_i->lock );
345

346
    char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
347

348 349 350
    vlc_mutex_unlock( &p_i->lock );
    return psz_s;
}
351

352
void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
353
{
354
    assert( psz_uri );
355
#ifndef NDEBUG
356 357 358 359
    if( !strstr( psz_uri, "://" )
     || strchr( psz_uri, ' ' ) || strchr( psz_uri, '"' ) )
        fprintf( stderr, "Warning: %s(\"%s\"): file path instead of URL.\n",
                 __func__, psz_uri );
360
#endif
361
    vlc_mutex_lock( &p_i->lock );
362 363
    free( p_i->psz_uri );
    p_i->psz_uri = strdup( psz_uri );
364

365
    p_i->i_type = GuessType( p_i, &p_i->b_net );
366

367 368 369 370
    if( p_i->psz_name )
        ;
    else
    if( p_i->i_type == ITEM_TYPE_FILE || p_i->i_type == ITEM_TYPE_DIRECTORY )
371
    {
372 373 374
        const char *psz_filename = strrchr( p_i->psz_uri, '/' );

        if( psz_filename && *psz_filename == '/' )
375 376 377
            psz_filename++;
        if( psz_filename && *psz_filename )
            p_i->psz_name = strdup( psz_filename );
378 379 380

        /* Make the name more readable */
        if( p_i->psz_name )
381
        {
382
            vlc_uri_decode( p_i->psz_name );
383 384
            EnsureUTF8( p_i->psz_name );
        }
385
    }
386 387
    else
    {   /* Strip login and password from title */
388
        int r;
389
        vlc_url_t url;
390

391
        vlc_UrlParse( &url, psz_uri );
392 393 394
        if( url.psz_protocol )
        {
            if( url.i_port > 0 )
395
                r=asprintf( &p_i->psz_name, "%s://%s:%d%s", url.psz_protocol,
396 397 398
                          url.psz_host, url.i_port,
                          url.psz_path ? url.psz_path : "" );
            else
399
                r=asprintf( &p_i->psz_name, "%s://%s%s", url.psz_protocol,
400 401 402 403 404 405
                          url.psz_host ? url.psz_host : "",
                          url.psz_path ? url.psz_path : "" );
        }
        else
        {
            if( url.i_port > 0 )
406
                r=asprintf( &p_i->psz_name, "%s:%d%s", url.psz_host, url.i_port,
407 408
                          url.psz_path ? url.psz_path : "" );
            else
409
                r=asprintf( &p_i->psz_name, "%s%s", url.psz_host,
410 411 412
                          url.psz_path ? url.psz_path : "" );
        }
        vlc_UrlClean( &url );
413 414
        if( -1==r )
            p_i->psz_name=NULL; /* recover from undefined value */
415
    }
416

417 418 419
    vlc_mutex_unlock( &p_i->lock );
}

420
mtime_t input_item_GetDuration( input_item_t *p_i )
421 422
{
    vlc_mutex_lock( &p_i->lock );
423

424
    mtime_t i_duration = p_i->i_duration;
425

426 427 428 429
    vlc_mutex_unlock( &p_i->lock );
    return i_duration;
}

430
void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
431
{
432
    bool b_send_event = false;
433 434 435 436 437

    vlc_mutex_lock( &p_i->lock );
    if( p_i->i_duration != i_duration )
    {
        p_i->i_duration = i_duration;
438
        b_send_event = true;
439 440 441
    }
    vlc_mutex_unlock( &p_i->lock );

442
    if( b_send_event )
443
    {
444 445 446
        vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
            .type = vlc_InputItemDurationChanged,
            .u.input_item_duration_changed.new_duration = i_duration } );
447 448 449
    }
}

450 451 452 453 454 455 456 457 458 459 460
char *input_item_GetNowPlayingFb( input_item_t *p_item )
{
    char *psz_meta = input_item_GetMeta( p_item, vlc_meta_NowPlaying );
    if( !psz_meta || strlen( psz_meta ) == 0 )
    {
        free( psz_meta );
        return input_item_GetMeta( p_item, vlc_meta_ESNowPlaying );
    }

    return psz_meta;
}
461

462
bool input_item_IsPreparsed( input_item_t *p_item )
463
{
464
    vlc_mutex_lock( &p_item->lock );
465
    bool b_preparsed = p_item->p_meta ? ( vlc_meta_GetStatus(p_item->p_meta) & ITEM_PREPARSED ) != 0 : false;
466
    vlc_mutex_unlock( &p_item->lock );
467

468
    return b_preparsed;
469 470
}

471
bool input_item_IsArtFetched( input_item_t *p_item )
472
{
473
    vlc_mutex_lock( &p_item->lock );
474
    bool b_fetched = p_item->p_meta ? ( vlc_meta_GetStatus(p_item->p_meta) & ITEM_ART_FETCHED ) != 0 : false;
475
    vlc_mutex_unlock( &p_item->lock );
476

477
    return b_fetched;
478 479
}

480 481 482 483 484 485 486 487 488 489 490
bool input_item_ShouldPreparseSubItems( input_item_t *p_item )
{
    bool b_ret;

    vlc_mutex_lock( &p_item->lock );
    b_ret = p_item->i_preparse_depth == -1 ? true : p_item->i_preparse_depth > 0;
    vlc_mutex_unlock( &p_item->lock );

    return b_ret;
}

491
input_item_t *input_item_Hold( input_item_t *p_item )
492
{
493
    input_item_owner_t *owner = item_owner(p_item);
494

495 496 497 498 499 500 501 502 503 504 505
    atomic_fetch_add( &owner->refs, 1 );
    return p_item;
}

void input_item_Release( input_item_t *p_item )
{
    input_item_owner_t *owner = item_owner(p_item);

    if( atomic_fetch_sub(&owner->refs, 1) != 1 )
        return;

506 507 508 509 510 511 512 513 514 515 516 517 518
    vlc_event_manager_fini( &p_item->event_manager );

    free( p_item->psz_name );
    free( p_item->psz_uri );
    if( p_item->p_stats != NULL )
    {
        vlc_mutex_destroy( &p_item->p_stats->lock );
        free( p_item->p_stats );
    }

    if( p_item->p_meta != NULL )
        vlc_meta_Delete( p_item->p_meta );

519 520 521 522 523 524
    for( input_item_opaque_t *o = p_item->opaques, *next; o != NULL; o = next )
    {
        next = o->next;
        free( o );
    }

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
    for( int i = 0; i < p_item->i_options; i++ )
        free( p_item->ppsz_options[i] );
    TAB_CLEAN( p_item->i_options, p_item->ppsz_options );
    free( p_item->optflagv );

    for( int i = 0; i < p_item->i_es; i++ )
    {
        es_format_Clean( p_item->es[i] );
        free( p_item->es[i] );
    }
    TAB_CLEAN( p_item->i_es, p_item->es );

    for( int i = 0; i < p_item->i_epg; i++ )
        vlc_epg_Delete( p_item->pp_epg[i] );
    TAB_CLEAN( p_item->i_epg, p_item->pp_epg );

    for( int i = 0; i < p_item->i_categories; i++ )
        info_category_Delete( p_item->pp_categories[i] );
    TAB_CLEAN( p_item->i_categories, p_item->pp_categories );

545 546 547 548
    for( int i = 0; i < p_item->i_slaves; i++ )
        input_item_slave_Delete( p_item->pp_slaves[i] );
    TAB_CLEAN( p_item->i_slaves, p_item->pp_slaves );

549 550
    vlc_mutex_destroy( &p_item->lock );
    free( owner );
551 552
}

553 554
int input_item_AddOption( input_item_t *p_input, const char *psz_option,
                          unsigned flags )
555
{
556 557
    int err = VLC_SUCCESS;

558
    if( psz_option == NULL )
559
        return VLC_EGENERIC;
560 561

    vlc_mutex_lock( &p_input->lock );
562
    if (flags & VLC_INPUT_OPTION_UNIQUE)
563
    {
564 565 566
        for (int i = 0 ; i < p_input->i_options; i++)
            if( !strcmp( p_input->ppsz_options[i], psz_option ) )
                goto out;
567 568
    }

569 570 571 572 573 574 575 576 577
    uint8_t *flagv = realloc (p_input->optflagv, p_input->optflagc + 1);
    if (flagv == NULL)
    {
        err = VLC_ENOMEM;
        goto out;
    }
    p_input->optflagv = flagv;
    flagv[p_input->optflagc++] = flags;

578 579 580 581
    INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
                 p_input->i_options, strdup( psz_option ) );
out:
    vlc_mutex_unlock( &p_input->lock );
582
    return err;
583
}
584

585 586 587 588 589 590 591 592 593 594
int input_item_AddOptions( input_item_t *p_item, int i_options,
                           const char *const *ppsz_options,
                           unsigned i_flags )
{
    int i_ret = VLC_SUCCESS;
    for( int i = 0; i < i_options && i_ret == VLC_SUCCESS; i++ )
        i_ret = input_item_AddOption( p_item, ppsz_options[i], i_flags );
    return i_ret;
}

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
int input_item_AddOpaque(input_item_t *item, const char *name, void *value)
{
    assert(name != NULL);

    size_t namelen = strlen(name);
    input_item_opaque_t *entry = malloc(sizeof (*entry) + namelen);
    if (unlikely(entry == NULL))
        return VLC_ENOMEM;

    memcpy(entry->name, name, namelen + 1);
    entry->value = value;

    vlc_mutex_lock(&item->lock);
    entry->next = item->opaques;
    item->opaques = entry;
    vlc_mutex_unlock(&item->lock);
    return VLC_SUCCESS;
}

614 615 616 617 618 619 620 621
void input_item_ApplyOptions(vlc_object_t *obj, input_item_t *item)
{
    vlc_mutex_lock(&item->lock);
    assert(item->optflagc == (unsigned)item->i_options);

    for (unsigned i = 0; i < (unsigned)item->i_options; i++)
        var_OptionParse(obj, item->ppsz_options[i],
                        !!(item->optflagv[i] & VLC_INPUT_OPTION_TRUSTED));
622 623 624 625 626 627 628

    for (const input_item_opaque_t *o = item->opaques; o != NULL; o = o->next)
    {
        var_Create(obj, o->name, VLC_VAR_ADDRESS);
        var_SetAddress(obj, o->name, o->value);
    }

629 630 631
    vlc_mutex_unlock(&item->lock);
}

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
bool input_item_slave_GetType(const char *psz_filename,
                              enum slave_type *p_slave_type)
{
    static const char *const ppsz_sub_exts[] = { SLAVE_SPU_EXTENSIONS, NULL };
    static const char *const ppsz_audio_exts[] = { SLAVE_AUDIO_EXTENSIONS, NULL };

    static struct {
        enum slave_type i_type;
        const char *const *ppsz_exts;
    } p_slave_list[] = {
        { SLAVE_TYPE_SPU, ppsz_sub_exts },
        { SLAVE_TYPE_AUDIO, ppsz_audio_exts },
    };

    const char *psz_ext = strrchr(psz_filename, '.');
    if (psz_ext == NULL || *(++psz_ext) == '\0')
        return false;

    for (unsigned int i = 0; i < sizeof(p_slave_list) / sizeof(*p_slave_list); ++i)
    {
        for (const char *const *ppsz_slave_ext = p_slave_list[i].ppsz_exts;
             *ppsz_slave_ext != NULL; ppsz_slave_ext++)
        {
            if (!strcasecmp(psz_ext, *ppsz_slave_ext))
            {
                *p_slave_type = p_slave_list[i].i_type;
                return true;
            }
        }
    }
    return false;
}

input_item_slave_t *input_item_slave_New(const char *psz_uri, enum slave_type i_type,
                                       enum slave_priority i_priority)
{
    if( !psz_uri )
        return NULL;

    input_item_slave_t *p_slave = malloc( sizeof( *p_slave ) + strlen( psz_uri ) + 1 );
    if( !p_slave )
        return NULL;

    p_slave->i_type = i_type;
    p_slave->i_priority = i_priority;
677
    p_slave->b_forced = false;
678 679 680 681 682 683 684
    strcpy( p_slave->psz_uri, psz_uri );

    return p_slave;
}

int input_item_AddSlave(input_item_t *p_item, input_item_slave_t *p_slave)
{
685 686
    if( p_item == NULL || p_slave == NULL
     || p_slave->i_priority < SLAVE_PRIORITY_MATCH_NONE )
687 688 689 690 691 692 693 694 695 696
        return VLC_EGENERIC;

    vlc_mutex_lock( &p_item->lock );

    INSERT_ELEM( p_item->pp_slaves, p_item->i_slaves, p_item->i_slaves, p_slave );

    vlc_mutex_unlock( &p_item->lock );
    return VLC_SUCCESS;
}

697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
static info_category_t *InputItemFindCat( input_item_t *p_item,
                                          int *pi_index, const char *psz_cat )
{
    vlc_assert_locked( &p_item->lock );
    for( int i = 0; i < p_item->i_categories && psz_cat; i++ )
    {
        info_category_t *p_cat = p_item->pp_categories[i];

        if( !strcmp( p_cat->psz_name, psz_cat ) )
        {
            if( pi_index )
                *pi_index = i;
            return p_cat;
        }
    }
    return NULL;
}

715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
/**
 * Get a info item from a given category in a given input item.
 *
 * \param p_i The input item to get info from
 * \param psz_cat String representing the category for the info
 * \param psz_name String representing the name of the desired info
 * \return A pointer to the string with the given info if found, or an
 *         empty string otherwise. The caller should free the returned
 *         pointer.
 */
char *input_item_GetInfo( input_item_t *p_i,
                          const char *psz_cat,
                          const char *psz_name )
{
    vlc_mutex_lock( &p_i->lock );

731 732
    const info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
    if( p_cat )
733
    {
734 735
        info_t *p_info = info_category_FindInfo( p_cat, NULL, psz_name );
        if( p_info && p_info->psz_value )
736
        {
737 738 739
            char *psz_ret = strdup( p_info->psz_value );
            vlc_mutex_unlock( &p_i->lock );
            return psz_ret;
740 741 742 743 744 745 746 747 748 749
        }
    }
    vlc_mutex_unlock( &p_i->lock );
    return strdup( "" );
}

static int InputItemVaAddInfo( input_item_t *p_i,
                               const char *psz_cat,
                               const char *psz_name,
                               const char *psz_format, va_list args )
750
{
751
    vlc_assert_locked( &p_i->lock );
752

753
    info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
754 755
    if( !p_cat )
    {
756 757
        p_cat = info_category_New( psz_cat );
        if( !p_cat )
758
            return VLC_ENOMEM;
759 760 761
        INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
                     p_cat );
    }
762 763 764 765
    info_t *p_info = info_category_VaAddInfo( p_cat, psz_name, psz_format, args );
    if( !p_info || !p_info->psz_value )
        return VLC_EGENERIC;
    return VLC_SUCCESS;
766 767 768 769 770 771 772 773 774 775 776 777 778
}

int input_item_AddInfo( input_item_t *p_i,
                        const char *psz_cat,
                        const char *psz_name,
                        const char *psz_format, ... )
{
    va_list args;

    vlc_mutex_lock( &p_i->lock );

    va_start( args, psz_format );
    const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
779 780 781 782
    va_end( args );

    vlc_mutex_unlock( &p_i->lock );

783 784

    if( !i_ret )
785 786
        vlc_event_send( &p_i->event_manager, &(vlc_event_t) {
            .type = vlc_InputItemInfoChanged } );
787

788
    return i_ret;
789
}
790

791 792 793 794 795
int input_item_DelInfo( input_item_t *p_i,
                        const char *psz_cat,
                        const char *psz_name )
{
    vlc_mutex_lock( &p_i->lock );
796 797 798
    int i_cat;
    info_category_t *p_cat = InputItemFindCat( p_i, &i_cat, psz_cat );
    if( !p_cat )
799 800 801 802 803 804 805 806
    {
        vlc_mutex_unlock( &p_i->lock );
        return VLC_EGENERIC;
    }

    if( psz_name )
    {
        /* Remove a specific info */
807 808
        int i_ret = info_category_DeleteInfo( p_cat, psz_name );
        if( i_ret )
809 810 811 812 813 814 815 816
        {
            vlc_mutex_unlock( &p_i->lock );
            return VLC_EGENERIC;
        }
    }
    else
    {
        /* Remove the complete categorie */
817
        info_category_Delete( p_cat );
818 819 820 821
        REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
    }
    vlc_mutex_unlock( &p_i->lock );

822 823
    vlc_event_send( &p_i->event_manager,
                    &(vlc_event_t) { .type = vlc_InputItemInfoChanged } );
824 825 826

    return VLC_SUCCESS;
}
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
void input_item_ReplaceInfos( input_item_t *p_item, info_category_t *p_cat )
{
    vlc_mutex_lock( &p_item->lock );
    int i_cat;
    info_category_t *p_old = InputItemFindCat( p_item, &i_cat, p_cat->psz_name );
    if( p_old )
    {
        info_category_Delete( p_old );
        p_item->pp_categories[i_cat] = p_cat;
    }
    else
    {
        INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
                     p_cat );
    }
    vlc_mutex_unlock( &p_item->lock );

844 845
    vlc_event_send( &p_item->event_manager,
                    &(vlc_event_t) { .type = vlc_InputItemInfoChanged } );
846
}
847

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
void input_item_MergeInfos( input_item_t *p_item, info_category_t *p_cat )
{
    vlc_mutex_lock( &p_item->lock );
    info_category_t *p_old = InputItemFindCat( p_item, NULL, p_cat->psz_name );
    if( p_old )
    {
        for( int i = 0; i < p_cat->i_infos; i++ )
            info_category_ReplaceInfo( p_old, p_cat->pp_infos[i] );
        TAB_CLEAN( p_cat->i_infos, p_cat->pp_infos );
        info_category_Delete( p_cat );
    }
    else
    {
        INSERT_ELEM( p_item->pp_categories, p_item->i_categories, p_item->i_categories,
                     p_cat );
    }
    vlc_mutex_unlock( &p_item->lock );

866 867
    vlc_event_send( &p_item->event_manager,
                    &(vlc_event_t) { .type = vlc_InputItemInfoChanged } );
868
}
869

870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
void input_item_SetEpgEvent( input_item_t *p_item, const vlc_epg_event_t *p_epg_evt )
{
    bool b_changed = false;
    vlc_mutex_lock( &p_item->lock );

    for( int i = 0; i < p_item->i_epg; i++ )
    {
        vlc_epg_t *p_epg = p_item->pp_epg[i];
        for( size_t j = 0; j < p_epg->i_event; j++ )
        {
            /* Same event can exist in more than one table */
            if( p_epg->pp_event[j]->i_id == p_epg_evt->i_id )
            {
                vlc_epg_event_t *p_dup = vlc_epg_event_Duplicate( p_epg_evt );
                if( p_dup )
                {
                    if( p_epg->p_current == p_epg->pp_event[j] )
                        p_epg->p_current = p_dup;
                    vlc_epg_event_Delete( p_epg->pp_event[j] );
                    p_epg->pp_event[j] = p_dup;
                    b_changed = true;
                }
                break;
            }
        }
    }
    vlc_mutex_unlock( &p_item->lock );

    if ( b_changed )
    {
900 901
        vlc_event_send( &p_item->event_manager,
                        &(vlc_event_t) { .type = vlc_InputItemInfoChanged } );
902 903 904
    }
}

905
//#define EPG_DEBUG
906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921
#ifdef EPG_DEBUG
static int InputItemAddInfo( input_item_t *p_i,
                             const char *psz_cat,
                             const char *psz_name,
                             const char *psz_format, ... )
{
    va_list args;

    va_start( args, psz_format );
    const int i_ret = InputItemVaAddInfo( p_i, psz_cat, psz_name, psz_format, args );
    va_end( args );

    return i_ret;
}
#endif

922
void input_item_SetEpg( input_item_t *p_item, const vlc_epg_t *p_update, bool b_current_source )
923
{
924 925 926 927
    vlc_epg_t *p_epg = vlc_epg_Duplicate( p_update );
    if( !p_epg )
        return;

928 929 930
    vlc_mutex_lock( &p_item->lock );

    /* */
931
    vlc_epg_t **pp_epg = NULL;
932 933
    for( int i = 0; i < p_item->i_epg; i++ )
    {
934 935
        if( p_item->pp_epg[i]->i_source_id == p_update->i_source_id &&
            p_item->pp_epg[i]->i_id == p_update->i_id )
François Cartegnie's avatar
François Cartegnie committed
936
        {
937
            pp_epg = &p_item->pp_epg[i];
François Cartegnie's avatar
François Cartegnie committed
938 939
            break;
        }
940 941
    }

942 943
    /* replace with new version */
    if( pp_epg )
944
    {
945
        vlc_epg_Delete( *pp_epg );
946 947
        if( *pp_epg == p_item->p_epg_table ) /* current table can have changed */
            p_item->p_epg_table = NULL;
948
        *pp_epg = p_epg;
949
    }
François Cartegnie's avatar
François Cartegnie committed
950 951
    else
    {
952
        TAB_APPEND( p_item->i_epg, p_item->pp_epg, p_epg );
François Cartegnie's avatar
François Cartegnie committed
953
    }
954

955 956 957
    if( b_current_source && p_epg->b_present )
        p_item->p_epg_table = p_epg;

958 959
    vlc_mutex_unlock( &p_item->lock );

960 961 962
    if( !p_epg )
        return;

963 964 965 966 967
#ifdef EPG_DEBUG
    char *psz_epg;
    if( asprintf( &psz_epg, "EPG %s", p_epg->psz_name ? p_epg->psz_name : "unknown" ) < 0 )
        goto signal;

968 969
    input_item_DelInfo( p_item, psz_epg, NULL );

970
    vlc_mutex_lock( &p_item->lock );
François Cartegnie's avatar
François Cartegnie committed
971
    for( size_t i = 0; i < p_epg->i_event; i++ )
972 973 974 975 976 977 978 979 980 981 982 983
    {
        const vlc_epg_event_t *p_evt = p_epg->pp_event[i];
        time_t t_start = (time_t)p_evt->i_start;
        struct tm tm_start;
        char psz_start[128];

        localtime_r( &t_start, &tm_start );

        snprintf( psz_start, sizeof(psz_start), "%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d",
                  1900 + tm_start.tm_year, 1 + tm_start.tm_mon, tm_start.tm_mday,
                  tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec );
        if( p_evt->psz_short_description || p_evt->psz_description )
984
            InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s %s",
985 986
                              p_evt->psz_name,
                              p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
987 988
                              p_evt->psz_short_description ? p_evt->psz_short_description : "" ,
                              p_evt->psz_description ? p_evt->psz_description : "" );
989
        else
990 991 992 993 994
            InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d)",
                              p_evt->psz_name,
                              p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 );
    }
    vlc_mutex_unlock( &p_item->lock );
995 996 997
    free( psz_epg );
signal:
#endif
998 999
    vlc_event_send( &p_item->event_manager,
                    &(vlc_event_t){ .type = vlc_InputItemInfoChanged, } );
1000 1001
}

1002
void input_item_ChangeEPGSource( input_item_t *p_item, int i_source_id )
Laurent Aimar's avatar
Laurent Aimar committed
1003 1004
{
    vlc_mutex_lock( &p_item->lock );
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
    p_item->p_epg_table = NULL;
    if( i_source_id > 0 )
    {
        /* Update pointer to current/next table in the full schedule */
        for( int i = 0; i < p_item->i_epg; i++ )
        {
            if( p_item->pp_epg[i]->i_source_id == i_source_id &&
                p_item->pp_epg[i]->b_present )
            {
                p_item->p_epg_table = p_item->pp_epg[i];
                break;
            }
        }
    }
Laurent Aimar's avatar
Laurent Aimar committed
1019
    vlc_mutex_unlock( &p_item->lock );
1020 1021
}

1022 1023 1024 1025 1026 1027 1028
void input_item_SetEpgTime( input_item_t *p_item, int64_t i_time )
{
    vlc_mutex_lock( &p_item->lock );
    p_item->i_epg_time = i_time;
    vlc_mutex_unlock( &p_item->lock );
}

1029 1030 1031
void input_item_SetEpgOffline( input_item_t *p_item )
{
    input_item_ChangeEPGSource( p_item, -1 );
Laurent Aimar's avatar
Laurent Aimar committed
1032 1033 1034 1035

#ifdef EPG_DEBUG
    vlc_mutex_lock( &p_item->lock );
    const int i_epg_info = p_item->i_epg;
1036
    if( i_epg_info > 0 )
Laurent Aimar's avatar
Laurent Aimar committed
1037
    {
1038 1039 1040 1041 1042 1043 1044 1045
        char *ppsz_epg_info[i_epg_info];
        for( int i = 0; i < p_item->i_epg; i++ )
        {
            const vlc_epg_t *p_epg = p_item->pp_epg[i];
            if( asprintf( &ppsz_epg_info[i], "EPG %s", p_epg->psz_name ? p_epg->psz_name : "unknown" ) < 0 )
                ppsz_epg_info[i] = NULL;
        }
        vlc_mutex_unlock( &p_item->lock );
Laurent Aimar's avatar
Laurent Aimar committed
1046

1047 1048 1049 1050 1051 1052 1053
        for( int i = 0; i < i_epg_info; i++ )
        {
            if( !ppsz_epg_info[i] )
                continue;
            input_item_DelInfo( p_item, ppsz_epg_info[i], NULL );
            free( ppsz_epg_info[i] );
        }
Laurent Aimar's avatar
Laurent Aimar committed
1054
    }
1055 1056
    else
        vlc_mutex_unlock( &p_item->lock );
Laurent Aimar's avatar
Laurent Aimar committed
1057 1058
#endif

1059 1060
    vlc_event_send( &p_item->event_manager,
                    &(vlc_event_t) { .type = vlc_InputItemInfoChanged } );
Laurent Aimar's avatar
Laurent Aimar committed
1061 1062
}

1063
input_item_t *
1064 1065
input_item_NewExt( const char *psz_uri, const char *psz_name,
                   mtime_t duration, int type, enum input_item_net_type i_net )
1066
{
1067 1068
    input_item_owner_t *owner = calloc( 1, sizeof( *owner ) );
    if( unlikely(owner == NULL) )
1069
        return NULL;
1070

1071 1072
    atomic_init( &owner->refs, 1 );

1073
    input_item_t *p_input = &owner->item;
1074
    vlc_event_manager_t * p_em = &p_input->event_manager;
1075

1076
    vlc_mutex_init( &p_input->lock );
1077

1078 1079 1080
    p_input->psz_name = NULL;
    if( psz_name )
        input_item_SetName( p_input, psz_name );
1081

1082
    p_input->psz_uri = NULL;
1083 1084
    if( psz_uri )
        input_item_SetURI( p_input, psz_uri );
1085
    else
1086
    {
1087
        p_input->i_type = ITEM_TYPE_UNKNOWN;
1088 1089
        p_input->b_net = false;
    }
1090

1091 1092 1093
    TAB_INIT( p_input->i_options, p_input->ppsz_options );
    p_input->optflagc = 0;
    p_input->optflagv = NULL;
1094
    p_input->opaques = NULL;
1095

1096 1097 1098 1099 1100 1101
    p_input->i_duration = duration;
    TAB_INIT( p_input->i_categories, p_input->pp_categories );
    TAB_INIT( p_input->i_es, p_input->es );
    p_input->p_stats = NULL;
    p_input->p_meta = NULL;
    TAB_INIT( p_input->i_epg, p_input->pp_epg );
1102
    TAB_INIT( p_input->i_slaves, p_input->pp_slaves );
1103

1104 1105 1106 1107 1108 1109 1110 1111 1112
    vlc_event_manager_init( p_em, p_input );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemMetaChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemAdded );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemTreeAdded );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemDurationChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemPreparsedChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemNameChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemInfoChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemErrorWhenReadingChanged );
1113
    vlc_event_manager_register_event_type( p_em, vlc_InputItemPreparseEnded );
1114

1115 1116 1117
    if( type != ITEM_TYPE_UNKNOWN )
        p_input->i_type = type;
    p_input->b_error_when_reading = false;
1118

1119 1120
    if( i_net != ITEM_NET_UNKNOWN )
        p_input->b_net = i_net == ITEM_NET;
1121 1122 1123
    return p_input;
}

1124
input_item_t *input_item_Copy( input_item_t *p_input )
1125
{
1126 1127
    vlc_meta_t *meta = NULL;
    input_item_t *item;
1128
    bool b_net;
1129

1130
    vlc_mutex_lock( &p_input->lock );
1131

1132 1133 1134
    item = input_item_NewExt( p_input->psz_uri, p_input->psz_name,
                              p_input->i_duration, p_input->i_type,
                              ITEM_NET_UNKNOWN );
1135
    if( likely(item != NULL) && p_input->p_meta != NULL )
1136
    {
1137 1138
        meta = vlc_meta_New();
        vlc_meta_Merge( meta, p_input->p_meta );
1139
    }
1140
    b_net = p_input->b_net;
1141 1142
    vlc_mutex_unlock( &p_input->lock );

1143 1144
    if( likely(item != NULL) )
    {   /* No need to lock; no other thread has seen this new item yet. */
1145
        input_item_CopyOptions( item, p_input );
1146
        item->p_meta = meta;
1147
        item->b_net = b_net;
1148 1149 1150
    }

    return item;
1151 1152
}

1153
struct item_type_entry
1154
{
1155
    const char *psz_scheme;
1156
    uint8_t    i_type;
1157
    bool       b_net;
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
};

static int typecmp( const void *key, const void *entry )
{
    const struct item_type_entry *type = entry;
    const char *uri = key, *scheme = type->psz_scheme;

    return strncmp( uri, scheme, strlen( scheme ) );
}

/* Guess the type of the item using the beginning of the mrl */
1169
static int GuessType( const input_item_t *p_item, bool *p_net )
1170 1171 1172
{
    static const struct item_type_entry tab[] =
    {   /* /!\ Alphabetical order /!\ */
1173
        /* Short match work, not just exact match */
1174 1175 1176
        { "alsa",   ITEM_TYPE_CARD, false },
        { "atsc",   ITEM_TYPE_CARD, false },
        { "bd",     ITEM_TYPE_DISC, false },
1177
        { "bluray", ITEM_TYPE_DISC, false },
1178
        { "cable",  ITEM_TYPE_CARD, false },
1179
        { "cdda",   ITEM_TYPE_DISC, false },
1180 1181 1182 1183 1184 1185
        { "cqam",   ITEM_TYPE_CARD, false },
        { "dc1394", ITEM_TYPE_CARD, false },
        { "dccp",   ITEM_TYPE_STREAM, true },
        { "deckli", ITEM_TYPE_CARD, false }, /* decklink */
        { "dir",    ITEM_TYPE_DIRECTORY, false },
        { "dshow",  ITEM_TYPE_CARD, false },
1186
        { "dtv",    ITEM_TYPE_CARD, false },
1187 1188 1189 1190
        { "dvb",    ITEM_TYPE_CARD, false },
        { "dvd",    ITEM_TYPE_DISC, false },
        { "eyetv",  ITEM_TYPE_CARD, false },
        { "fd",     ITEM_TYPE_UNKNOWN, false },
1191
        { "file",   ITEM_TYPE_FILE, false },
1192 1193 1194 1195
        { "ftp",    ITEM_TYPE_FILE, true },
        { "http",   ITEM_TYPE_FILE, true },
        { "icyx",   ITEM_TYPE_STREAM, true },
        { "imem",   ITEM_TYPE_UNKNOWN, false },
1196
        { "isdb-",  ITEM_TYPE_CARD, false },
1197 1198 1199 1200 1201 1202
        { "itpc",   ITEM_TYPE_PLAYLIST, true },
        { "jack",   ITEM_TYPE_CARD, false },
        { "linsys", ITEM_TYPE_CARD, false },
        { "live",   ITEM_TYPE_STREAM, true }, /* livedotcom */
        { "mms",    ITEM_TYPE_STREAM, true },
        { "mtp",    ITEM_TYPE_DISC, false },
Thomas Guillem's avatar
Thomas Guillem committed
1203
        { "nfs",    ITEM_TYPE_FILE, true },
1204 1205 1206
        { "ofdm",   ITEM_TYPE_CARD, false },
        { "oss",    ITEM_TYPE_CARD, false },
        { "pnm",    ITEM_TYPE_STREAM, true },
1207
        { "pulse",  ITEM_TYPE_CARD, false },
1208 1209 1210
        { "qam",    ITEM_TYPE_CARD, false },
        { "qpsk",   ITEM_TYPE_CARD, false },
        { "qtcapt", ITEM_TYPE_CARD, false }, /* qtcapture */
1211
        { "qtsound",ITEM_TYPE_CARD, false },
1212 1213
        { "raw139", ITEM_TYPE_CARD, false }, /* raw1394 */
        { "rt",     ITEM_TYPE_STREAM, true }, /* rtp, rtsp, rtmp */
1214
        { "satell", ITEM_TYPE_CARD, false }, /* satellite */
Julian Scheel's avatar
Julian Scheel committed
1215
        { "satip",  ITEM_TYPE_STREAM, true }, /* satellite over ip */
1216 1217 1218 1219 1220
        { "screen", ITEM_TYPE_CARD, false },
        { "sdp",    ITEM_TYPE_STREAM, true },
        { "sftp",   ITEM_TYPE_FILE, true },
        { "shm",    ITEM_TYPE_CARD, false },
        { "smb",    ITEM_TYPE_FILE, true },
1221
        { "stream", ITEM_TYPE_STREAM, false },
1222 1223 1224 1225 1226
        { "svcd",   ITEM_TYPE_DISC, false },
        { "tcp",    ITEM_TYPE_STREAM, true },
        { "terres", ITEM_TYPE_CARD, false }, /* terrestrial */
        { "udp",    ITEM_TYPE_STREAM, true },  /* udplite too */
        { "unsv",   ITEM_TYPE_STREAM, true },
1227
        { "upnp",   ITEM_TYPE_FILE, true },
1228 1229 1230
        { "usdigi", ITEM_TYPE_CARD, false }, /* usdigital */
        { "v4l",    ITEM_TYPE_CARD, false },
        { "vcd",    ITEM_TYPE_DISC, false },
1231 1232
        { "vdr",    ITEM_TYPE_STREAM, true },
        { "wasapi", ITEM_TYPE_CARD, false },
1233
        { "window", ITEM_TYPE_CARD, false },
1234
    };
1235 1236 1237

#ifndef NDEBUG
    for( size_t i = 1; i < ARRAY_SIZE( tab ); i++ )
1238
        assert( typecmp( (tab + i)->psz_scheme, tab + i - 1 ) > 0 );
1239 1240
#endif

1241
    *p_net = false;
1242

1243 1244 1245 1246 1247 1248 1249 1250
    if( strstr( p_item->psz_uri, "://" ) == NULL )
        return ITEM_TYPE_UNKNOWN; /* invalid URI */

    const struct item_type_entry *e =
        bsearch( p_item->psz_uri, tab, ARRAY_SIZE( tab ),
                 sizeof( tab[0] ), typecmp );
    if( e == NULL )
        return ITEM_TYPE_UNKNOWN;
1251

1252 1253
    *p_net = e->b_net;
    return e->i_type;
1254
}
1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273

input_item_node_t *input_item_node_Create( input_item_t *p_input )
{
    input_item_node_t* p_node = malloc( sizeof( input_item_node_t ) );
    if( !p_node )
        return NULL;

    assert( p_input );

    p_node->p_item = p_input;
    vlc_gc_incref( p_input );

    p_node->p_parent = NULL;
    p_node->i_children = 0;
    p_node->pp_children = NULL;

    return p_node;
}

1274
static void RecursiveNodeDelete( input_item_node_t *p_node )
1275
{
1276 1277
    for( int i = 0; i < p_node->i_children; i++ )
        RecursiveNodeDelete( p_node->pp_children[i] );
1278

1279 1280 1281
    vlc_gc_decref( p_node->p_item );
    free( p_node->pp_children );
    free( p_node );
1282
}
1283

1284 1285
void input_item_node_Delete( input_item_node_t *p_node )
{
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
    if( p_node->p_parent )
        for( int i = 0; i < p_node->p_parent->i_children; i++ )
            if( p_node->p_parent->pp_children[i] == p_node )
            {
                REMOVE_ELEM( p_node->p_parent->pp_children,
                        p_node->p_parent->i_children,
                        i );
                break;
            }

    RecursiveNodeDelete( p_node );
1297 1298 1299 1300
}

input_item_node_t *input_item_node_AppendItem( input_item_node_t *p_node, input_item_t *p_item )
{
1301
    int i_preparse_depth;
1302 1303
    input_item_node_t *p_new_child = input_item_node_Create( p_item );
    if( !p_new_child ) return NULL;
1304 1305 1306

    vlc_mutex_lock( &p_node->p_item->lock );
    i_preparse_depth = p_node->p_item->i_preparse_depth;
1307 1308 1309
    vlc_mutex_unlock( &p_node->p_item->lock );

    vlc_mutex_lock( &p_item->lock );
1310 1311 1312 1313 1314
    p_item->i_preparse_depth = i_preparse_depth > 0 ?
                               i_preparse_depth -1 :
                               i_preparse_depth;
    vlc_mutex_unlock( &p_item->lock );

1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
    input_item_node_AppendNode( p_node, p_new_child );
    return p_new_child;
}

void input_item_node_AppendNode( input_item_node_t *p_parent, input_item_node_t *p_child )
{
    assert( p_parent && p_child && p_child->p_parent == NULL );
    INSERT_ELEM( p_parent->pp_children,
                 p_parent->i_children,
                 p_parent->i_children,
                 p_child );
    p_child->p_parent = p_parent;
}
1328 1329 1330

void input_item_node_PostAndDelete( input_item_node_t *p_root )
{
1331
    post_subitems( p_root );
1332

1333 1334 1335
    vlc_event_send( &p_root->p_item->event_manager, &(vlc_event_t) {
        .type = vlc_InputItemSubItemTreeAdded,
        .u.input_item_subitem_tree_added.p_root = p_root } );
1336

1337
    input_item_node_Delete( p_root );
1338
}
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368