04-播放列表线程和输入线程
作者：互联网
一、播放列表线程功能
二、列表对象
vlc与c++一样，有着封装的结构，一个指针指向的对象，有公共数据和私有数据，公共对象如下:
struct playlist_t
{
VLC_COMMON_MEMBERS
playlist_item_array_t items; //播放项数组
//当前播放项
playlist_item_array_t current; /**< Items currently being played */
int i_current_index; /**< Index in current array */
//预先准备的播放项
playlist_item_t root;
playlist_item_t *p_playing;
playlist_item_t *p_media_library;
};
私有数据如下：
typedef struct playlist_private_t
{
playlist_t public_data;//公共数据
struct intf_thread_t *interface; //界面线程
void *input_tree; //播放列表树
void *id_tree; /**播放列表id*/
vlc_sd_internal_t **pp_sds;
int i_sds; /**服务发现模块序号 */
input_thread_t * p_input; /**input线程*/
input_resource_t * p_input_resource; /**< 输入资源 */
vlc_renderer_item_t *p_renderer;//渲染项
struct {
/* 播放列表项状态，界面线程可以触发它*/
playlist_item_t * p_item; /**< Currently playing/active item */
playlist_item_t * p_node; /**< Current node to play from */
} status;
struct {
/* 请求，使用这个给playlist线程发送一个请求 */
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 */
bool b_request;/**< Set to true by the requester
The playlist sets it back to false
when processing the request */
bool input_dead; /**< Set when input has finished. */
} request;
vlc_thread_t thread; /**< engine thread */
vlc_mutex_t lock; /**< dah big playlist global lock */
vlc_cond_t signal; /**< 唤醒playlist线程 */
bool killed; /**< playlist is shutting down */
bool cork_effective; /**< Corked while actively playing */
int i_last_playlist_id; /**< Last id to an item */
bool b_reset_currently_playing; /** Reset current item array */
bool b_tree; /**< Display as a tree */
bool b_preparse; /**< Preparse items */
} playlist_private_t;
输入项结构input_item_t
struct input_item_t
{
char *psz_name; /**< text describing this item */
char *psz_uri; /**< mrl of this item */
int i_options; /**< Number of input options */
char **ppsz_options; /**< Array of input options */
uint8_t *optflagv; /**< Some flags of input options */
unsigned optflagc;
input_item_opaque_t *opaques; /**< List of opaque pointer values */
mtime_t i_duration; /**< Duration in microseconds */
int i_categories; /**< Number of info categories */
info_category_t **pp_categories; /**< Pointer to the first info category */
int i_es; /**< Number of es format descriptions */
es_format_t **es; /**< Es formats */
input_stats_t *p_stats; /**< Statistics */
vlc_meta_t *p_meta;
int i_epg; /**< Number of EPG entries */
vlc_epg_t **pp_epg; /**< EPG entries */
int64_t i_epg_time; /** EPG timedate as epoch time */
const vlc_epg_t *p_epg_table; /** running/selected program cur/next EPG table */
int i_slaves; /**< Number of slaves */
input_item_slave_t **pp_slaves; /**< Slave entries that will be loaded by
the input_thread */
vlc_event_manager_t event_manager;//事件管理结构
vlc_mutex_t lock; /**< Lock for the item */
uint8_t i_type; /**< Type (file, disc, ... see input_item_type_e) */
bool b_net; /**< Net: always true for TYPE_STREAM, it
depends for others types */
bool b_error_when_reading;/**< Error When Reading */
int i_preparse_depth; /**< How many level of sub items can be preparsed:
-1: recursive, 0: none, >0: n levels */
bool b_preparse_interact; /**< Force interaction with the user when
preparsing.*/
};
播放项playlist_item_t结构如下：
struct playlist_item_t
{
input_item_t *p_input; /**指向输入项 */
playlist_item_t **pp_children; /**< 播放项的子项*/
playlist_item_t *p_parent; /**< 播放项的父项 */
int i_children; /**< 子项个数 */
unsigned i_nb_played; /**< 播放次数 */
int i_id; /**< 播放id */
uint8_t i_flags; /**< Flags \see playlist_item_flags_e */
};
二、列表对象创建
列表对象playlist_t在程序启动的时候创建，并在创建的时候启动播放列表线程
playlist_t *playlist_Create( vlc_object_t *p_parent )
{
playlist_t *p_playlist;
playlist_private_t *p;
//列表对象父对象是libvlc_int_t，也就是vlc的实例对象
p = vlc_custom_create( p_parent, sizeof( *p ), "playlist" );
if( !p )
return NULL;
//公共对外的对象数据
p_playlist = &p->public_data;
p->input_tree = NULL;
p->id_tree = NULL;
TAB_INIT( pl_priv(p_playlist)->i_sds, pl_priv(p_playlist)->pp_sds );
// 初始化列表对象的元属性，比如"loop"，播放列表是否重复播放属性
VariablesInit( p_playlist );
vlc_mutex_init( &p->lock );
vlc_cond_init( &p->signal );
p->killed = false;
//初始化列表对象特有的数据
pl_priv(p_playlist)->i_last_playlist_id = 0;
pl_priv(p_playlist)->p_input = NULL;
ARRAY_INIT( p_playlist->items );
ARRAY_INIT( p_playlist->current );
p_playlist->i_current_index = 0;
pl_priv(p_playlist)->b_reset_currently_playing = true;
pl_priv(p_playlist)->b_tree = var_InheritBool( p_parent, "playlist-tree" );
pl_priv(p_playlist)->b_preparse = var_InheritBool( p_parent, "auto-preparse" );
p_playlist->root.p_input = NULL;
p_playlist->root.pp_children = NULL;
p_playlist->root.i_children = 0;
p_playlist->root.i_nb_played = 0;
p_playlist->root.i_id = 0;
p_playlist->root.i_flags = 0;
/* Create the root, playing items and meida library nodes */
playlist_item_t *playing, *ml;
PL_LOCK;
//创建播放节点
playing = playlist_NodeCreate( p_playlist, _( "Playlist" ),
&p_playlist->root, PLAYLIST_END,
PLAYLIST_RO_FLAG|PLAYLIST_NO_INHERIT_FLAG );
if( var_InheritBool( p_parent, "media-library") )
ml = playlist_NodeCreate( p_playlist, _( "Media Library" ),
&p_playlist->root, PLAYLIST_END,
PLAYLIST_RO_FLAG|PLAYLIST_NO_INHERIT_FLAG );
else
ml = NULL;
PL_UNLOCK;
if( unlikely(playing == NULL) )
abort();
p_playlist->p_playing = playing;
p_playlist->p_media_library = ml;
/* Initial status */
pl_priv(p_playlist)->status.p_item = NULL;
pl_priv(p_playlist)->status.p_node = p_playlist->p_playing;
pl_priv(p_playlist)->request.b_request = false;
p->request.input_dead = false;
if (ml != NULL)
playlist_MLLoad( p_playlist );
//创建输入资源
p->p_input_resource = input_resource_New( VLC_OBJECT( p_playlist ) );
if( unlikely(p->p_input_resource == NULL) )
abort();
/* Audio output (needed for volume and device controls). */
audio_output_t *aout = input_resource_GetAout( p->p_input_resource );
if( aout != NULL )
input_resource_PutAout( p->p_input_resource, aout );
/* Initialize the shared HTTP cookie jar */
vlc_value_t cookies;
cookies.p_address = vlc_http_cookies_new();
if ( likely(cookies.p_address) )
{
var_Create( p_playlist, "http-cookies", VLC_VAR_ADDRESS );
var_SetChecked( p_playlist, "http-cookies", VLC_VAR_ADDRESS, cookies );
}
//激活列表线程
playlist_Activate (p_playlist);
/* Add service discovery modules */
char *mods = var_InheritString( p_playlist, "services-discovery" );
if( mods != NULL )
{
char *s = mods, *m;
while( (m = strsep( &s, " :," )) != NULL )
playlist_ServicesDiscoveryAdd( p_playlist, m );
free( mods );
}
return p_playlist;
}
三、列表线程启动
void playlist_Activate( playlist_t *p_playlist )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
if( vlc_clone( &p_sys->thread, Thread, p_playlist,
VLC_THREAD_PRIORITY_LOW ) )
{
msg_Err( p_playlist, "cannot spawn playlist thread" );
abort();
}
}
列表线程函数Thread,如下：
static void *Thread ( void *data )
{
playlist_t *p_playlist = data;
playlist_private_t *p_sys = pl_priv(p_playlist);
bool played = false;
PL_LOCK;
//程序没停止就一直循环
while( !p_sys->killed )
{
/* Playlist in stopped state */
assert(p_sys->p_input == NULL);
if( !p_sys->request.b_request )
{
//没有input播放的时候，这个时候会在这睡眠，等待播放项激活
vlc_cond_wait( &p_sys->signal, &p_sys->lock );
continue;
}
/* Playlist in running state */
while( !p_sys->killed && Next( p_playlist ) )
{
//如果有input在播放的时候，会在LoopInput里面循环
LoopInput( p_playlist );
played = true;
}
/* Playlist stopping */
msg_Dbg( p_playlist, "nothing to play" );
if( played && var_InheritBool( p_playlist, "play-and-exit" ) )
{
msg_Info( p_playlist, "end of playlist, exiting" );
libvlc_Quit( p_playlist->obj.libvlc );
}
/* Destroy any video display now (XXX: ugly hack) */
if( input_resource_HasVout( p_sys->p_input_resource ) )
{
PL_UNLOCK; /* Mind: NO LOCKS while manipulating input resources! */
input_resource_TerminateVout( p_sys->p_input_resource );
PL_LOCK;
}
}
PL_UNLOCK;
input_resource_Terminate( p_sys->p_input_resource );
return NULL;
}
有输入流的时候，列表线程在LoopInput里面循环，如下:
static void LoopInput( playlist_t *p_playlist )
{
playlist_private_t *p_sys = pl_priv(p_playlist);
input_thread_t *p_input = p_sys->p_input;
assert( p_input != NULL );
//输入未停止，就一直循环
while( !p_sys->request.input_dead )
{
if( p_sys->request.b_request || p_sys->killed )
{
PL_DEBUG( "incoming request - stopping current input" );
input_Stop( p_input );//列表结构中检测有停止请求，停止输入线程
}
vlc_cond_wait( &p_sys->signal, &p_sys->lock );
}
/* This input is dead. Remove it ! */
PL_DEBUG( "dead input" );
p_sys->p_input = NULL;
p_sys->request.input_dead = false;
PL_UNLOCK;
var_SetAddress( p_playlist, "input-current", NULL );
/* WARNING: Input resource manipulation and callback deletion are
* incompatible with the playlist lock. */
if( !var_InheritBool( p_input, "sout-keep" ) )
input_resource_TerminateSout( p_sys->p_input_resource );
var_DelCallback( p_input, "intf-event", InputEvent, p_playlist );
input_Close( p_input );
PL_LOCK;
}
四、输入线程
列表线程管理输入的切换，列表项的管理，而输入线程则是代表单个输入的处理，vlc后台支持同时起多个输入，只是界面模块暂时不支持而已。输入对象与列表对象的创建流程类似，创建后初始化变量和注册变量回调。当播放流时，会创建一个输入线程，input线程函数如下：
static void *Run( void *data )
{
input_thread_private_t *priv = data;
input_thread_t *p_input = &priv->input;
vlc_interrupt_set(&priv->interrupt);
//线程资源初始化
if( !Init( p_input ) )
{
if( priv->b_can_pace_control && priv->b_out_pace_control )
{
/* We don't want a high input priority here or we'll
* end-up sucking up all the CPU time */
vlc_set_priority( priv->thread, VLC_THREAD_PRIORITY_LOW );
}
//进入循环
MainLoop( p_input, true ); /* FIXME it can be wrong (like with VLM) */
/* Clean up */
End( p_input );
}
input_SendEventDead( p_input );
return NULL;
}
MainLoop会进入循环，不断的从demux模块中获取数据，数据经抽象层次es_out传递给decode进行解码。
static void MainLoop( input_thread_t *p_input, bool b_interactive )
{
mtime_t i_intf_update = 0;
mtime_t i_last_seek_mdate = 0;
if( b_interactive && var_InheritBool( p_input, "start-paused" ) )
ControlPause( p_input, mdate() );
bool b_pause_after_eof = b_interactive &&
var_InheritBool( p_input, "play-and-pause" );
bool b_paused_at_eof = false;
demux_t *p_demux = input_priv(p_input)->master->p_demux;
const bool b_can_demux = p_demux->pf_demux != NULL;
//没有停止不停循环
while( !input_Stopped( p_input ) && input_priv(p_input)->i_state != ERROR_S )
{
mtime_t i_wakeup = -1;
bool b_paused = input_priv(p_input)->i_state == PAUSE_S;
/* FIXME if input_priv(p_input)->i_state == PAUSE_S the access/access_demux
* is paused -> this may cause problem with some of them
* The same problem can be seen when seeking while paused */
//es_out_GetBuffering:判断是否正在缓冲数据中(后续文章再进行深入分析数据缓冲)
if( b_paused )
b_paused = !es_out_GetBuffering( input_priv(p_input)->p_es_out )
|| input_priv(p_input)->master->b_eof;
if( !b_paused )
{
if( !input_priv(p_input)->master->b_eof )
{
//是否进行强制刷新
bool b_force_update = false;
//解复用数据
MainLoopDemux( p_input, &b_force_update );
//i_wakeup : 获取下一个唤醒时间
if( b_can_demux )
i_wakeup = es_out_GetWakeup( input_priv(p_input)->p_es_out );
if( b_force_update )
i_intf_update = 0;
b_paused_at_eof = false;
}
else if( !es_out_GetEmpty( input_priv(p_input)->p_es_out ) )
{
//等待解码线程解码完毕
msg_Dbg( p_input, "waiting decoder fifos to empty" );
i_wakeup = mdate() + INPUT_IDLE_SLEEP;
}
/* Pause after eof only if the input is pausable.
* This way we won't trigger timeshifting for nothing */
else if( b_pause_after_eof && input_priv(p_input)->b_can_pause )
{
//暂停播放
if( b_paused_at_eof )
break;
vlc_value_t val = { .i_int = PAUSE_S };
msg_Dbg( p_input, "pausing at EOF (pause after each)");
Control( p_input, INPUT_CONTROL_SET_STATE, val );
b_paused = true;
b_paused_at_eof = true;
}
else
{
//重复播放
if( MainLoopTryRepeat( p_input ) )
break;
}
/* Update interface and statistics */
mtime_t now = mdate();
if( now >= i_intf_update )
{
// 刷新播放数据统计值
MainLoopStatistics( p_input );
//每隔250ms刷新一次，或者b_force_update 为true时强制刷新
i_intf_update = now + INT64_C(250000);
}
}
/* Handle control */
for( ;; )
{
mtime_t i_deadline = i_wakeup;
/* Postpone seeking until ES buffering is complete or at most
* 125 ms. */
bool b_postpone = es_out_GetBuffering( input_priv(p_input)->p_es_out )
&& !input_priv(p_input)->master->b_eof;
//b_postpone 为true，正在缓冲数据中
if( b_postpone )
{
mtime_t now = mdate();
//如果正在缓冲，则每个20ms，检测是否缓冲完整
if( now < i_last_seek_mdate + INT64_C(125000)
&& (i_deadline < 0 || i_deadline > now + INT64_C(20000)) )
i_deadline = now + INT64_C(20000);
else
b_postpone = false;//超过125ms将b_postpone 置成false
}
int i_type;
vlc_value_t val;
//睡眠等待，直到有请求，或者到达唤醒时间
if( ControlPop( p_input, &i_type, &val, i_deadline, b_postpone ) )
{
if( b_postpone )//有缓冲，继续等待直到没有缓冲或者超过125ms将b_postpone 置成false
continue;//
break; //唤醒时间到了，开始继续上面大循环的解复用数据
}
#ifndef NDEBUG
msg_Dbg( p_input, "control type=%d", i_type );
#endif
//根据请求类型，处理请求，这里下篇文章详解，主要处理input的控制逻辑
if( Control( p_input, i_type, val ) )
{
//开始播放和seek后都会进缓冲buffering，i_last_seek_mdate 记录seek时间
if( ControlIsSeekRequest( i_type ) )
i_last_seek_mdate = mdate();
i_intf_update = 0;
}
/* Update the wakeup time */
if( i_wakeup != 0 )
i_wakeup = es_out_GetWakeup( input_priv(p_input)->p_es_out );
}
}
}
标签：playlist,04,vlc,sys,item,线程,播放列表,input,priv 来源： https://blog.csdn.net/baidu_31541363/article/details/122075195