git.sesse.net Git - vlc/blob - src/playlist/item.c

   1 /*****************************************************************************
   2  * item.c : Playlist item functions
   3  *****************************************************************************
   4  * Copyright (C) 1999-2004 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23 #include <stdlib.h>                                      /* free(), strtol() */
  24 #include <stdio.h>                                              /* sprintf() */
  25 #include <string.h>                                            /* strerror() */
  26
  27 #include <vlc/vlc.h>
  28 #include <vlc/input.h>
  29
  30 #include "vlc_input.h"
  31 #include "vlc_playlist.h"
  32
  33 static void GuessType( input_item_t *p_item);
  34
  35 /**
  36  * Create a new item, without adding it to the playlist
  37  *
  38  * \param p_obj a vlc object (anyone will do)
  39  * \param psz_uri the mrl of the item
  40  * \param psz_name a text giving a name or description of the item
  41  * \return the new item or NULL on failure
  42  */
  43
  44 playlist_item_t * __playlist_ItemNew( vlc_object_t *p_obj,
  45                                       const char *psz_uri,
  46                                       const char *psz_name )
  47 {
  48     return playlist_ItemNewWithType( p_obj, psz_uri,
  49                                      psz_name, ITEM_TYPE_UNKNOWN );
  50 }
  51
  52 playlist_item_t * playlist_ItemNewWithType( vlc_object_t *p_obj,
  53                                             const char *psz_uri,
  54                                             const char *psz_name,
  55                                             int i_type )
  56 {
  57     playlist_item_t * p_item;
  58
  59     if( psz_uri == NULL) return NULL;
  60
  61     p_item = malloc( sizeof( playlist_item_t ) );
  62     if( p_item == NULL ) return NULL;
  63
  64     memset( p_item, 0, sizeof( playlist_item_t ) );
  65
  66     vlc_input_item_Init( p_obj, &p_item->input );
  67     p_item->input.b_fixed_name = VLC_FALSE;
  68
  69     p_item->input.psz_uri = strdup( psz_uri );
  70
  71     if( psz_name != NULL ) p_item->input.psz_name = strdup( psz_name );
  72     else p_item->input.psz_name = strdup ( psz_uri );
  73
  74     p_item->input.i_type = i_type;
  75
  76     p_item->b_enabled = VLC_TRUE;
  77     p_item->i_nb_played = 0;
  78
  79     p_item->i_children = -1;
  80     p_item->pp_children = NULL;
  81
  82     p_item->i_flags = 0;
  83     p_item->i_flags |= PLAYLIST_SKIP_FLAG;
  84     p_item->i_flags |= PLAYLIST_SAVE_FLAG;
  85
  86     p_item->input.i_duration = -1;
  87     p_item->input.ppsz_options = NULL;
  88     p_item->input.i_options = 0;
  89
  90     vlc_mutex_init( p_obj, &p_item->input.lock );
  91
  92     if( p_item->input.i_type == ITEM_TYPE_UNKNOWN )
  93         GuessType( &p_item->input );
  94
  95     return p_item;
  96 }
  97
  98 /**
  99  * Copy a playlist item
 100  *
 101  * Creates a new item with name, mrl and meta infor like the
 102  * source. Does not copy children for node type items.
 103  * \param p_obj any vlc object, needed for mutex init
 104  * \param p_item the item to copy
 105  * \return pointer to the new item, or NULL on error
 106  * \note function takes the lock on p_item
 107  */
 108 playlist_item_t *__playlist_ItemCopy( vlc_object_t *p_obj,
 109                                       playlist_item_t *p_item )
 110 {
 111     playlist_item_t *p_res;
 112     int i;
 113     vlc_mutex_lock( &p_item->input.lock );
 114
 115     p_res = malloc( sizeof( playlist_item_t ) );
 116     if( p_res == NULL )
 117     {
 118         vlc_mutex_unlock( &p_item->input.lock );
 119         return NULL;
 120     }
 121
 122     *p_res = *p_item;
 123     vlc_mutex_init( p_obj, &p_res->input.lock );
 124
 125     if( p_item->input.i_options )
 126         p_res->input.ppsz_options =
 127             malloc( p_item->input.i_options * sizeof(char*) );
 128     for( i = 0; i < p_item->input.i_options; i++ )
 129     {
 130         p_res->input.ppsz_options[i] = strdup( p_item->input.ppsz_options[i] );
 131     }
 132
 133     if( p_item->i_children != -1 )
 134     {
 135         msg_Warn( p_obj, "not copying playlist items children" );
 136         p_res->i_children = -1;
 137         p_res->pp_children = NULL;
 138     }
 139     p_res->i_parents = 0;
 140     p_res->pp_parents = NULL;
 141
 142     if( p_item->input.psz_name )
 143         p_res->input.psz_name = strdup( p_item->input.psz_name );
 144     if( p_item->input.psz_uri )
 145         p_res->input.psz_uri = strdup( p_item->input.psz_uri );
 146
 147     if( p_item->input.i_es )
 148     {
 149         p_res->input.es =
 150             (es_format_t**)malloc( p_item->input.i_es * sizeof(es_format_t*));
 151         for( i = 0; i < p_item->input.i_es; i++ )
 152         {
 153             p_res->input.es[ i ] = (es_format_t*)malloc(sizeof(es_format_t*));
 154             es_format_Copy( p_res->input.es[ i ],
 155                          p_item->input.es[ i ] );
 156         }
 157     }
 158     if( p_item->input.i_categories )
 159     {
 160         p_res->input.pp_categories = NULL;
 161         p_res->input.i_categories = 0;
 162         for( i = 0; i < p_item->input.i_categories; i++ )
 163         {
 164             info_category_t *p_incat;
 165             p_incat = p_item->input.pp_categories[i];
 166             if( p_incat->i_infos )
 167             {
 168                 int j;
 169                 for( j = 0; j < p_incat->i_infos; j++ )
 170                 {
 171                     vlc_input_item_AddInfo( &p_res->input, p_incat->psz_name,
 172                                             p_incat->pp_infos[j]->psz_name,
 173                                             "%s", /* to be safe */
 174                                             p_incat->pp_infos[j]->psz_value );
 175                 }
 176             }
 177         }
 178     }
 179
 180     vlc_mutex_unlock( &p_item->input.lock );
 181     return p_res;
 182 }
 183
 184 /**
 185  * Deletes a playlist item
 186  *
 187  * \param p_item the item to delete
 188  * \return nothing
 189  */
 190 int playlist_ItemDelete( playlist_item_t *p_item )
 191 {
 192     vlc_mutex_lock( &p_item->input.lock );
 193
 194     if( p_item->input.psz_name ) free( p_item->input.psz_name );
 195     if( p_item->input.psz_uri ) free( p_item->input.psz_uri );
 196
 197     /* Free the info categories */
 198     if( p_item->input.i_categories > 0 )
 199     {
 200         int i, j;
 201
 202         for( i = 0; i < p_item->input.i_categories; i++ )
 203         {
 204             info_category_t *p_category = p_item->input.pp_categories[i];
 205
 206             for( j = 0; j < p_category->i_infos; j++)
 207             {
 208                 if( p_category->pp_infos[j]->psz_name )
 209                 {
 210                     free( p_category->pp_infos[j]->psz_name);
 211                 }
 212                 if( p_category->pp_infos[j]->psz_value )
 213                 {
 214                     free( p_category->pp_infos[j]->psz_value );
 215                 }
 216                 free( p_category->pp_infos[j] );
 217             }
 218
 219             if( p_category->i_infos ) free( p_category->pp_infos );
 220             if( p_category->psz_name ) free( p_category->psz_name );
 221             free( p_category );
 222         }
 223
 224         free( p_item->input.pp_categories );
 225     }
 226
 227     for( ; p_item->input.i_options > 0; p_item->input.i_options-- )
 228     {
 229         free( p_item->input.ppsz_options[p_item->input.i_options - 1] );
 230         if( p_item->input.i_options == 1 ) free( p_item->input.ppsz_options );
 231     }
 232
 233     for( ; p_item->i_parents > 0 ; )
 234     {
 235         struct item_parent_t *p_parent =  p_item->pp_parents[0];
 236         REMOVE_ELEM( p_item->pp_parents, p_item->i_parents, 0 );
 237         free( p_parent );
 238     }
 239
 240     vlc_mutex_unlock( &p_item->input.lock );
 241     vlc_mutex_destroy( &p_item->input.lock );
 242
 243     free( p_item );
 244
 245     return VLC_SUCCESS;
 246 }
 247
 248 /**
 249  *  Add a option to one item ( no need for p_playlist )
 250  *
 251  * \param p_item the item on which we want the info
 252  * \param psz_option the option
 253  * \return 0 on success
 254  */
 255 int playlist_ItemAddOption( playlist_item_t *p_item, const char *psz_option )
 256 {
 257     if( !psz_option ) return VLC_EGENERIC;
 258
 259     vlc_mutex_lock( &p_item->input.lock );
 260     INSERT_ELEM( p_item->input.ppsz_options, p_item->input.i_options,
 261                  p_item->input.i_options, strdup( psz_option ) );
 262     vlc_mutex_unlock( &p_item->input.lock );
 263
 264     return VLC_SUCCESS;
 265 }
 266
 267 /**
 268  * Add a parent to an item
 269  *
 270  * \param p_item the item
 271  * \param i_view the view in which the parent is
 272  * \param p_parent the parent to add
 273  * \return nothing
 274  */
 275 int playlist_ItemAddParent( playlist_item_t *p_item, int i_view,
 276                             playlist_item_t *p_parent )
 277 {
 278    vlc_bool_t b_found = VLC_FALSE;
 279    int i;
 280
 281    for( i= 0; i< p_item->i_parents ; i++ )
 282    {
 283        if( p_item->pp_parents[i]->i_view == i_view )
 284
 285        {
 286            b_found = VLC_TRUE;
 287            break;
 288        }
 289    }
 290    if( b_found == VLC_FALSE )
 291    {
 292
 293        struct item_parent_t *p_ip = (struct item_parent_t *)
 294                malloc(sizeof(struct item_parent_t) );
 295        p_ip->i_view = i_view;
 296        p_ip->p_parent = p_parent;
 297
 298        INSERT_ELEM( p_item->pp_parents,
 299                     p_item->i_parents, p_item->i_parents,
 300                     p_ip );
 301    }
 302    return VLC_SUCCESS;
 303 }
 304
 305 /**
 306  * Copy all parents from parent to child
 307  */
 308 int playlist_CopyParents( playlist_item_t *p_parent,
 309                            playlist_item_t *p_child )
 310 {
 311     int i=0;
 312     for( i= 0 ; i< p_parent->i_parents; i ++ )
 313     {
 314         playlist_ItemAddParent( p_child,
 315                                 p_parent->pp_parents[i]->i_view,
 316                                 p_parent );
 317     }
 318     return VLC_SUCCESS;
 319 }
 320
 321
 322 /**********************************************************************
 323  * playlist_item_t structure accessors
 324  * These functions give access to the fields of the playlist_item_t
 325  * structure
 326  **********************************************************************/
 327
 328
 329 /**
 330  * Set the name of a playlist item
 331  *
 332  * \param p_item the item
 333  * \param psz_name the new name
 334  * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
 335  */
 336 int playlist_ItemSetName( playlist_item_t *p_item, char *psz_name )
 337 {
 338     if( psz_name && p_item )
 339     {
 340         if( p_item->input.psz_name ) free( p_item->input.psz_name );
 341         p_item->input.psz_name = strdup( psz_name );
 342         return VLC_SUCCESS;
 343     }
 344     return VLC_EGENERIC;
 345 }
 346
 347 /**
 348  * Set the duration of a playlist item
 349  * This function must be entered with the item lock
 350  *
 351  * \param p_item the item
 352  * \param i_duration the new duration
 353  * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
 354  */
 355 int playlist_ItemSetDuration( playlist_item_t *p_item, mtime_t i_duration )
 356 {
 357     char psz_buffer[MSTRTIME_MAX_SIZE];
 358     if( p_item )
 359     {
 360         p_item->input.i_duration = i_duration;
 361         if( i_duration != -1 )
 362         {
 363             secstotimestr( psz_buffer, (int)(i_duration/1000000) );
 364         }
 365         else
 366         {
 367             memcpy( psz_buffer, "--:--:--", sizeof("--:--:--") );
 368         }
 369         vlc_input_item_AddInfo( &p_item->input, _("General") , _("Duration"),
 370                                 "%s", psz_buffer );
 371
 372         return VLC_SUCCESS;
 373     }
 374     return VLC_EGENERIC;
 375 }
 376
 377 /*
 378  * Guess the type of the item using the beginning of the mrl */
 379 static void GuessType( input_item_t *p_item)
 380 {
 381     int i;
 382     static struct { char *psz_search; int i_type; }  types_array[] =
 383     {
 384         { "http", ITEM_TYPE_NET },
 385         { "dvd", ITEM_TYPE_DISC },
 386         { "cdda", ITEM_TYPE_CDDA },
 387         { "mms", ITEM_TYPE_NET },
 388         { "rtsp", ITEM_TYPE_NET },
 389         { "udp", ITEM_TYPE_NET },
 390         { "rtp", ITEM_TYPE_NET },
 391         { "vcd", ITEM_TYPE_DISC },
 392         { "v4l", ITEM_TYPE_CARD },
 393         { "dshow", ITEM_TYPE_CARD },
 394         { "pvr", ITEM_TYPE_CARD },
 395         { "dvb", ITEM_TYPE_CARD },
 396         { "qpsk", ITEM_TYPE_CARD },
 397         { "sdp", ITEM_TYPE_NET },
 398         { NULL, 0 }
 399     };
 400
 401 #if 0 /* Unused */
 402     static struct { char *psz_search; int i_type; } exts_array[] =
 403     {
 404         { "mp3", ITEM_TYPE_AFILE },
 405         { NULL, 0 }
 406     };
 407 #endif
 408
 409     for( i = 0; types_array[i].psz_search != NULL; i++ )
 410     {
 411         if( !strncmp( p_item->psz_uri, types_array[i].psz_search,
 412                       strlen( types_array[i].psz_search ) ) )
 413         {
 414             p_item->i_type = types_array[i].i_type;
 415             return;
 416         }
 417     }
 418     p_item->i_type = ITEM_TYPE_VFILE;
 419 }