item.c 31.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*****************************************************************************
 * item.c: input_item management
 *****************************************************************************
 * Copyright (C) 1998-2004 the VideoLAN team
 * $Id$
 *
 * Authors: Clément Stenac <zorglub@videolan.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (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
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
19
20
21
 * You should have received a copy of the GNU 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

29
#include <vlc_common.h>
30
#include <vlc_url.h>
31
32
#include "vlc_playlist.h"
#include "vlc_interface.h"
33
#include <vlc_charset.h>
34

35
#include "item.h"
36
#include "info.h"
zorglub's avatar
zorglub committed
37

38
static int GuessType( const input_item_t *p_item );
39

40
41
/** Stuff moved out of vlc_input.h -- FIXME: should probably not be inline
 * anyway. */
42
static inline void input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
43
44
{
    memset( p_i, 0, sizeof(input_item_t) );
45

46
47
48
49
50
51
    p_i->psz_name = NULL;
    p_i->psz_uri = NULL;
    TAB_INIT( p_i->i_es, p_i->es );
    TAB_INIT( p_i->i_options, p_i->ppsz_options );
    p_i->optflagv = NULL, p_i->optflagc = 0;
    TAB_INIT( p_i->i_categories, p_i->pp_categories );
52
    TAB_INIT( p_i->i_epg, p_i->pp_epg );
53
54

    p_i->i_type = ITEM_TYPE_UNKNOWN;
55
    p_i->b_fixed_name = true;
56
57
58
59

    p_i->p_stats = NULL;
    p_i->p_meta = NULL;

60
    vlc_mutex_init( &p_i->lock );
61
62
63
64
    vlc_event_manager_t * p_em = &p_i->event_manager;
    vlc_event_manager_init( p_em, p_i, p_o );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemMetaChanged );
    vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemAdded );
jpd's avatar
jpd committed
65
    vlc_event_manager_register_event_type( p_em, vlc_InputItemSubItemTreeAdded );
66
67
68
69
70
    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 );
71
72
}

73
static inline void input_item_Clean( input_item_t *p_i )
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
{
    int i;

    vlc_event_manager_fini( &p_i->event_manager );

    free( p_i->psz_name );
    free( p_i->psz_uri );
    if( p_i->p_stats )
    {
        vlc_mutex_destroy( &p_i->p_stats->lock );
        free( p_i->p_stats );
    }

    if( p_i->p_meta )
        vlc_meta_Delete( p_i->p_meta );

    for( i = 0; i < p_i->i_options; i++ )
        free( p_i->ppsz_options[i] );
    TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
    free( p_i->optflagv);

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

102
103
104
105
    for( i = 0; i < p_i->i_epg; i++ )
        vlc_epg_Delete( p_i->pp_epg[i] );
    TAB_CLEAN( p_i->i_epg, p_i->pp_epg );

106
    for( i = 0; i < p_i->i_categories; i++ )
107
        info_category_Delete( p_i->pp_categories[i] );
108
109
110
111
    TAB_CLEAN( p_i->i_categories, p_i->pp_categories );

    vlc_mutex_destroy( &p_i->lock );
}
112
113
114
115
116
117
118
119
120
121
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 );
122

123
124
125
126
127
128
129
130
131
132
    if( b_changed )
    {
        vlc_event_t event;

        event.type = vlc_InputItemErrorWhenReadingChanged;
        event.u.input_item_error_when_reading_changed.new_value = b_error;
        vlc_event_send( &p_i->event_manager, &event );
    }
}
void input_item_SetPreparsed( input_item_t *p_i, bool b_preparsed )
133
{
134
    bool b_send_event = false;
135

136
    vlc_mutex_lock( &p_i->lock );
137

138
139
    if( !p_i->p_meta )
        p_i->p_meta = vlc_meta_New();
140

141
142
    int status = vlc_meta_GetStatus(p_i->p_meta);
    int new_status;
143
    if( b_preparsed )
144
        new_status = status | ITEM_PREPARSED;
145
    else
146
147
        new_status = status & ~ITEM_PREPARSED;
    if( status != new_status )
148
    {
149
        vlc_meta_SetStatus(p_i->p_meta, new_status);
150
151
152
153
154
155
156
157
158
        b_send_event = true;
    }

    vlc_mutex_unlock( &p_i->lock );

    if( b_send_event )
    {
        vlc_event_t event;
        event.type = vlc_InputItemPreparsedChanged;
159
        event.u.input_item_preparsed_changed.new_status = new_status;
160
161
162
        vlc_event_send( &p_i->event_manager, &event );
    }
}
163

164
165
166
167
168
169
170
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();

171
    int status = vlc_meta_GetStatus(p_i->p_meta);
172

173
    if( b_not_found )
174
        status |= ITEM_ART_NOTFOUND;
175
    else
176
        status &= ~ITEM_ART_NOTFOUND;
177

178
    vlc_meta_SetStatus(p_i->p_meta, status);
179

180
181
    vlc_mutex_unlock( &p_i->lock );
}
182

183
184
185
186
187
188
189
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();

190
    int status = vlc_meta_GetStatus(p_i->p_meta);
191

192
    if( b_art_fetched )
193
        status |= ITEM_ART_FETCHED;
194
    else
195
196
197
        status &= ~ITEM_ART_FETCHED;

    vlc_meta_SetStatus(p_i->p_meta, status);
198
199

    vlc_mutex_unlock( &p_i->lock );
200
201
}

202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
void input_item_SetMeta( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val )
{
    vlc_event_t event;

    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 */
    event.type = vlc_InputItemMetaChanged;
    event.u.input_item_meta_changed.meta_type = meta_type;
    vlc_event_send( &p_i->event_manager, &event );
}

218
/* FIXME GRRRRRRRRRR args should be in the reverse order to be
Rémi Denis-Courmont's avatar
Typos    
Rémi Denis-Courmont committed
219
 * consistent with (nearly?) all or copy funcs */
220
void input_item_CopyOptions( input_item_t *p_parent,
221
                             input_item_t *p_child )
222
{
223
224
225
    vlc_mutex_lock( &p_parent->lock );

    for( int i = 0 ; i< p_parent->i_options; i++ )
226
    {
227
        if( !strcmp( p_parent->ppsz_options[i], "meta-file" ) )
228
            continue;
229

230
231
232
        input_item_AddOption( p_child,
                              p_parent->ppsz_options[i],
                              p_parent->optflagv[i] );
233
234
    }

235
    vlc_mutex_unlock( &p_parent->lock );
236
237
}

238
static void post_subitems( input_item_node_t *p_node )
239
{
240
241
242
243
244
245
246
247
248
    for( int i = 0; i < p_node->i_children; i++ )
    {
        vlc_event_t event;
        event.type = vlc_InputItemSubItemAdded;
        event.u.input_item_subitem_added.p_new_child = p_node->pp_children[i]->p_item;
        vlc_event_send( &p_node->p_item->event_manager, &event );

        post_subitems( p_node->pp_children[i] );
    }
249
250
}

251
252
253
254
/* 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
 * It is not the input item's responsability to keep all the ref of
 * the input item children. */
255
void input_item_PostSubItem( input_item_t *p_parent, input_item_t *p_child )
256
{
257
258
    input_item_node_t *p_node = input_item_node_Create( p_parent );
    input_item_node_AppendItem( p_node, p_child );
259
    input_item_node_PostAndDelete( p_node );
jpd's avatar
jpd committed
260
261
}

262
bool input_item_HasErrorWhenReading( input_item_t *p_item )
263
{
264
265
266
267
268
269
270
    vlc_mutex_lock( &p_item->lock );

    bool b_error = p_item->b_error_when_reading;

    vlc_mutex_unlock( &p_item->lock );

    return b_error;
271
272
}

273
274
bool input_item_MetaMatch( input_item_t *p_i,
                           vlc_meta_type_t meta_type, const char *psz )
275
276
{
    vlc_mutex_lock( &p_i->lock );
277

278
279
280
281
282
    if( !p_i->p_meta )
    {
        vlc_mutex_unlock( &p_i->lock );
        return false;
    }
283
284
285
    const char *psz_meta = vlc_meta_Get( p_i->p_meta, meta_type );
    bool b_ret = psz_meta && strcasestr( psz_meta, psz );

286
287
    vlc_mutex_unlock( &p_i->lock );

288
    return b_ret;
289
290
}

291
char *input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
292
293
294
295
296
297
298
299
300
{
    vlc_mutex_lock( &p_i->lock );

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

301
    char *psz = NULL;
302
303
304
305
306
307
308
    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;
}

309
310
311
312
313
314
315
316
/* 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 )
    {
317
        psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;
318
        vlc_mutex_unlock( &p_item->lock );
319
        return psz_ret;
320
321
    }

322
323
324
    const char *psz_title = vlc_meta_Get( p_item->p_meta, vlc_meta_Title );
    if( !EMPTY_STR( psz_title ) )
        psz_ret = strdup( psz_title );
325
326
327
328
329
330
331
    else
        psz_ret = p_item->psz_name ? strdup( p_item->psz_name ) : NULL;

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

332
char *input_item_GetName( input_item_t *p_item )
333
{
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
    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 );
349
350
}

351
char *input_item_GetURI( input_item_t *p_i )
352
353
{
    vlc_mutex_lock( &p_i->lock );
354

355
    char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
356

357
358
359
    vlc_mutex_unlock( &p_i->lock );
    return psz_s;
}
360

361
void input_item_SetURI( input_item_t *p_i, const char *psz_uri )
362
{
363
    assert( psz_uri );
364
#ifndef NDEBUG
365
366
367
368
    if( !strstr( psz_uri, "://" )
     || strchr( psz_uri, ' ' ) || strchr( psz_uri, '"' ) )
        fprintf( stderr, "Warning: %s(\"%s\"): file path instead of URL.\n",
                 __func__, psz_uri );
369
#endif
370
    vlc_mutex_lock( &p_i->lock );
371
372
    free( p_i->psz_uri );
    p_i->psz_uri = strdup( psz_uri );
373

374
    p_i->i_type = GuessType( p_i );
375

376
377
378
379
    if( p_i->psz_name )
        ;
    else
    if( p_i->i_type == ITEM_TYPE_FILE || p_i->i_type == ITEM_TYPE_DIRECTORY )
380
    {
381
382
383
        const char *psz_filename = strrchr( p_i->psz_uri, '/' );

        if( psz_filename && *psz_filename == '/' )
384
385
386
            psz_filename++;
        if( psz_filename && *psz_filename )
            p_i->psz_name = strdup( psz_filename );
387
388
389

        /* Make the name more readable */
        if( p_i->psz_name )
390
        {
391
            decode_URI( p_i->psz_name );
392
393
            EnsureUTF8( p_i->psz_name );
        }
394
    }
395
396
    else
    {   /* Strip login and password from title */
397
        int r;
398
        vlc_url_t url;
399

400
401
402
403
        vlc_UrlParse( &url, psz_uri, 0 );
        if( url.psz_protocol )
        {
            if( url.i_port > 0 )
404
                r=asprintf( &p_i->psz_name, "%s://%s:%d%s", url.psz_protocol,
405
406
407
                          url.psz_host, url.i_port,
                          url.psz_path ? url.psz_path : "" );
            else
408
                r=asprintf( &p_i->psz_name, "%s://%s%s", url.psz_protocol,
409
410
411
412
413
414
                          url.psz_host ? url.psz_host : "",
                          url.psz_path ? url.psz_path : "" );
        }
        else
        {
            if( url.i_port > 0 )
415
                r=asprintf( &p_i->psz_name, "%s:%d%s", url.psz_host, url.i_port,
416
417
                          url.psz_path ? url.psz_path : "" );
            else
418
                r=asprintf( &p_i->psz_name, "%s%s", url.psz_host,
419
420
421
                          url.psz_path ? url.psz_path : "" );
        }
        vlc_UrlClean( &url );
422
423
        if( -1==r )
            p_i->psz_name=NULL; /* recover from undefined value */
424
    }
425

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

429
mtime_t input_item_GetDuration( input_item_t *p_i )
430
431
{
    vlc_mutex_lock( &p_i->lock );
432

433
    mtime_t i_duration = p_i->i_duration;
434

435
436
437
438
    vlc_mutex_unlock( &p_i->lock );
    return i_duration;
}

439
void input_item_SetDuration( input_item_t *p_i, mtime_t i_duration )
440
{
441
    bool b_send_event = false;
442
443
444
445
446

    vlc_mutex_lock( &p_i->lock );
    if( p_i->i_duration != i_duration )
    {
        p_i->i_duration = i_duration;
447
        b_send_event = true;
448
449
450
    }
    vlc_mutex_unlock( &p_i->lock );

451
    if( b_send_event )
452
453
    {
        vlc_event_t event;
454

455
456
457
458
459
460
461
        event.type = vlc_InputItemDurationChanged;
        event.u.input_item_duration_changed.new_duration = i_duration;
        vlc_event_send( &p_i->event_manager, &event );
    }
}


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
static void input_item_Destroy ( gc_object_t *p_gc )
481
{
482
    input_item_t *p_item = vlc_priv( p_gc, input_item_t );
483

484
485
    input_item_Clean( p_item );
    free( p_item );
486
487
}

488
489
int input_item_AddOption( input_item_t *p_input, const char *psz_option,
                          unsigned flags )
490
{
491
492
    int err = VLC_SUCCESS;

493
    if( psz_option == NULL )
494
        return VLC_EGENERIC;
495
496

    vlc_mutex_lock( &p_input->lock );
497
    if (flags & VLC_INPUT_OPTION_UNIQUE)
498
    {
499
500
501
        for (int i = 0 ; i < p_input->i_options; i++)
            if( !strcmp( p_input->ppsz_options[i], psz_option ) )
                goto out;
502
503
    }

504
505
506
507
508
509
510
511
512
    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;

513
514
515
516
    INSERT_ELEM( p_input->ppsz_options, p_input->i_options,
                 p_input->i_options, strdup( psz_option ) );
out:
    vlc_mutex_unlock( &p_input->lock );
517
    return err;
518
}
519

520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
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;
}

538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
/**
 * 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 );

554
555
    const info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
    if( p_cat )
556
    {
557
558
        info_t *p_info = info_category_FindInfo( p_cat, NULL, psz_name );
        if( p_info && p_info->psz_value )
559
        {
560
561
562
            char *psz_ret = strdup( p_info->psz_value );
            vlc_mutex_unlock( &p_i->lock );
            return psz_ret;
563
564
565
566
567
568
569
570
571
572
        }
    }
    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 )
573
{
574
    vlc_assert_locked( &p_i->lock );
575

576
    info_category_t *p_cat = InputItemFindCat( p_i, NULL, psz_cat );
577
578
    if( !p_cat )
    {
579
580
        p_cat = info_category_New( psz_cat );
        if( !p_cat )
581
            return VLC_ENOMEM;
582
583
584
        INSERT_ELEM( p_i->pp_categories, p_i->i_categories, p_i->i_categories,
                     p_cat );
    }
585
586
587
588
    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;
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
}

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;
}

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 );
616
617
618
619
    va_end( args );

    vlc_mutex_unlock( &p_i->lock );

620
621

    if( !i_ret )
622
623
624
625
626
627
    {
        vlc_event_t event;

        event.type = vlc_InputItemInfoChanged;
        vlc_event_send( &p_i->event_manager, &event );
    }
628
    return i_ret;
629
}
630

631
632
633
634
635
int input_item_DelInfo( input_item_t *p_i,
                        const char *psz_cat,
                        const char *psz_name )
{
    vlc_mutex_lock( &p_i->lock );
636
637
638
    int i_cat;
    info_category_t *p_cat = InputItemFindCat( p_i, &i_cat, psz_cat );
    if( !p_cat )
639
640
641
642
643
644
645
646
    {
        vlc_mutex_unlock( &p_i->lock );
        return VLC_EGENERIC;
    }

    if( psz_name )
    {
        /* Remove a specific info */
647
648
        int i_ret = info_category_DeleteInfo( p_cat, psz_name );
        if( i_ret )
649
650
651
652
653
654
655
656
        {
            vlc_mutex_unlock( &p_i->lock );
            return VLC_EGENERIC;
        }
    }
    else
    {
        /* Remove the complete categorie */
657
        info_category_Delete( p_cat );
658
659
660
661
662
663
664
665
666
667
668
        REMOVE_ELEM( p_i->pp_categories, p_i->i_categories, i_cat );
    }
    vlc_mutex_unlock( &p_i->lock );


    vlc_event_t event;
    event.type = vlc_InputItemInfoChanged;
    vlc_event_send( &p_i->event_manager, &event );

    return VLC_SUCCESS;
}
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
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 );


    vlc_event_t event;
    event.type = vlc_InputItemInfoChanged;
    vlc_event_send( &p_item->event_manager, &event );
}
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 );


    vlc_event_t event;
    event.type = vlc_InputItemInfoChanged;
    vlc_event_send( &p_item->event_manager, &event );
}
714

715
716
#define EPG_DEBUG
void input_item_SetEpg( input_item_t *p_item, const vlc_epg_t *p_update )
717
{
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
    vlc_mutex_lock( &p_item->lock );

    /* */
    vlc_epg_t *p_epg = NULL;
    for( int i = 0; i < p_item->i_epg; i++ )
    {
        vlc_epg_t *p_tmp = p_item->pp_epg[i];

        if( (p_tmp->psz_name == NULL) != (p_update->psz_name == NULL) )
            continue;
        if( p_tmp->psz_name && p_update->psz_name && strcmp(p_tmp->psz_name, p_update->psz_name) )
            continue;

        p_epg = p_tmp;
        break;
    }

    /* */
    if( !p_epg )
    {
        p_epg = vlc_epg_New( p_update->psz_name );
        if( p_epg )
            TAB_APPEND( p_item->i_epg, p_item->pp_epg, p_epg );
    }
    if( p_epg )
        vlc_epg_Merge( p_epg, p_update );

    vlc_mutex_unlock( &p_item->lock );

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

752
753
    input_item_DelInfo( p_item, psz_epg, NULL );

754
    vlc_mutex_lock( &p_item->lock );
755
756
757
758
759
760
761
762
763
764
765
766
767
    for( int i = 0; i < p_epg->i_event; i++ )
    {
        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 )
768
            InputItemAddInfo( p_item, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s %s",
769
770
                              p_evt->psz_name,
                              p_evt->i_duration/60/60, (p_evt->i_duration/60)%60,
771
772
                              p_evt->psz_short_description ? p_evt->psz_short_description : "" ,
                              p_evt->psz_description ? p_evt->psz_description : "" );
773
        else
774
775
776
777
778
            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 );
779
780
781
    free( psz_epg );
signal:
#endif
782
783
784

    if( p_epg->i_event > 0 )
    {
785
        vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
786
        vlc_event_send( &p_item->event_manager, &event );
787
788
789
    }
}

Laurent Aimar's avatar
Laurent Aimar committed
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
void input_item_SetEpgOffline( input_item_t *p_item )
{
    vlc_mutex_lock( &p_item->lock );
    for( int i = 0; i < p_item->i_epg; i++ )
        vlc_epg_SetCurrent( p_item->pp_epg[i], -1 );
    vlc_mutex_unlock( &p_item->lock );

#ifdef EPG_DEBUG
    vlc_mutex_lock( &p_item->lock );
    const int i_epg_info = p_item->i_epg;
    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 );

    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] );
    }
#endif

    vlc_event_t event = { .type = vlc_InputItemInfoChanged, };
    vlc_event_send( &p_item->event_manager, &event );
}

822
823
824
825
826
827
828
#undef input_item_NewExt
input_item_t *input_item_NewExt( vlc_object_t *p_obj, const char *psz_uri,
                                 const char *psz_name,
                                 int i_options,
                                 const char *const *ppsz_options,
                                 unsigned i_option_flags,
                                 mtime_t i_duration )
829
{
830
    return input_item_NewWithType( p_obj, psz_uri, psz_name,
831
                                  i_options, ppsz_options, i_option_flags,
832
833
834
835
                                  i_duration, ITEM_TYPE_UNKNOWN );
}


836
input_item_t *input_item_NewWithType( vlc_object_t *p_obj, const char *psz_uri,
837
838
839
                                const char *psz_name,
                                int i_options,
                                const char *const *ppsz_options,
840
                                unsigned i_option_flags,
841
                                mtime_t i_duration,
842
843
                                int i_type )
{
844
    libvlc_priv_t *priv = libvlc_priv (p_obj->p_libvlc);
845
    static vlc_mutex_t input_id_lock = VLC_STATIC_MUTEX;
846

847
848
849
    input_item_t* p_input = malloc( sizeof(input_item_t ) );
    if( !p_input )
        return NULL;
850

851
    input_item_Init( p_obj, p_input );
852
    vlc_gc_init( p_input, input_item_Destroy );
853

854
    vlc_mutex_lock( &input_id_lock );
855
    p_input->i_id = ++priv->i_last_input_id;
856
    vlc_mutex_unlock( &input_id_lock );
857

858
    p_input->b_fixed_name = false;
859
860
861

    p_input->i_type = i_type;

862
863
    if( psz_uri )
        input_item_SetURI( p_input, psz_uri );
864

865
866
867
868
869
    if( i_type != ITEM_TYPE_UNKNOWN )
        p_input->i_type = i_type;

    if( psz_name )
        input_item_SetName( p_input, psz_name );
870

871
872
    p_input->i_duration = i_duration;

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
873
    for( int i = 0; i < i_options; i++ )
874
        input_item_AddOption( p_input, ppsz_options[i], i_option_flags );
875
876
877
    return p_input;
}

jpd's avatar
jpd committed
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
input_item_t *input_item_Copy( vlc_object_t *p_obj, input_item_t *p_input )
{
    vlc_mutex_lock( &p_input->lock );

    input_item_t *p_new_input =
        input_item_NewWithType( p_obj,
                                p_input->psz_uri, p_input->psz_name,
                                0, NULL, 0, p_input->i_duration,
                                p_input->i_type );

    if( p_new_input )
    {
        for( int i = 0 ; i< p_input->i_options; i++ )
        {
            input_item_AddOption( p_new_input,
                                  p_input->ppsz_options[i],
                                  p_input->optflagv[i] );
        }
    }

    vlc_mutex_unlock( &p_input->lock );

    return p_new_input;
}

903
struct item_type_entry
904
{
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
    const char psz_scheme[7];
    uint8_t    i_type;
};

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 */
static int GuessType( const input_item_t *p_item )
{
    static const struct item_type_entry tab[] =
    {   /* /!\ Alphabetical order /!\ */
922
923
924
925
926
        /* Short match work, not just exact match */
        { "alsa",   ITEM_TYPE_CARD },
        { "atsc",   ITEM_TYPE_CARD },
        { "bd",     ITEM_TYPE_DISC },
        { "cable",  ITEM_TYPE_CARD },
927
        { "cdda",   ITEM_TYPE_CDDA },
928
929
930
        { "dc1394", ITEM_TYPE_CARD },
        { "dccp",   ITEM_TYPE_NET },
        { "dir",    ITEM_TYPE_DIRECTORY },
931
        { "dshow",  ITEM_TYPE_CARD },
932
        { "dv",     ITEM_TYPE_CARD },
933
934
935
936
        { "dvb",    ITEM_TYPE_CARD },
        { "dvd",    ITEM_TYPE_DISC },
        { "ftp",    ITEM_TYPE_NET },
        { "http",   ITEM_TYPE_NET },
937
938
939
940
        { "icyx",   ITEM_TYPE_NET },
        { "itpc",   ITEM_TYPE_NET },
        { "jack",   ITEM_TYPE_CARD },
        { "live",   ITEM_TYPE_NET }, /* livedotcom */
941
        { "mms",    ITEM_TYPE_NET },
942
943
944
945
        { "mtp",    ITEM_TYPE_DISC },
        { "ofdm",   ITEM_TYPE_CARD },
        { "oss",    ITEM_TYPE_CARD },
        { "pnm",    ITEM_TYPE_NET },
946
        { "pvr",    ITEM_TYPE_CARD },
947
        { "qam",    ITEM_TYPE_CARD },
948
        { "qpsk",   ITEM_TYPE_CARD },
949
950
951
952
953
        { "qtcapt", ITEM_TYPE_CARD }, /* qtcapture */
        { "raw139", ITEM_TYPE_CARD }, /* raw1394 */
        { "rt",     ITEM_TYPE_NET }, /* rtp, rtsp, rtmp */
        { "satell", ITEM_TYPE_CARD }, /* sattelite */
        { "screen", ITEM_TYPE_CARD },
954
955
        { "sdp",    ITEM_TYPE_NET },
        { "smb",    ITEM_TYPE_NET },
956
957
958
959
960
961
        { "svcd",   ITEM_TYPE_DISC },
        { "tcp",    ITEM_TYPE_NET },
        { "terres", ITEM_TYPE_CARD }, /* terrestrial */
        { "udp",    ITEM_TYPE_NET },  /* udplite too */
        { "unsv",   ITEM_TYPE_NET },
        { "usdigi", ITEM_TYPE_CARD }, /* usdigital */
962
963
        { "v4l",    ITEM_TYPE_CARD },
        { "vcd",    ITEM_TYPE_DISC },
964
        { "window", ITEM_TYPE_CARD },
965
    };
966
    const struct item_type_entry *e;
967

968
969
    if( !strstr( p_item->psz_uri, "://" ) )
        return ITEM_TYPE_FILE;
970

971
972
973
    e = bsearch( p_item->psz_uri, tab, sizeof( tab ) / sizeof( tab[0] ),
                 sizeof( tab[0] ), typecmp );
    return e ? e->i_type : ITEM_TYPE_FILE;
974
}
jpd's avatar
jpd committed
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993

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;
}

994
static void RecursiveNodeDelete( input_item_node_t *p_node )
jpd's avatar
jpd committed
995
{
996
997
998
999
1000
1001
1002
  for( int i = 0; i < p_node->i_children; i++ )
      RecursiveNodeDelete( p_node->pp_children[i] );

  vlc_gc_decref( p_node->p_item );
  free( p_node->pp_children );
  free( p_node );
}
jpd's avatar
jpd committed
1003

1004
1005
void input_item_node_Delete( input_item_node_t *p_node )
{
jpd's avatar
jpd committed
1006
1007
  if(  p_node->p_parent )
  {
1008
      for( int i = 0; i < p_node->p_parent->i_children; i++ )
jpd's avatar
jpd committed
1009
1010
1011
1012
1013
1014
1015
1016
1017
          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;
          }
  }

1018
  RecursiveNodeDelete( p_node );
jpd's avatar
jpd committed
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
}

input_item_node_t *input_item_node_AppendItem( input_item_node_t *p_node, input_item_t *p_item )
{
    input_item_node_t *p_new_child = input_item_node_Create( p_item );
    if( !p_new_child ) return NULL;
    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;
}
1038
1039
1040

void input_item_node_PostAndDelete( input_item_node_t *p_root )
{
1041
1042
  post_subitems( p_root );

1043
1044
1045
1046
1047
1048
1049
  vlc_event_t event;
  event.type = vlc_InputItemSubItemTreeAdded;
  event.u.input_item_subitem_tree_added.p_root = p_root;
  vlc_event_send( &p_root->p_item->event_manager, &event );

  input_item_node_Delete( p_root );
}
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081

/* Called by es_out when a new Elementary Stream is added or updated. */
void input_item_UpdateTracksInfo(input_item_t *item, const es_format_t *fmt)
{
    int i;
    es_format_t *fmt_copy = malloc(sizeof *fmt_copy);
    if (!fmt_copy)
        return;

    es_format_Copy(fmt_copy, fmt);
    /* XXX: we could free p_extra to save memory, we will likely not need
     * the decoder specific data */

    vlc_mutex_lock( &item->lock );

    for( i = 0; i < item->i_es; i++ )
    {
        if (item->es[i]->i_id != fmt->i_id)
            continue;

        /* We've found the right ES, replace it */
        es_format_Clean(item->es[i]);
        free(item->es[i]);
        item->es[i] = fmt_copy;
        vlc_mutex_unlock( &item->lock );
        return;
    }

    /* ES not found, insert it */
    TAB_APPEND(item->i_es, item->es, fmt_copy);
    vlc_mutex_unlock( &item->lock );
}