playlist_t *p_pl )
{
mvar_t *s = mvar_New( name, "set" );
- vlc_mutex_lock( &p_pl->object_lock );
+ vlc_object_lock( p_pl );
PlaylistListNode( p_intf, p_pl, p_pl->p_root_category , name, s, 0 );
- vlc_mutex_unlock( &p_pl->object_lock );
+ vlc_object_unlock( p_pl );
return s;
}
if( p_playlist )
{
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
p_intf->p_sys->i_last_state = (int) PLAYLIST_STOPPED;
msg_rc( STATUS_CHANGE "( stop state: 0 )" );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
}
}
if( (p_input != NULL) && !p_input->b_dead && !p_input->b_die &&
(p_playlist != NULL) )
{
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
if( (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
(p_playlist->status.i_status == PLAYLIST_STOPPED) )
{
p_intf->p_sys->i_last_state = p_playlist->status.i_status;
msg_rc( STATUS_CHANGE "( pause state: 4 )" );
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
}
if( p_input && b_showpos )
intf_thread_t * p_intf = VLCIntf;
playlist_t * p_playlist = pl_Yield( p_intf );
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
if( playlist_IsEmpty( p_playlist ) )
{
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
vlc_object_release( p_playlist );
[o_main intfOpenFileGeneric: (id)sender];
}
else
{
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
vlc_object_release( p_playlist );
}
intf_thread_t * p_intf = VLCIntf;
playlist_t * p_playlist = pl_Yield( p_intf );
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
#define p_input p_playlist->p_input
[o_main setupMenus]; /* Make sure video menu is up to date */
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
vlc_object_release( p_playlist );
return( bEnabled );
- (void)sheetDidEnd:(NSWindow *)o_sheet returnCode:(int)i_return
contextInfo:(void *)o_context
{
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
if( i_return == NSAlertDefaultReturn )
{
p_dialog->i_return = DIALOG_OK_YES;
p_dialog->i_return = DIALOG_CANCELLED;
}
p_dialog->i_status = ANSWERED_DIALOG;
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
}
-(void)updateDialog
- (IBAction)cancelAndClose:(id)sender
{
/* tell the core that the dialog was cancelled in a yes/no-style dialogue */
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
p_dialog->i_return = DIALOG_CANCELLED;
p_dialog->i_status = ANSWERED_DIALOG;
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
msg_Dbg( p_intf, "dialog cancelled" );
}
{
/* tell core that the user wishes to cancel the dialogue
* Use this function if cancelling is optionally like in the progress-dialogue */
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
p_dialog->b_cancelled = true;
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
msg_Dbg( p_intf, "cancelling dialog, will close it later on" );
}
- (IBAction)okayAndClose:(id)sender
{
msg_Dbg( p_intf, "running okayAndClose" );
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
if( p_dialog->i_flags == DIALOG_LOGIN_PW_OK_CANCEL )
{
p_dialog->psz_returned[0] = strdup( [[o_auth_login_fld stringValue] UTF8String] );
p_dialog->psz_returned[0] = strdup( [[o_input_fld stringValue] UTF8String] );
p_dialog->i_return = DIALOG_OK_YES;
p_dialog->i_status = ANSWERED_DIALOG;
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
msg_Dbg( p_intf, "dialog acknowledged" );
}
i_type = ORDER_NORMAL;
}
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_category, i_mode, i_type );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
vlc_object_release( p_playlist );
[self playlistUpdated];
input_thread_t *p_input = p_intf->p_sys->p_input;
int64_t i_time = 0, i_length = 0;
- vlc_mutex_lock( &p_input->object_lock );
+ vlc_object_lock( p_input );
if( !p_input->b_die )
{
playlist_t *p_playlist;
double f_pos = (double)newvalue / 100.0;
/* release the lock to be able to seek */
- vlc_mutex_unlock( &p_input->object_lock );
+ vlc_object_unlock( p_input );
var_SetFloat( p_input, "position", f_pos );
- vlc_mutex_lock( &p_input->object_lock );
+ vlc_object_lock( p_input );
/* Update the old value */
p_intf->p_sys->f_adj_oldvalue = newvalue;
double f_pos = (double)newvalue / 100.0;
/* release the lock to be able to seek */
- vlc_mutex_unlock( &p_input->object_lock );
+ vlc_object_unlock( p_input );
var_SetFloat( p_input, "position", f_pos );
- vlc_mutex_lock( &p_input->object_lock );
+ vlc_object_lock( p_input );
/* Update the old value */
p_intf->p_sys->i_adj_oldvalue = newvalue;
}
}
}
- vlc_mutex_unlock( &p_input->object_lock );
+ vlc_object_unlock( p_input );
}
else if( p_intf->p_sys->b_playing && !intf_ShouldDie( p_intf ) )
{
red.blue = 0;
red.green = 0;
#endif
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
for( i_dummy = 0; i_dummy < playlist_CurrentSize(p_playlist) ; i_dummy++ )
{
playlist_item_t *p_item = playlist_ItemGetById( p_playlist, i_dummy, true );
-1);
}
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
}
/*****************************************************************
if (p_playlist)
{
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
if (playlist_CurrentSize(p_playlist))
{
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
playlist_Play( p_playlist );
gdk_window_lower( p_intf->p_sys->p_window->window );
}
else
{
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
}
vlc_object_release( p_playlist );
}
void InteractionDialog::Finish( int i_ret )
{
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
if( p_dialog->i_flags & DIALOG_LOGIN_PW_OK_CANCEL )
{
p_dialog->b_cancelled = true;
hide();
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
playlist_Signal( THEPL );
}
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
- vlc_mutex_lock( &p_intf->object_lock );
+ vlc_object_lock( p_intf );
p_intf->b_dead = true;
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
if( p_intf->p_sys->b_isDialogProvider )
{
};
#define THEPL p_intf->p_sys->p_playlist
-#define QPL_LOCK vlc_mutex_lock( &THEPL->object_lock );
-#define QPL_UNLOCK vlc_mutex_unlock( &THEPL->object_lock );
+#define QPL_LOCK vlc_object_lock( THEPL );
+#define QPL_UNLOCK vlc_object_unlock( THEPL );
#define THEDP DialogsProvider::getInstance()
#define THEMIM MainInputManager::getInstance( p_intf )
/// \todo Choose sort method/order - Need more commands
/// \todo Choose the correct view
playlist_t *p_playlist = getIntf()->p_sys->p_playlist;
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_onelevel,
SORT_TITLE, ORDER_NORMAL );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
// Ask for rebuild
Playtree &rVar = VlcProc::instance( getIntf() )->getPlaytreeVar();
void Playtree::delSelected()
{
Iterator it = begin();
- vlc_mutex_lock( &getIntf()->p_sys->p_playlist->object_lock );
+ vlc_object_lock( getIntf()->p_sys->p_playlist );
for( it = begin(); it != end(); it = getNextVisibleItem( it ) )
{
if( (*it).m_selected && !(*it).isReadonly() )
it = getNextVisibleItem( it );
}
}
- vlc_mutex_unlock( &getIntf()->p_sys->p_playlist->object_lock );
+ vlc_object_unlock( getIntf()->p_sys->p_playlist );
}
void Playtree::action( VarTree *pItem )
{
- vlc_mutex_lock( &m_pPlaylist->object_lock );
+ vlc_object_lock( m_pPlaylist );
VarTree::Iterator it;
playlist_item_t *p_item = (playlist_item_t *)pItem->m_pData;
{
playlist_Control( m_pPlaylist, PLAYLIST_VIEWPLAY, true, p_parent, p_item );
}
- vlc_mutex_unlock( &m_pPlaylist->object_lock );
+ vlc_object_unlock( m_pPlaylist );
}
void Playtree::onChange()
void Playtree::buildTree()
{
clear();
- vlc_mutex_lock( &m_pPlaylist->object_lock );
+ vlc_object_lock( m_pPlaylist );
i_items_to_append = 0;
buildNode( m_pPlaylist->p_root_category, *this );
- vlc_mutex_unlock( &m_pPlaylist->object_lock );
+ vlc_object_unlock( m_pPlaylist );
// What is it ?
// checkParents( NULL );
}
/* Update the colour of items */
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
if( p_intf->p_sys->i_playing != p_playlist->i_index )
{
// p_playlist->i_index in RED
// if exists, p_intf->p_sys->i_playing in BLACK
p_intf->p_sys->i_playing = p_playlist->i_index;
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
vlc_object_release( p_playlist );
}
ListView_DeleteAllItems( hListView );
/* ...and rebuild it */
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
for( int i = 0; i < p_playlist->i_size; i++ )
{
LVITEM lv;
_FROMMB(p_playlist->pp_items[i]->input.psz_name) );
UpdateItem( i );
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
if ( i_focused )
ListView_SetItemState( hListView, i_focused, LVIS_FOCUSED |
vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
if( p_playlist == NULL ) return;
- vlc_mutex_lock( &p_playlist->object_lock);
+ vlc_object_lock( p_playlist);
playlist_item_t *p_item = playlist_ItemGetByPos( p_playlist, i_item );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
if( p_item )
{
{
#if 0
int i;
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
for( i = p_dialog->i_widgets - 1 ; i >= 0 ; i-- )
{
user_widget_t *p_widget = p_dialog->pp_widgets[i];
buttons_sizer->Remove( 3 );
buttons_panel->DestroyChildren();
input_widgets.clear();
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
Render();
#endif
}
void InteractionDialog::Finish( int i_ret )
{
#if 0
- vlc_mutex_lock( &p_dialog->p_interaction->object_lock );
+ vlc_object_lock( p_dialog->p_interaction );
vector<InputWidget>::iterator it = input_widgets.begin();
while ( it < input_widgets.end() )
{
Hide();
p_dialog->i_status = ANSWERED_DIALOG;
p_dialog->i_return = i_ret;
- vlc_mutex_unlock( &p_dialog->p_interaction->object_lock );
+ vlc_object_unlock( p_dialog->p_interaction );
#endif
}
void VLMWrapper::LockVLM()
{
- vlc_mutex_lock( &p_vlm->object_lock );
+ vlc_object_lock( p_vlm );
}
void VLMWrapper::UnlockVLM()
{
- vlc_mutex_unlock( &p_vlm->object_lock );
+ vlc_object_unlock( p_vlm );
}
void VLMWrapper::AddBroadcast( const char* name, const char* input,
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
- vlc_mutex_lock( &p_intf->object_lock );
+ vlc_object_lock( p_intf );
p_intf->b_dead = true;
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
if( p_intf->pf_show_dialog )
{
inline void LockPlaylist( intf_sys_t *p_sys, playlist_t *p_pl )
{
if( p_sys->i_playlist_usage++ == 0)
- vlc_mutex_lock( &p_pl->object_lock );
+ vlc_object_lock( p_pl );
}
inline void UnlockPlaylist( intf_sys_t *p_sys, playlist_t *p_pl )
{
if( --p_sys->i_playlist_usage == 0)
- vlc_mutex_unlock( &p_pl->object_lock );
+ vlc_object_unlock( p_pl );
}
#endif
lua_pushstring( L, psz_uri );
free( psz_uri );
lua_pushnumber( L, config_GetInt( p_intf, "volume" ) );*/
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
switch( p_playlist->status.i_status )
{
case PLAYLIST_STOPPED:
lua_pushstring( L, "unknown" );
break;
}
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
/*i_count += 3;*/
}
else
rtcp_t *p_rtcp = (rtcp_t *) p_this;
rtcp_client_t *p_client = NULL;
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = (rtcp_client_t*) malloc( sizeof(rtcp_client_t) );
if( !p_client )
return VLC_ENOMEM;
p_client->i_index, p_client );
p_rtcp->i_clients++;
p_rtcp->u_clients++;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
return VLC_SUCCESS;
}
rtcp_t *p_rtcp = (rtcp_t *) p_this;
uint32_t i_pos = 0;
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
if( p_rtcp->pf_find_client( p_this, u_ssrc, &i_pos ) == VLC_SUCCESS )
{
rtcp_client_t *p_old = p_rtcp->pp_clients[i_pos];
p_rtcp->u_clients--;
/* BYE message is sent by rtcp_destroy_client() */
}
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
return VLC_SUCCESS;
}
rtcp_t *p_rtcp = (rtcp_t *) p_this;
uint32_t i = 0;
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
for( i=0; i < p_rtcp->i_clients; i++ )
{
rtcp_client_t *p_old = p_rtcp->pp_clients[i];
free( p_old );
}
}
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
return VLC_SUCCESS;
}
if( result == VLC_EGENERIC )
return VLC_ENOMEM;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
p_client->p_stats->u_SR_received++;
p_client->p_stats->u_last_SR,
p_client->p_stats->u_delay_since_last_SR );
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
}
return VLC_SUCCESS;
}
return VLC_ENOMEM;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
p_client->p_stats->u_RR_received++;
p_client->p_stats->u_last_SR,
p_client->p_stats->u_delay_since_last_SR );
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
}
return VLC_SUCCESS;
}
return VLC_ENOMEM;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
u_item = bs_read( p_rtcp->bs, 8 );
((double)(0.9375) * p_client->p_stats->u_avg_pkt_size) );
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
}
return VLC_SUCCESS;
}
return VLC_ENOMEM;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
for( i = 0 ; i < 4; i++ )
psz_data = (char *) malloc( p_pkt->u_length );
if( !psz_data ) {
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
return VLC_EGENERIC;
}
p_pkt->report.app.u_length = p_pkt->u_length;
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
/* Just ignore this packet */
return VLC_SUCCESS;
return NULL;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
p_stats = p_client->p_stats;
bs_write( s, 32, p_stats->u_delay_since_last_SR );
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
/* possible SR extension */
return p_block;
return NULL;
}
- vlc_mutex_lock( &p_rtcp->object_lock );
+ vlc_object_lock( p_rtcp );
p_client = p_rtcp->pp_clients[i_pos];
p_stats = p_client->p_stats;
bs_write( s, 32, p_stats->u_delay_since_last_RR );
p_client = NULL;
- vlc_mutex_unlock( &p_rtcp->object_lock );
+ vlc_object_unlock( p_rtcp );
/* possible RR extension */
return p_block;
if (! playlist_was_locked( p_instance ) )
{
playlist_mark_locked( p_instance, 1 );
- vlc_mutex_lock( &PL->object_lock );
+ vlc_object_lock( PL );
did_lock = 1;
}
{
if( did_lock == 1 )
{
- vlc_mutex_unlock( &PL->object_lock );
+ vlc_object_unlock( PL );
playlist_mark_locked( p_instance, 0 );
}
RAISEVOID( "Unable to find item" );
PL->status.p_node, p_item );
if( did_lock == 1 )
{
- vlc_mutex_unlock( &PL->object_lock );
+ vlc_object_unlock( PL );
playlist_mark_locked( p_instance, 0 );
}
}
void libvlc_playlist_lock( libvlc_instance_t *p_instance )
{
assert( PL );
- vlc_mutex_lock( &PL->object_lock );
+ vlc_object_lock( PL );
p_instance->b_playlist_locked = 1;
}
{
assert( PL );
p_instance->b_playlist_locked = 0;
- vlc_mutex_unlock( &PL->object_lock );
+ vlc_object_unlock( PL );
}
libvlc_media_player_t * libvlc_playlist_get_media_player(
libvlc_media_player_t *p_mi;
assert( PL );
- vlc_mutex_lock( &PL->object_lock );
+ vlc_object_lock( PL );
if( PL->p_input )
{
p_mi = libvlc_media_player_new_from_input_thread(
p_mi = NULL;
libvlc_exception_raise( p_e, "No active input" );
}
- vlc_mutex_unlock( &PL->object_lock );
+ vlc_object_unlock( PL );
return p_mi;
}
input_ItemClean( p_input );
- vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
+ vlc_object_lock( p_obj->p_libvlc );
ARRAY_BSEARCH( priv->input_items,->i_id, int, p_input->i_id, i);
if( i != -1 )
ARRAY_REMOVE( priv->input_items, i);
- vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
+ vlc_object_unlock( p_obj->p_libvlc );
free( p_input );
}
input_item_t * p_ret = NULL;
int i;
- vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
+ vlc_object_lock( p_obj->p_libvlc );
ARRAY_BSEARCH( priv->input_items, ->i_id, int, i_id, i);
if( i != -1 )
p_ret = ARRAY_VAL( priv->input_items, i);
- vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
+ vlc_object_unlock( p_obj->p_libvlc );
return p_ret;
}
input_ItemInit( p_obj, p_input );
vlc_gc_init( p_input, input_ItemDestroy, (void *)p_obj );
- vlc_mutex_lock( &p_obj->p_libvlc->object_lock );
+ vlc_object_lock( p_obj->p_libvlc );
p_input->i_id = ++priv->i_last_input_id;
ARRAY_APPEND( priv->input_items, p_input );
- vlc_mutex_unlock( &p_obj->p_libvlc->object_lock );
+ vlc_object_unlock( p_obj->p_libvlc );
p_input->b_fixed_name = false;
psz_intf = p_intf->psz_switch_intf;
p_intf->psz_switch_intf = NULL;
- vlc_mutex_lock( &p_intf->object_lock );
+ vlc_object_lock( p_intf );
p_intf->b_die = false; /* FIXME */
p_intf->b_dead = false;
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
p_intf->psz_intf = psz_intf;
p_intf->p_module = module_Need( p_intf, "interface", psz_intf, 0 );
vlc_object_internals_t *internals = vlc_internals( p_this );
int fd;
- vlc_mutex_lock( &p_this->object_lock );
+ vlc_object_lock( p_this );
p_this->b_die = true;
vlc_spin_lock (&internals->spin);
}
vlc_object_signal_unlocked( p_this );
- vlc_mutex_unlock( &p_this->object_lock );
+ vlc_object_unlock( p_this );
if (p_this->i_object_type == VLC_OBJECT_LIBVLC)
{
boot->entry = func;
boot->object = p_this;
- vlc_mutex_lock( &p_this->object_lock );
+ vlc_object_lock( p_this );
#if defined( LIBVLC_USE_PTHREAD )
pthread_attr_t attr;
psz_name, psz_file, i_line );
}
- vlc_mutex_unlock( &p_this->object_lock );
+ vlc_object_unlock( p_this );
return i_ret;
}
int playlist_PreparseEnqueue( playlist_t *p_playlist,
input_item_t *p_item )
{
- vlc_mutex_lock( &p_playlist->p_preparse->object_lock );
+ vlc_object_lock( p_playlist->p_preparse );
vlc_gc_incref( p_item );
INSERT_ELEM( p_playlist->p_preparse->pp_waiting,
p_playlist->p_preparse->i_waiting,
p_playlist->p_preparse->i_waiting,
p_item );
vlc_cond_signal( &p_playlist->p_preparse->object_wait );
- vlc_mutex_unlock( &p_playlist->p_preparse->object_lock );
+ vlc_object_unlock( p_playlist->p_preparse );
return VLC_SUCCESS;
}
int playlist_PreparseEnqueueItem( playlist_t *p_playlist,
playlist_item_t *p_item )
{
- vlc_mutex_lock( &p_playlist->object_lock );
- vlc_mutex_lock( &p_playlist->p_preparse->object_lock );
+ vlc_object_lock( p_playlist );
+ vlc_object_lock( p_playlist->p_preparse );
PreparseEnqueueItemSub( p_playlist, p_item );
- vlc_mutex_unlock( &p_playlist->p_preparse->object_lock );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist->p_preparse );
+ vlc_object_unlock( p_playlist );
return VLC_SUCCESS;
}
input_item_t *p_item;
int i_activity;
- vlc_mutex_lock( &p_obj->object_lock );
+ vlc_object_lock( p_obj );
while( vlc_object_alive( p_obj ) )
{
p_item = p_obj->pp_waiting[0];
REMOVE_ELEM( p_obj->pp_waiting, p_obj->i_waiting, 0 );
- vlc_mutex_unlock( &p_obj->object_lock );
+ vlc_object_unlock( p_obj );
if( p_item )
{
int i_ret;
vlc_object_unlock( p_obj );
/* Sleep at least 1ms */
msleep( (i_activity+1) * 1000 );
- vlc_mutex_lock( &p_obj->object_lock );
+ vlc_object_lock( p_obj );
}
- vlc_mutex_unlock( &p_obj->object_lock );
+ vlc_object_unlock( p_obj );
}
static void VariablesInit( playlist_t *p_playlist )
p_export->p_root = p_export_root;
/* Lock the playlist */
- vlc_mutex_lock( &p_playlist->object_lock );
+ vlc_object_lock( p_playlist );
p_playlist->p_private = (void *)p_export;
/* And call the module ! All work is done now */
if( !p_module )
{
msg_Warn( p_playlist, "exporting playlist failed" );
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
return VLC_ENOOBJ;
}
module_Unneed( p_playlist , p_module );
free( p_export->psz_filename );
free ( p_export );
p_playlist->p_private = NULL;
- vlc_mutex_unlock( &p_playlist->object_lock );
+ vlc_object_unlock( p_playlist );
return VLC_SUCCESS;
}
}
/* Find the session to announce */
- vlc_mutex_lock( &p_sap->object_lock );
+ vlc_object_lock( p_sap );
if( p_sap->i_sessions > p_sap->i_current_session + 1)
{
p_sap->i_current_session++;
}
else
{
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
msleep( SAP_IDLE );
continue;
}
p_session = p_sap->pp_sessions[p_sap->i_current_session];
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
/* And announce it */
if( p_session->p_address->b_enabled == true &&
struct sockaddr_storage addr;
socklen_t addrlen;
- vlc_mutex_lock( &p_sap->object_lock );
+ vlc_object_lock( p_sap );
addrlen = p_session->addrlen;
if ((addrlen == 0) || (addrlen > sizeof (addr)))
{
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
msg_Err( p_sap, "No/invalid address specified for SAP announce" );
return VLC_EGENERIC;
}
{
msg_Err( p_sap, "Out-of-scope multicast address "
"not supported by SAP" );
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_EGENERIC;
}
}
default:
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
msg_Err( p_sap, "Address family %d not supported by SAP",
addr.ss_family );
return VLC_EGENERIC;
if( i )
{
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
msg_Err( p_sap, "%s", vlc_gai_strerror( i ) );
return VLC_EGENERIC;
}
malloc( sizeof(sap_address_t) );
if( !p_address )
{
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_ENOMEM;
}
p_address->psz_address = strdup( psz_addr );
default:
msg_Err( p_sap, "Address family %d not supported by SAP",
addr.ss_family );
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_EGENERIC;
}
if (p_sap_session->psz_data == NULL)
{
free (p_session->psz_sdp);
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_ENOMEM;
}
msg_Dbg( p_sap,"%i addresses, %i sessions",
p_sap->i_addresses,p_sap->i_sessions);
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_SUCCESS;
}
session_descriptor_t *p_session )
{
int i;
- vlc_mutex_lock( &p_sap->object_lock );
+ vlc_object_lock( p_sap );
msg_Dbg( p_sap, "removing session %p from SAP", p_session);
msg_Dbg( p_sap,"%i announcements remaining", p_sap->i_sessions );
- vlc_mutex_unlock( &p_sap->object_lock );
+ vlc_object_unlock( p_sap );
return VLC_SUCCESS;
}
if( !p_intf ) return;
- vlc_mutex_lock( &p_intf->object_lock );
+ vlc_object_lock( p_intf );
if( p_intf->b_dead )
{
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
return;
}
if( !p_intf->pf_release_window )
{
msg_Err( p_vout, "no pf_release_window");
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
vlc_object_release( p_intf );
return;
}
p_intf->pf_release_window( p_intf, p_window );
p_vout->p_parent_intf = NULL;
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
vlc_object_release( p_intf );
}
if( !p_intf ) return VLC_EGENERIC;
- vlc_mutex_lock( &p_intf->object_lock );
+ vlc_object_lock( p_intf );
if( p_intf->b_dead )
{
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
return VLC_EGENERIC;
}
if( !p_intf->pf_control_window )
{
msg_Err( p_vout, "no pf_control_window");
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
return VLC_EGENERIC;
}
i_ret = p_intf->pf_control_window( p_intf, p_window, i_query, args );
- vlc_mutex_unlock( &p_intf->object_lock );
+ vlc_object_unlock( p_intf );
return i_ret;
}