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., 59 Temple Place - Suite 330, Boston, MA  02111, 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     p_item->input.psz_uri = strdup( psz_uri );
  67
  68     if( psz_name != NULL ) p_item->input.psz_name = strdup( psz_name );
  69     else p_item->input.psz_name = strdup ( psz_uri );
  70
  71     p_item->input.i_type = i_type;
  72
  73     p_item->b_enabled = VLC_TRUE;
  74     p_item->i_nb_played = 0;
  75
  76     p_item->i_children = -1;
  77     p_item->pp_children = NULL;
  78
  79     p_item->i_flags = 0;
  80     p_item->i_flags |= PLAYLIST_SKIP_FLAG;
  81     p_item->i_flags |= PLAYLIST_SAVE_FLAG;
  82
  83     p_item->input.i_duration = -1;
  84     p_item->input.ppsz_options = NULL;
  85     p_item->input.i_options = 0;
  86
  87     vlc_mutex_init( p_obj, &p_item->input.lock );
  88
  89     if( p_item->input.i_type == ITEM_TYPE_UNKNOWN )
  90         GuessType( &p_item->input );
  91
  92     return p_item;
  93 }
  94
  95 /**
  96  * Copy a playlist item
  97  *
  98  * Creates a new item with name, mrl and meta infor like the
  99  * source. Does not copy children for node type items.
 100  * \param p_obj any vlc object, needed for mutex init
 101  * \param p_item the item to copy
 102  * \return pointer to the new item, or NULL on error
 103  * \note function takes the lock on p_item
 104  */
 105 playlist_item_t *__playlist_ItemCopy( vlc_object_t *p_obj,
 106                                       playlist_item_t *p_item )
 107 {
 108     playlist_item_t *p_res;
 109     int i;
 110     vlc_mutex_lock( &p_item->input.lock );
 111
 112     p_res = malloc( sizeof( playlist_item_t ) );
 113     if( p_res == NULL )
 114     {
 115         vlc_mutex_unlock( &p_item->input.lock );
 116         return NULL;
 117     }
 118
 119     *p_res = *p_item;
 120     vlc_mutex_init( p_obj, &p_res->input.lock );
 121
 122     if( p_item->input.i_options )
 123         p_res->input.ppsz_options =
 124             malloc( p_item->input.i_options * sizeof(char*) );
 125     for( i = 0; i < p_item->input.i_options; i++ )
 126     {
 127         p_res->input.ppsz_options[i] = strdup( p_item->input.ppsz_options[i] );
 128     }
 129
 130     if( p_item->i_children != -1 )
 131     {
 132         msg_Warn( p_obj, "not copying playlist items children" );
 133         p_res->i_children = -1;
 134         p_res->pp_children = NULL;
 135     }
 136     p_res->i_parents = 0;
 137     p_res->pp_parents = NULL;
 138
 139     if( p_item->input.psz_name )
 140         p_res->input.psz_name = strdup( p_item->input.psz_name );
 141     if( p_item->input.psz_uri )
 142         p_res->input.psz_uri = strdup( p_item->input.psz_uri );
 143
 144     if( p_item->input.i_es )
 145     {
 146         p_res->input.es =
 147             (es_format_t**)malloc( p_item->input.i_es * sizeof(es_format_t*));
 148         for( i = 0; i < p_item->input.i_es; i++ )
 149         {
 150             p_res->input.es[ i ] = (es_format_t*)malloc(sizeof(es_format_t*));
 151             es_format_Copy( p_res->input.es[ i ],
 152                          p_item->input.es[ i ] );
 153         }
 154     }
 155     if( p_item->input.i_categories )
 156     {
 157         p_res->input.pp_categories = NULL;
 158         p_res->input.i_categories = 0;
 159         for( i = 0; i < p_item->input.i_categories; i++ )
 160         {
 161             info_category_t *p_incat;
 162             p_incat = p_item->input.pp_categories[i];
 163             if( p_incat->i_infos )
 164             {
 165                 int j;
 166                 for( j = 0; j < p_incat->i_infos; j++ )
 167                 {
 168                     vlc_input_item_AddInfo( &p_res->input, p_incat->psz_name,
 169                                             p_incat->pp_infos[j]->psz_name,
 170                                             "%s", /* to be safe */
 171                                             p_incat->pp_infos[j]->psz_value );
 172                 }
 173             }
 174         }
 175     }
 176
 177     vlc_mutex_unlock( &p_item->input.lock );
 178     return p_res;
 179 }
 180
 181 /**
 182  * Deletes a playlist item
 183  *
 184  * \param p_item the item to delete
 185  * \return nothing
 186  */
 187 int playlist_ItemDelete( playlist_item_t *p_item )
 188 {
 189     vlc_mutex_lock( &p_item->input.lock );
 190
 191     if( p_item->input.psz_name ) free( p_item->input.psz_name );
 192     if( p_item->input.psz_uri ) free( p_item->input.psz_uri );
 193
 194     /* Free the info categories */
 195     if( p_item->input.i_categories > 0 )
 196     {
 197         int i, j;
 198
 199         for( i = 0; i < p_item->input.i_categories; i++ )
 200         {
 201             info_category_t *p_category = p_item->input.pp_categories[i];
 202
 203             for( j = 0; j < p_category->i_infos; j++)
 204             {
 205                 if( p_category->pp_infos[j]->psz_name )
 206                 {
 207                     free( p_category->pp_infos[j]->psz_name);
 208                 }
 209                 if( p_category->pp_infos[j]->psz_value )
 210                 {
 211                     free( p_category->pp_infos[j]->psz_value );
 212                 }
 213                 free( p_category->pp_infos[j] );
 214             }
 215
 216             if( p_category->i_infos ) free( p_category->pp_infos );
 217             if( p_category->psz_name ) free( p_category->psz_name );
 218             free( p_category );
 219         }
 220
 221         free( p_item->input.pp_categories );
 222     }
 223
 224     for( ; p_item->input.i_options > 0; p_item->input.i_options-- )
 225     {
 226         free( p_item->input.ppsz_options[p_item->input.i_options - 1] );
 227         if( p_item->input.i_options == 1 ) free( p_item->input.ppsz_options );
 228     }
 229
 230     for( ; p_item->i_parents > 0 ; )
 231     {
 232         struct item_parent_t *p_parent =  p_item->pp_parents[0];
 233         REMOVE_ELEM( p_item->pp_parents, p_item->i_parents, 0 );
 234         free( p_parent );
 235     }
 236
 237     vlc_mutex_unlock( &p_item->input.lock );
 238     vlc_mutex_destroy( &p_item->input.lock );
 239
 240     free( p_item );
 241
 242     return VLC_SUCCESS;
 243 }
 244
 245 /**
 246  *  Add a option to one item ( no need for p_playlist )
 247  *
 248  * \param p_item the item on which we want the info
 249  * \param psz_option the option
 250  * \return 0 on success
 251  */
 252 int playlist_ItemAddOption( playlist_item_t *p_item, const char *psz_option )
 253 {
 254     if( !psz_option ) return VLC_EGENERIC;
 255
 256     vlc_mutex_lock( &p_item->input.lock );
 257     INSERT_ELEM( p_item->input.ppsz_options, p_item->input.i_options,
 258                  p_item->input.i_options, strdup( psz_option ) );
 259     vlc_mutex_unlock( &p_item->input.lock );
 260
 261     return VLC_SUCCESS;
 262 }
 263
 264 /**
 265  * Add a parent to an item
 266  *
 267  * \param p_item the item
 268  * \param i_view the view in which the parent is
 269  * \param p_parent the parent to add
 270  * \return nothing
 271  */
 272 int playlist_ItemAddParent( playlist_item_t *p_item, int i_view,
 273                             playlist_item_t *p_parent )
 274 {
 275    vlc_bool_t b_found = VLC_FALSE;
 276    int i;
 277
 278    for( i= 0; i< p_item->i_parents ; i++ )
 279    {
 280        if( p_item->pp_parents[i]->i_view == i_view )
 281
 282        {
 283            b_found = VLC_TRUE;
 284            break;
 285        }
 286    }
 287    if( b_found == VLC_FALSE )
 288    {
 289
 290        struct item_parent_t *p_ip = (struct item_parent_t *)
 291                malloc(sizeof(struct item_parent_t) );
 292        p_ip->i_view = i_view;
 293        p_ip->p_parent = p_parent;
 294
 295        INSERT_ELEM( p_item->pp_parents,
 296                     p_item->i_parents, p_item->i_parents,
 297                     p_ip );
 298    }
 299    return VLC_SUCCESS;
 300 }
 301
 302 /**
 303  * Copy all parents from parent to child
 304  */
 305 int playlist_CopyParents( playlist_item_t *p_parent,
 306                            playlist_item_t *p_child )
 307 {
 308     int i=0;
 309     for( i= 0 ; i< p_parent->i_parents; i ++ )
 310     {
 311         playlist_ItemAddParent( p_child,
 312                                 p_parent->pp_parents[i]->i_view,
 313                                 p_parent );
 314     }
 315     return VLC_SUCCESS;
 316 }
 317
 318
 319 /**********************************************************************
 320  * playlist_item_t structure accessors
 321  * These functions give access to the fields of the playlist_item_t
 322  * structure
 323  **********************************************************************/
 324
 325
 326 /**
 327  * Set the name of a playlist item
 328  *
 329  * \param p_item the item
 330  * \param psz_name the new name
 331  * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
 332  */
 333 int playlist_ItemSetName( playlist_item_t *p_item, char *psz_name )
 334 {
 335     if( psz_name && p_item )
 336     {
 337         if( p_item->input.psz_name ) free( p_item->input.psz_name );
 338         p_item->input.psz_name = strdup( psz_name );
 339         return VLC_SUCCESS;
 340     }
 341     return VLC_EGENERIC;
 342 }
 343
 344 /**
 345  * Set the duration of a playlist item
 346  * This function must be entered with the item lock
 347  *
 348  * \param p_item the item
 349  * \param i_duration the new duration
 350  * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
 351  */
 352 int playlist_ItemSetDuration( playlist_item_t *p_item, mtime_t i_duration )
 353 {
 354     char psz_buffer[MSTRTIME_MAX_SIZE];
 355     if( p_item )
 356     {
 357         p_item->input.i_duration = i_duration;
 358         if( i_duration != -1 )
 359         {
 360             secstotimestr( psz_buffer, (int)(i_duration/1000000) );
 361         }
 362         else
 363         {
 364             memcpy( psz_buffer, "--:--:--", sizeof("--:--:--") );
 365         }
 366         vlc_input_item_AddInfo( &p_item->input, _("General") , _("Duration"),
 367                                 "%s", psz_buffer );
 368
 369         return VLC_SUCCESS;
 370     }
 371     return VLC_EGENERIC;
 372 }
 373
 374 /*
 375  * Guess the type of the item using the beginning of the mrl */
 376 static void GuessType( input_item_t *p_item)
 377 {
 378     int i;
 379     static struct { char *psz_search; int i_type; }  types_array[] =
 380     {
 381         { "http", ITEM_TYPE_NET },
 382         { "dvd", ITEM_TYPE_DISC },
 383         { "cdda", ITEM_TYPE_CDDA },
 384         { "mms", ITEM_TYPE_NET },
 385         { "rtsp", ITEM_TYPE_NET },
 386         { "udp", ITEM_TYPE_NET },
 387         { "rtp", ITEM_TYPE_NET },
 388         { "vcd", ITEM_TYPE_DISC },
 389         { "v4l", ITEM_TYPE_CARD },
 390         { "dshow", ITEM_TYPE_CARD },
 391         { "pvr", ITEM_TYPE_CARD },
 392         { "dvb", ITEM_TYPE_CARD },
 393         { "qpsk", ITEM_TYPE_CARD },
 394         { "sdp", ITEM_TYPE_NET },
 395         { NULL, 0 }
 396     };
 397
 398 #if 0 /* Unused */
 399     static struct { char *psz_search; int i_type; } exts_array[] =
 400     {
 401         { "mp3", ITEM_TYPE_AFILE },
 402         { NULL, 0 }
 403     };
 404 #endif
 405
 406     for( i = 0; types_array[i].psz_search != NULL; i++ )
 407     {
 408         if( !strncmp( p_item->psz_uri, types_array[i].psz_search,
 409                       strlen( types_array[i].psz_search ) ) )
 410         {
 411             p_item->i_type = types_array[i].i_type;
 412             return;
 413         }
 414     }
 415     p_item->i_type = ITEM_TYPE_VFILE;
 416 }