Commit f9d5e2ba authored by Clément Stenac's avatar Clément Stenac

Improvements to the playlist core

parent 07ec1808
......@@ -205,17 +205,21 @@ typedef struct msg_subscription_t msg_subscription_t;
* Playlist commands
*/
typedef enum {
PLAYLIST_PLAY, /**< Starts playing. No arg. */
PLAYLIST_PAUSE, /**< Toggles playlist pause. No arg. */
PLAYLIST_STOP, /**< Stops playing. No arg. */
PLAYLIST_SKIP, /**< Skip X items and play. */
PLAYLIST_GOTO, /**< Goto Xth item. */
PLAYLIST_PLAY, /**< No arg. res=can fail*/
PLAYLIST_VIEWPLAY, /**< arg1= int, arg2= playlist_item_t*,*/
/** arg3 = playlist_item_t* , res=can fail */
PLAYLIST_ITEMPLAY, /** <arg1 = playlist_item_t * , res=can fail */
PLAYLIST_PAUSE, /**< No arg res=can fail*/
PLAYLIST_STOP, /**< No arg res=can fail*/
PLAYLIST_SKIP, /**< arg1=int, res=can fail*/
PLAYLIST_GOTO, /**< arg1=int res=can fail */
PLAYLIST_VIEWGOTO, /**< arg1=int res=can fail */
} playlist_command_t;
typedef struct playlist_t playlist_t;
typedef struct playlist_item_t playlist_item_t;
typedef struct playlist_group_t playlist_group_t;
typedef struct playlist_view_t playlist_view_t;
typedef struct playlist_export_t playlist_export_t;
/* Modules */
......
......@@ -53,6 +53,9 @@ struct input_item_t
mtime_t i_duration; /**< A hint about the duration of this
* item, in milliseconds*/
int i_id; /**< Identifier of the item */
uint8_t i_type; /**< Type (file, disc, ...) */
int i_categories; /**< Number of info categories */
info_category_t **pp_categories; /**< Pointer to the first info category */
......@@ -62,14 +65,26 @@ struct input_item_t
vlc_mutex_t lock; /**< Item cannot be changed without this lock */
};
#define ITEM_TYPE_UNKNOWN 0
#define ITEM_TYPE_FILE 1
#define ITEM_TYPE_DIRECTORY 2
#define ITEM_TYPE_DISC 3
#define ITEM_TYPE_CARD 4
#define ITEM_TYPE_NET 5
#define ITEM_TYPE_PLAYLIST 6
static inline void vlc_input_item_Init( vlc_object_t *p_o, input_item_t *p_i )
{
memset( p_i, 0, sizeof(input_item_t) );
p_i->i_options = 0;
p_i->i_es = 0;
p_i->i_categories = 0 ;
p_i->psz_name = 0;
p_i->psz_uri = 0;
p_i->ppsz_options = 0;
p_i->pp_categories = 0;
p_i->es = 0;
p_i->i_type = ITEM_TYPE_UNKNOWN;
vlc_mutex_init( p_o, &p_i->lock );
}
......
......@@ -232,5 +232,7 @@ static inline int StringToKey( char *psz_key )
#define ACTIONID_HISTORY_FORWARD 49
#define ACTIONID_AUDIO_TRACK 50
#define ACTIONID_SUBTITLE_TRACK 51
#define ACTIONID_CUBESPEED_UP 52
#define ACTIONID_CUBESPEED_DOWN 53
#define ACTIONID_INTF_SHOW 52
......@@ -42,35 +42,71 @@ struct playlist_export_t
FILE *p_file;
};
struct item_parent_t
{
int i_view;
playlist_item_t *p_parent;
};
/**
* playlist item
* playlist item / node
* \see playlist_t
*/
struct playlist_item_t
{
input_item_t input; /**< input item descriptor */
int i_nb_played; /**< How many times was this item played ? */
vlc_bool_t b_autodeletion; /**< Indicates whther this item is to
* be deleted after playback. True mean
* that this item is to be deleted
* after playback, false otherwise */
vlc_bool_t b_enabled; /**< Indicates whether this item is to be
* played or skipped */
int i_group; /**< Which group does this item belongs to ? */
int i_id; /**< Unique id to track this item */
input_item_t input; /**< input item descriptor */
/* Tree specific fields */
int i_children; /**< Number of children
-1 if not a node */
playlist_item_t **pp_children; /**< Children nodes/items */
int i_parents; /**< Number of parents */
struct item_parent_t **pp_parents; /**< Parents */
int i_serial; /**< Has this node been updated ? */
uint8_t i_flags; /**< Flags */
int i_nb_played; /**< How many times was this item played ? */
vlc_bool_t b_autodeletion; /**< Indicates whther this item is to
* be deleted after playback. True mean
* that this item is to be deleted
* after playback, false otherwise */
vlc_bool_t b_enabled; /**< Indicates whether this item is to be
* played or skipped */
};
#define PLAYLIST_SAVE_FLAG 0x1 /**< Must it be saved */
#define PLAYLIST_SKIP_FLAG 0x2 /**< Must playlist skip after it ? */
#define PLAYLIST_ENA_FLAG 0x4 /**< Is it enabled ? */
#define PLAYLIST_DEL_FLAG 0x8 /**< Autodelete ? */
/**
* playlist group
* playlist view
* \see playlist_t
*/
struct playlist_group_t
*/
struct playlist_view_t
{
char * psz_name; /**< name of the group */
int i_id; /**< Identifier for the group */
char * psz_name; /**< View name */
int i_id; /**< Identifier for the view */
playlist_item_t * p_root; /**< Root node */
};
/**
* predefined views
*
*/
#define VIEW_CATEGORY 1
#define VIEW_SIMPLE 2
#define VIEW_ALL 3
#define VIEW_FIRST_SORTED 4
#define VIEW_S_AUTHOR 4
#define VIEW_LAST_SORTED 4
#define VIEW_FIRST_CUSTOM 100
/**
* Playlist status
*/
......@@ -88,93 +124,153 @@ struct playlist_t
*/
/*@{*/
int i_index; /**< current index into the playlist */
playlist_status_t i_status; /**< current status of playlist */
int i_size; /**< total size of the list */
int i_enabled; /**< How many items are enabled ? */
int i_size; /**< total size of the list */
playlist_item_t ** pp_items; /**< array of pointers to the
* playlist items */
int i_groups; /**< How many groups are in the playlist */
playlist_group_t ** pp_groups;/**< array of pointers to the playlist
* groups */
int i_last_group; /**< Maximal group id given */
int i_views; /**< Number of views */
playlist_view_t ** pp_views; /**< array of pointers to the
* playlist views */
input_thread_t * p_input; /**< the input thread ascosiated
* with the current item */
mtime_t request_date; /**< Used for profiling */
int i_last_id; /**< Last id to an item */
int i_sort; /**< Last sorting applied to the playlist */
int i_order; /**< Last ordering applied to the playlist */
playlist_item_t * p_general; /**< Keep a pointer on the "general"
category */
vlc_bool_t b_go_next; /*< Go further than the parent node ? */
struct {
/* Current status */
playlist_status_t i_status; /**< Current status of playlist */
/* R/O fields, don't touch if you aren't the playlist thread */
/* Use a request */
playlist_item_t * p_item; /**< Currently playing/active item */
playlist_item_t * p_node; /**< Current node to play from */
int i_view; /**< Current view */
} status;
struct {
/* Request */
/* Playlist thread uses this info to calculate the next position */
int i_view; /**< requested view id */
playlist_item_t * p_node; /**< requested node to play from */
playlist_item_t * p_item; /**< requested item to play in the node */
int i_skip; /**< Number of items to skip */
int i_goto; /**< Direct index to go to (non-view)*/
vlc_bool_t b_request; /**< Set to true by the requester
The playlist sets it back to false
when processing the request */
vlc_mutex_t lock; /**< Lock to protect request */
} request;
/*@}*/
};
#define SORT_ID 0
#define SORT_TITLE 1
#define SORT_AUTHOR 2
#define SORT_GROUP 3
#define SORT_RANDOM 4
#define SORT_DURATION 5
#define ORDER_NORMAL 0
#define ORDER_REVERSE 1
#define PLAYLIST_TYPE_MANUAL 1
#define PLAYLIST_TYPE_SAP 2
/*****************************************************************************
* Prototypes
*****************************************************************************/
/* Creation/Deletion */
#define playlist_Create(a) __playlist_Create(VLC_OBJECT(a))
playlist_t * __playlist_Create ( vlc_object_t * );
void playlist_Destroy ( playlist_t * );
#define playlist_Play(p) playlist_Command(p,PLAYLIST_PLAY,0)
#define playlist_Pause(p) playlist_Command(p,PLAYLIST_PAUSE,0)
#define playlist_Stop(p) playlist_Command(p,PLAYLIST_STOP,0)
#define playlist_Next(p) playlist_Command(p,PLAYLIST_SKIP,1)
#define playlist_Prev(p) playlist_Command(p,PLAYLIST_SKIP,-1)
#define playlist_Skip(p,i) playlist_Command(p,PLAYLIST_SKIP,i)
#define playlist_Goto(p,i) playlist_Command(p,PLAYLIST_GOTO,i)
/* Playlist control */
#define playlist_Play(p) playlist_Control(p,PLAYLIST_PLAY )
#define playlist_Pause(p) playlist_Control(p,PLAYLIST_PAUSE )
#define playlist_Stop(p) playlist_Control(p,PLAYLIST_STOP )
#define playlist_Next(p) playlist_Control(p,PLAYLIST_SKIP , 1)
#define playlist_Prev(p) playlist_Control(p,PLAYLIST_SKIP , -1)
#define playlist_Skip(p,i) playlist_Control(p,PLAYLIST_SKIP,i)
#define playlist_Goto(p,i) playlist_Control(p,PLAYLIST_GOTO,i)
VLC_EXPORT( void, playlist_Command, ( playlist_t *, playlist_command_t, int ) );
VLC_EXPORT( int, playlist_Control, ( playlist_t *, int, ... ) );
VLC_EXPORT( int, playlist_Clear, ( playlist_t * ) );
/* Item management functions */
/* Item management functions (act on items) */
#define playlist_AddItem(p,pi,i1,i2) playlist_ItemAdd(p,pi,i1,i2)
#define playlist_ItemNew( a , b, c ) __playlist_ItemNew(VLC_OBJECT(a) , b , c )
VLC_EXPORT( playlist_item_t* , __playlist_ItemNew, ( vlc_object_t *,const char *,const char * ) );
VLC_EXPORT( void, playlist_ItemDelete, ( playlist_item_t * ) );
VLC_EXPORT( int, playlist_ItemAdd, ( playlist_t *, playlist_item_t *, int, int ) );
VLC_EXPORT( void, playlist_ItemAddParent, ( playlist_item_t *, int,playlist_item_t *) );
/* Item informations accessors */
VLC_EXPORT( int, playlist_ItemSetName, (playlist_item_t *, char * ) );
VLC_EXPORT( int, playlist_ItemSetDuration, (playlist_item_t *, mtime_t ) );
/* Simple add/remove funcctions */
/* View management functions */
VLC_EXPORT( int, playlist_ViewInsert, (playlist_t *, int, char * ) );
VLC_EXPORT( void, playlist_ViewDelete, (playlist_t *,playlist_view_t* ) );
VLC_EXPORT( playlist_view_t *, playlist_ViewFind, (playlist_t *, int ) );
VLC_EXPORT( int, playlist_ViewUpdate, (playlist_t *, int ) );
VLC_EXPORT( void, playlist_ViewDump, (playlist_t *, playlist_view_t * ) );
VLC_EXPORT( int, playlist_ViewEmpty, (playlist_t *, int, vlc_bool_t ) );
/* Node management */
VLC_EXPORT( playlist_item_t *, playlist_NodeCreate, ( playlist_t *,int,char *, playlist_item_t * p_parent ) );
VLC_EXPORT( int, playlist_NodeAppend, (playlist_t *,int,playlist_item_t*,playlist_item_t *) );
VLC_EXPORT( int, playlist_NodeInsert, (playlist_t *,int,playlist_item_t*,playlist_item_t *, int) );
VLC_EXPORT( int, playlist_NodeRemoveItem, (playlist_t *,playlist_item_t*,playlist_item_t *) );
VLC_EXPORT( int, playlist_NodeChildrenCount, (playlist_t *,playlist_item_t* ) );
VLC_EXPORT( playlist_item_t *, playlist_ChildSearchName, (playlist_item_t*, const char* ) );
VLC_EXPORT( int, playlist_NodeDelete, ( playlist_t *, playlist_item_t *, vlc_bool_t ) );
VLC_EXPORT( int, playlist_NodeEmpty, ( playlist_t *, playlist_item_t *, vlc_bool_t ) );
/* Tree walking */
playlist_item_t *playlist_FindNextFromParent( playlist_t *p_playlist,
int i_view,
playlist_item_t *p_root,
playlist_item_t *p_node,
playlist_item_t *p_item );
playlist_item_t *playlist_FindPrevFromParent( playlist_t *p_playlist,
int i_view,
playlist_item_t *p_root,
playlist_item_t *p_node,
playlist_item_t *p_item );
/* Simple add/remove functions */
/* These functions add the item to the "simple" view (+all & category )*/
VLC_EXPORT( int, playlist_Add, ( playlist_t *, const char *, const char *, int, int ) );
VLC_EXPORT( int, playlist_AddExt, ( playlist_t *, const char *, const char *, int, int, mtime_t, const char **,int ) );
VLC_EXPORT( int, playlist_ItemAdd, ( playlist_t *, playlist_item_t *, int, int ) );
VLC_EXPORT(int, playlist_NodeAddItem, ( playlist_t *, playlist_item_t *,int,playlist_item_t *,int , int ) );
VLC_EXPORT( int, playlist_Clear, ( playlist_t * ) );
/* Misc item operations (act on item+playlist) */
VLC_EXPORT( int, playlist_Delete, ( playlist_t *, int ) );
VLC_EXPORT( int, playlist_Disable, ( playlist_t *, int ) );
VLC_EXPORT( int, playlist_Enable, ( playlist_t *, int ) );
VLC_EXPORT( int, playlist_DisableGroup, ( playlist_t *, int ) );
VLC_EXPORT( int, playlist_EnableGroup, ( playlist_t *, int ) );
/* Basic item information accessors */
VLC_EXPORT( int, playlist_ItemSetGroup, (playlist_item_t *, int ) );
VLC_EXPORT( int, playlist_ItemSetName, (playlist_item_t *, char * ) );
VLC_EXPORT( int, playlist_ItemSetDuration, (playlist_item_t *, mtime_t ) );
VLC_EXPORT( int, playlist_Disable, ( playlist_t *, playlist_item_t * ) );
VLC_EXPORT( int, playlist_Enable, ( playlist_t *, playlist_item_t * ) );
VLC_EXPORT( void, playlist_ItemToNode, (playlist_t *,playlist_item_t *) );
VLC_EXPORT( int, playlist_SetGroup, (playlist_t * , int , int ) );
VLC_EXPORT( int, playlist_SetName, (playlist_t *, int , char * ) );
VLC_EXPORT( int, playlist_SetDuration, (playlist_t *, int , mtime_t ) );
/* Item search functions */
VLC_EXPORT( int, playlist_GetPositionById, (playlist_t *, int) );
VLC_EXPORT( playlist_item_t *, playlist_ItemGetById, (playlist_t *, int) );
VLC_EXPORT( playlist_item_t *, playlist_ItemGetByPos, (playlist_t *, int) );
/* Group management functions */
VLC_EXPORT( playlist_group_t *, playlist_CreateGroup, (playlist_t *, char* ) );
VLC_EXPORT( int, playlist_DeleteGroup, (playlist_t *, int ) );
VLC_EXPORT( char *, playlist_FindGroup, (playlist_t *, int ) );
VLC_EXPORT( int, playlist_GroupToId, (playlist_t *, char * ) );
VLC_EXPORT( int, playlist_GetPositionById, (playlist_t *,int ) );
/* Info functions */
VLC_EXPORT( char * , playlist_GetInfo, ( playlist_t * , int, const char *, const char *) );
......@@ -186,8 +282,6 @@ VLC_EXPORT( info_category_t*, playlist_ItemCreateCategory, ( playlist_item_t *,
VLC_EXPORT( int, playlist_AddInfo, (playlist_t *, int, const char * , const char *, const char *, ...) );
VLC_EXPORT( int, playlist_ItemAddInfo, (playlist_item_t *, const char * , const char *, const char *, ...) );
/* Option functions */
VLC_EXPORT( int, playlist_ItemAddOption, (playlist_item_t *, const char *) );
/* Playlist sorting */
......@@ -197,11 +291,17 @@ VLC_EXPORT( int, playlist_ItemAddOption, (playlist_item_t *, const char *) );
#define playlist_SortGroup(p, i) playlist_Sort( p, SORT_GROUP, i)
VLC_EXPORT( int, playlist_Sort, ( playlist_t *, int, int) );
VLC_EXPORT( int, playlist_Move, ( playlist_t *, int, int ) );
VLC_EXPORT( int, playlist_NodeGroup, ( playlist_t *, int,playlist_item_t *,playlist_item_t **,int, int, int ) );
/* Load/Save */
VLC_EXPORT( int, playlist_Import, ( playlist_t *, const char * ) );
VLC_EXPORT( int, playlist_Export, ( playlist_t *, const char *, const char * ) );
/***********************************************************************
* Inline functions
***********************************************************************/
/**
* tell if a playlist is currently playing.
* \param p_playlist the playlist to check
......@@ -212,7 +312,7 @@ static inline vlc_bool_t playlist_IsPlaying( playlist_t * p_playlist )
vlc_bool_t b_playing;
vlc_mutex_lock( &p_playlist->object_lock );
b_playing = p_playlist->i_status == PLAYLIST_RUNNING;
b_playing = p_playlist->status.i_status == PLAYLIST_RUNNING;
vlc_mutex_unlock( &p_playlist->object_lock );
return( b_playing );
......
......@@ -580,6 +580,7 @@ static int Init( input_thread_t * p_input )
var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
UpdateItemLength( p_input, val.i_time );
p_input->input.p_item->i_duration = val.i_time;
}
/* Start title/chapter */
......@@ -893,6 +894,11 @@ static int Init( input_thread_t * p_input )
msg_Dbg( p_input, "`%s' sucessfully opened",
p_input->input.p_item->psz_uri );
/* Trigger intf update for this item */
/* Playlist has a callback on this variable and will forward
* it to intf */
var_SetInteger( p_input, "item-change", p_input->input.p_item->i_id );
/* initialization is complete */
p_input->i_state = PLAYING_S;
......
......@@ -190,12 +190,14 @@ void input_ControlVarInit ( input_thread_t *p_input )
var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL );
/* Special "intf-change" variable, it allows intf to set up a callback
* to be notified of some changes.
* TODO list all changes warn by this callbacks */
var_Create( p_input, "intf-change", VLC_VAR_BOOL );
var_SetBool( p_input, "intf-change", VLC_TRUE );
/* item-change variable */
var_Create( p_input, "item-change", VLC_VAR_INTEGER );
}
/*****************************************************************************
......
/*****************************************************************************
* playlist.c : Playlist groups management functions
*****************************************************************************
* Copyright (C) 1999-2004 VideoLAN
* $Id$
*
* Authors: Clment 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.
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#include <stdlib.h> /* free(), strtol() */
#include <stdio.h> /* sprintf() */
#include <string.h> /* strerror() */
#include <vlc/vlc.h>
#include <vlc/input.h>
#include "vlc_playlist.h"
/**
* Create a group
*
* Create a new group
* \param p_playlist pointer to a playlist
* \param psz_name the name of the group to be created
* \return a pointer to the created group, or NULL on error
*/
playlist_group_t *playlist_CreateGroup( playlist_t *p_playlist, char *psz_name)
{
playlist_group_t *p_group;
int i;
for( i = 0 ; i < p_playlist->i_groups; i++ )
{
if( !strcasecmp( p_playlist->pp_groups[i]->psz_name , psz_name ) )
{
msg_Info( p_playlist, "this group already exists");
return p_playlist->pp_groups[i];
}
}
/* Allocate the group structure */
if( ( p_group = malloc( sizeof(playlist_group_t) ) ) == NULL )
{
msg_Err( p_playlist, "out of memory" );
return NULL;
}
p_group->psz_name = strdup( psz_name );
p_group->i_id = ++p_playlist->i_last_group;
msg_Dbg(p_playlist,"creating group %s with id %i at position %i",
p_group->psz_name,
p_group->i_id,
p_playlist->i_groups);
INSERT_ELEM ( p_playlist->pp_groups,
p_playlist->i_groups,
p_playlist->i_groups,
p_group );
return p_group;
}
/**
* Destroy a group
*
* \param p_playlist the playlist to remove the group from
* \param i_id the identifier of the group to remove
* \return VLC_SUCCESS
*/
int playlist_DeleteGroup( playlist_t *p_playlist, int i_id )
{
int i;
for( i=0 ; i<= p_playlist->i_groups; i++ )
{
playlist_group_t *p_group = p_playlist->pp_groups[i];
if( p_group->i_id == i_id )
{
if( p_group->psz_name )
{
free( p_group->psz_name );
}
REMOVE_ELEM( p_playlist->pp_groups,
p_playlist->i_groups,
i );
free( p_group );
return VLC_SUCCESS;
}
}
return VLC_SUCCESS;
}
/**
* Find the name of the group given its ID
*
* \param p_playlist the playlist where to find the group
* \param i_id the ID to search for
* \return the name of the group
*/
char *playlist_FindGroup( playlist_t *p_playlist, int i_id )
{
int i;
for( i=0 ; i< p_playlist->i_groups; i++ )
{
if( p_playlist->pp_groups[i]->i_id == i_id )
{
if( p_playlist->pp_groups[i]->psz_name)
return strdup( p_playlist->pp_groups[i]->psz_name );
}
}
return NULL;
}
/**
* Find the id of a group given its name
*
* \param p_playlist the playlist where to find the group
* \param psz_name the name to search for
* \return the id of the group
*/
int playlist_GroupToId( playlist_t *p_playlist, char *psz_name )
{
int i;
for( i = 0 ; i< p_playlist->i_groups; i++ )
{
if( p_playlist->pp_groups[i]->psz_name)
{
if( ! strcasecmp( p_playlist->pp_groups[i]->psz_name, psz_name ) )
{
return p_playlist->pp_groups[i]->i_id;
}
}
}
return VLC_SUCCESS;
}
......@@ -122,7 +122,7 @@ info_category_t * playlist_ItemGetCategory( playlist_item_t *p_item,
* \return the info category.
*/
info_category_t * playlist_ItemCreateCategory( playlist_item_t *p_item,
const char *psz_cat )
const char *psz_cat )
{
info_category_t *p_cat;
int i;
......
/*****************************************************************************
* item-ext.c : Playlist item management functions
* item-ext.c : Playlist item management functions (act on the playlist)
*****************************************************************************
* Copyright (C) 1999-2004 VideoLAN
* $Id$
......@@ -54,8 +54,8 @@ int playlist_AddExt( playlist_t *p_playlist, const char * psz_uri,
mtime_t i_duration, const char **ppsz_options,
int i_options )
{
playlist_item_t *p_item =
playlist_ItemNew( p_playlist , psz_uri, psz_name );
playlist_item_t *p_item;
p_item = playlist_ItemNew( p_playlist , psz_uri, psz_name );
if( p_item == NULL )
{
......@@ -102,295 +102,416 @@ int playlist_Add( playlist_t *p_playlist, const char *psz_uri,
-1, NULL, 0 );
}
/***************************************************************************
* Item search functions
***************************************************************************/
/**
* Search the position of an item by its id
* This function must be entered with the playlist lock
* Add a playlist item into a playlist
*
* \param p_playlist the playlist
* \param i_id the id to find
* \return the position, or VLC_EGENERIC on failure
* \param p_playlist the playlist to insert into
* \param p_item the playlist item to insert
* \param i_mode the mode used when adding
* \param i_pos the possition in the playlist where to add. If this is
* PLAYLIST_END the item will be added at the end of the playlist
* regardless of it's size
* \return The id of the playlist item
*/
int playlist_GetPositionById( playlist_t * p_playlist , int i_id )
int playlist_AddItem( playlist_t *p_playlist, playlist_item_t *p_item,
int i_mode, int i_pos)
{
int i;
for( i = 0 ; i < p_playlist->i_size ; i++ )
vlc_value_t val;
vlc_bool_t b_end = VLC_FALSE;
playlist_view_t *p_view;
vlc_mutex_lock( &p_playlist->object_lock );
/*