1 /*****************************************************************************
2 * item.c : Playlist item functions
3 *****************************************************************************
4 * Copyright (C) 1999-2004 the VideoLAN team
7 * Authors: Samuel Hocevar <sam@zoy.org>
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.
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.
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() */
28 #include <vlc/input.h>
30 #include "vlc_input.h"
31 #include "vlc_playlist.h"
33 static void GuessType( input_item_t *p_item);
36 * Create a new item, without adding it to the playlist
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
44 playlist_item_t * __playlist_ItemNew( vlc_object_t *p_obj,
46 const char *psz_name )
48 return playlist_ItemNewWithType( p_obj, psz_uri,
49 psz_name, ITEM_TYPE_UNKNOWN );
52 playlist_item_t * playlist_ItemNewWithType( vlc_object_t *p_obj,
57 playlist_item_t * p_item;
59 if( psz_uri == NULL) return NULL;
61 p_item = malloc( sizeof( playlist_item_t ) );
62 if( p_item == NULL ) return NULL;
64 memset( p_item, 0, sizeof( playlist_item_t ) );
66 vlc_input_item_Init( p_obj, &p_item->input );
68 p_item->input.psz_uri = strdup( psz_uri );
70 if( psz_name != NULL ) p_item->input.psz_name = strdup( psz_name );
71 else p_item->input.psz_name = strdup ( psz_uri );
73 p_item->input.i_type = i_type;
75 p_item->b_enabled = VLC_TRUE;
76 p_item->i_nb_played = 0;
78 p_item->i_children = -1;
79 p_item->pp_children = NULL;
82 p_item->i_flags |= PLAYLIST_SKIP_FLAG;
83 p_item->i_flags |= PLAYLIST_SAVE_FLAG;
85 p_item->input.i_duration = -1;
86 p_item->input.ppsz_options = NULL;
87 p_item->input.i_options = 0;
89 vlc_mutex_init( p_obj, &p_item->input.lock );
91 if( p_item->input.i_type == ITEM_TYPE_UNKNOWN )
92 GuessType( &p_item->input );
98 * Copy a playlist item
100 * Creates a new item with name, mrl and meta infor like the
101 * source. Does not copy children for node type items.
102 * \param p_obj any vlc object, needed for mutex init
103 * \param p_item the item to copy
104 * \return pointer to the new item, or NULL on error
105 * \note function takes the lock on p_item
107 playlist_item_t *__playlist_ItemCopy( vlc_object_t *p_obj,
108 playlist_item_t *p_item )
110 playlist_item_t *p_res;
112 vlc_mutex_lock( &p_item->input.lock );
114 p_res = malloc( sizeof( playlist_item_t ) );
117 vlc_mutex_unlock( &p_item->input.lock );
122 vlc_mutex_init( p_obj, &p_res->input.lock );
124 if( p_item->input.i_options )
125 p_res->input.ppsz_options =
126 malloc( p_item->input.i_options * sizeof(char*) );
127 for( i = 0; i < p_item->input.i_options; i++ )
129 p_res->input.ppsz_options[i] = strdup( p_item->input.ppsz_options[i] );
132 if( p_item->i_children != -1 )
134 msg_Warn( p_obj, "not copying playlist items children" );
135 p_res->i_children = -1;
136 p_res->pp_children = NULL;
138 p_res->i_parents = 0;
139 p_res->pp_parents = NULL;
141 if( p_item->input.psz_name )
142 p_res->input.psz_name = strdup( p_item->input.psz_name );
143 if( p_item->input.psz_uri )
144 p_res->input.psz_uri = strdup( p_item->input.psz_uri );
146 if( p_item->input.i_es )
149 (es_format_t**)malloc( p_item->input.i_es * sizeof(es_format_t*));
150 for( i = 0; i < p_item->input.i_es; i++ )
152 p_res->input.es[ i ] = (es_format_t*)malloc(sizeof(es_format_t*));
153 es_format_Copy( p_res->input.es[ i ],
154 p_item->input.es[ i ] );
157 if( p_item->input.i_categories )
159 p_res->input.pp_categories = NULL;
160 p_res->input.i_categories = 0;
161 for( i = 0; i < p_item->input.i_categories; i++ )
163 info_category_t *p_incat;
164 p_incat = p_item->input.pp_categories[i];
165 if( p_incat->i_infos )
168 for( j = 0; j < p_incat->i_infos; j++ )
170 vlc_input_item_AddInfo( &p_res->input, p_incat->psz_name,
171 p_incat->pp_infos[j]->psz_name,
172 "%s", /* to be safe */
173 p_incat->pp_infos[j]->psz_value );
179 vlc_mutex_unlock( &p_item->input.lock );
184 * Deletes a playlist item
186 * \param p_item the item to delete
189 int playlist_ItemDelete( playlist_item_t *p_item )
191 vlc_mutex_lock( &p_item->input.lock );
193 if( p_item->input.psz_name ) free( p_item->input.psz_name );
194 if( p_item->input.psz_uri ) free( p_item->input.psz_uri );
196 /* Free the info categories */
197 if( p_item->input.i_categories > 0 )
201 for( i = 0; i < p_item->input.i_categories; i++ )
203 info_category_t *p_category = p_item->input.pp_categories[i];
205 for( j = 0; j < p_category->i_infos; j++)
207 if( p_category->pp_infos[j]->psz_name )
209 free( p_category->pp_infos[j]->psz_name);
211 if( p_category->pp_infos[j]->psz_value )
213 free( p_category->pp_infos[j]->psz_value );
215 free( p_category->pp_infos[j] );
218 if( p_category->i_infos ) free( p_category->pp_infos );
219 if( p_category->psz_name ) free( p_category->psz_name );
223 free( p_item->input.pp_categories );
226 for( ; p_item->input.i_options > 0; p_item->input.i_options-- )
228 free( p_item->input.ppsz_options[p_item->input.i_options - 1] );
229 if( p_item->input.i_options == 1 ) free( p_item->input.ppsz_options );
232 for( ; p_item->i_parents > 0 ; )
234 struct item_parent_t *p_parent = p_item->pp_parents[0];
235 REMOVE_ELEM( p_item->pp_parents, p_item->i_parents, 0 );
239 vlc_mutex_unlock( &p_item->input.lock );
240 vlc_mutex_destroy( &p_item->input.lock );
248 * Add a option to one item ( no need for p_playlist )
250 * \param p_item the item on which we want the info
251 * \param psz_option the option
252 * \return 0 on success
254 int playlist_ItemAddOption( playlist_item_t *p_item, const char *psz_option )
256 if( !psz_option ) return VLC_EGENERIC;
258 vlc_mutex_lock( &p_item->input.lock );
259 INSERT_ELEM( p_item->input.ppsz_options, p_item->input.i_options,
260 p_item->input.i_options, strdup( psz_option ) );
261 vlc_mutex_unlock( &p_item->input.lock );
267 * Add a parent to an item
269 * \param p_item the item
270 * \param i_view the view in which the parent is
271 * \param p_parent the parent to add
274 int playlist_ItemAddParent( playlist_item_t *p_item, int i_view,
275 playlist_item_t *p_parent )
277 vlc_bool_t b_found = VLC_FALSE;
280 for( i= 0; i< p_item->i_parents ; i++ )
282 if( p_item->pp_parents[i]->i_view == i_view )
289 if( b_found == VLC_FALSE )
292 struct item_parent_t *p_ip = (struct item_parent_t *)
293 malloc(sizeof(struct item_parent_t) );
294 p_ip->i_view = i_view;
295 p_ip->p_parent = p_parent;
297 INSERT_ELEM( p_item->pp_parents,
298 p_item->i_parents, p_item->i_parents,
305 * Copy all parents from parent to child
307 int playlist_CopyParents( playlist_item_t *p_parent,
308 playlist_item_t *p_child )
311 for( i= 0 ; i< p_parent->i_parents; i ++ )
313 playlist_ItemAddParent( p_child,
314 p_parent->pp_parents[i]->i_view,
321 /**********************************************************************
322 * playlist_item_t structure accessors
323 * These functions give access to the fields of the playlist_item_t
325 **********************************************************************/
329 * Set the name of a playlist item
331 * \param p_item the item
332 * \param psz_name the new name
333 * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
335 int playlist_ItemSetName( playlist_item_t *p_item, char *psz_name )
337 if( psz_name && p_item )
339 if( p_item->input.psz_name ) free( p_item->input.psz_name );
340 p_item->input.psz_name = strdup( psz_name );
347 * Set the duration of a playlist item
348 * This function must be entered with the item lock
350 * \param p_item the item
351 * \param i_duration the new duration
352 * \return VLC_SUCCESS on success, VLC_EGENERIC on failure
354 int playlist_ItemSetDuration( playlist_item_t *p_item, mtime_t i_duration )
356 char psz_buffer[MSTRTIME_MAX_SIZE];
359 p_item->input.i_duration = i_duration;
360 if( i_duration != -1 )
362 secstotimestr( psz_buffer, (int)(i_duration/1000000) );
366 memcpy( psz_buffer, "--:--:--", sizeof("--:--:--") );
368 vlc_input_item_AddInfo( &p_item->input, _("General") , _("Duration"),
377 * Guess the type of the item using the beginning of the mrl */
378 static void GuessType( input_item_t *p_item)
381 static struct { char *psz_search; int i_type; } types_array[] =
383 { "http", ITEM_TYPE_NET },
384 { "dvd", ITEM_TYPE_DISC },
385 { "cdda", ITEM_TYPE_CDDA },
386 { "mms", ITEM_TYPE_NET },
387 { "rtsp", ITEM_TYPE_NET },
388 { "udp", ITEM_TYPE_NET },
389 { "rtp", ITEM_TYPE_NET },
390 { "vcd", ITEM_TYPE_DISC },
391 { "v4l", ITEM_TYPE_CARD },
392 { "dshow", ITEM_TYPE_CARD },
393 { "pvr", ITEM_TYPE_CARD },
394 { "dvb", ITEM_TYPE_CARD },
395 { "qpsk", ITEM_TYPE_CARD },
396 { "sdp", ITEM_TYPE_NET },
401 static struct { char *psz_search; int i_type; } exts_array[] =
403 { "mp3", ITEM_TYPE_AFILE },
408 for( i = 0; types_array[i].psz_search != NULL; i++ )
410 if( !strncmp( p_item->psz_uri, types_array[i].psz_search,
411 strlen( types_array[i].psz_search ) ) )
413 p_item->i_type = types_array[i].i_type;
417 p_item->i_type = ITEM_TYPE_VFILE;