static int VolumeMove( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
intf_thread_t *p_intf = (intf_thread_t*)p_this;
audio_volume_t i_volume;
int i_nb_steps = atoi(newval.psz_string);
int i_error = VLC_SUCCESS;
if ( i_nb_steps <= 0 || i_nb_steps > (AOUT_VOLUME_MAX/AOUT_VOLUME_STEP) )
{
i_nb_steps = 1;
}
if ( !strcmp(psz_cmd, "volup") )
{
if ( aout_VolumeUp( p_this, i_nb_steps, &i_volume ) < 0 )
i_error = VLC_EGENERIC;
}
else
{
if ( aout_VolumeDown( p_this, i_nb_steps, &i_volume ) < 0 )
i_error = VLC_EGENERIC;
}
if ( !i_error ) msg_rtci( "Volume is %d\n", i_volume );
return i_error;
}
static int vlclua_volume_up( lua_State *L )
{
audio_volume_t i_volume;
playlist_t *p_this = vlclua_get_playlist_internal( L );
aout_VolumeUp( p_this, luaL_optint( L, 1, 1 ), &i_volume );
lua_pushnumber( L, i_volume );
return 1;
}
/*****************************************************************************
* Manage: handle Sys events
*****************************************************************************
* This function should be called regularly by video output thread. It returns
* a non null value if an error occurred.
*****************************************************************************/
static int Manage( vout_thread_t *p_vout )
{
SDL_Event event; /* SDL event */
vlc_value_t val;
unsigned int i_width, i_height, i_x, i_y;
/* Process events */
while( SDL_PollEvent(&event) )
{
switch( event.type )
{
case SDL_VIDEORESIZE: /* Resizing of window */
/* Update dimensions */
p_vout->i_changes |= VOUT_SIZE_CHANGE;
p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
break;
case SDL_MOUSEMOTION:
vout_PlacePicture( p_vout, p_vout->p_sys->i_width,
p_vout->p_sys->i_height,
&i_x, &i_y, &i_width, &i_height );
val.i_int = ( event.motion.x - i_x )
* p_vout->render.i_width / i_width;
var_Set( p_vout, "mouse-x", val );
val.i_int = ( event.motion.y - i_y )
* p_vout->render.i_height / i_height;
var_Set( p_vout, "mouse-y", val );
val.b_bool = VLC_TRUE;
var_Set( p_vout, "mouse-moved", val );
if( p_vout->p_sys->b_cursor &&
(abs(event.motion.xrel) > 2 || abs(event.motion.yrel) > 2) )
{
if( p_vout->p_sys->b_cursor_autohidden )
{
p_vout->p_sys->b_cursor_autohidden = 0;
SDL_ShowCursor( 1 );
}
else
{
p_vout->p_sys->i_lastmoved = mdate();
}
}
break;
case SDL_MOUSEBUTTONUP:
switch( event.button.button )
{
case SDL_BUTTON_LEFT:
val.b_bool = VLC_TRUE;
var_Set( p_vout, "mouse-clicked", val );
break;
case SDL_BUTTON_RIGHT:
{
intf_thread_t *p_intf;
p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
FIND_ANYWHERE );
if( p_intf )
{
p_intf->b_menu_change = 1;
vlc_object_release( p_intf );
}
}
break;
}
break;
case SDL_MOUSEBUTTONDOWN:
switch( event.button.button )
{
case SDL_BUTTON_LEFT:
/* In this part we will eventually manage
* clicks for DVD navigation for instance. */
/* detect double-clicks */
if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
p_vout->p_sys->i_lastpressed = mdate();
break;
case 4:
break;
case 5:
break;
}
break;
case SDL_QUIT:
p_vout->p_vlc->b_die = 1;
break;
case SDL_KEYDOWN: /* if a key is pressed */
switch( event.key.keysym.sym )
{
case SDLK_ESCAPE:
if( p_vout->b_fullscreen )
{
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
}
else
{
p_vout->p_vlc->b_die = 1;
}
break;
case SDLK_q: /* quit */
p_vout->p_vlc->b_die = 1;
break;
case SDLK_f: /* switch to fullscreen */
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
break;
case SDLK_c: /* toggle grayscale */
p_vout->b_grayscale = ! p_vout->b_grayscale;
p_vout->i_changes |= VOUT_GRAYSCALE_CHANGE;
break;
case SDLK_i: /* toggle info */
p_vout->b_info = ! p_vout->b_info;
p_vout->i_changes |= VOUT_INFO_CHANGE;
break;
case SDLK_s: /* toggle scaling */
p_vout->b_scale = ! p_vout->b_scale;
p_vout->i_changes |= VOUT_SCALE_CHANGE;
break;
case SDLK_SPACE: /* toggle interface */
p_vout->b_interface = ! p_vout->b_interface;
p_vout->i_changes |= VOUT_INTF_CHANGE;
break;
case SDLK_MENU:
{
intf_thread_t *p_intf;
p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
FIND_ANYWHERE );
if( p_intf != NULL )
{
p_intf->b_menu_change = 1;
vlc_object_release( p_intf );
}
}
break;
case SDLK_LEFT:
break;
case SDLK_RIGHT:
break;
case SDLK_UP:
break;
case SDLK_DOWN:
break;
case SDLK_b:
{
audio_volume_t i_volume;
if ( !aout_VolumeDown( p_vout, 1, &i_volume ) )
{
msg_Dbg( p_vout, "audio volume is now %d", i_volume );
}
else
{
msg_Dbg( p_vout, "audio volume: operation not supported" );
}
}
break;
case SDLK_n:
{
audio_volume_t i_volume;
if ( !aout_VolumeUp( p_vout, 1, &i_volume ) )
{
msg_Dbg( p_vout, "audio volume is now %d", i_volume );
}
else
{
msg_Dbg( p_vout, "audio volume: operation not supported" );
}
}
break;
default:
break;
}
break;
default:
break;
}
}
/* Fullscreen change */
if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
{
p_vout->b_fullscreen = ! p_vout->b_fullscreen;
p_vout->p_sys->b_cursor_autohidden = 0;
SDL_ShowCursor( p_vout->p_sys->b_cursor &&
! p_vout->p_sys->b_cursor_autohidden );
p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
p_vout->i_changes |= VOUT_SIZE_CHANGE;
}
/*
* Size change
*/
if( p_vout->i_changes & VOUT_SIZE_CHANGE )
{
msg_Dbg( p_vout, "video display resized (%dx%d)",
p_vout->p_sys->i_width, p_vout->p_sys->i_height );
CloseDisplay( p_vout );
OpenDisplay( p_vout );
/* We don't need to signal the vout thread about the size change if
* we can handle rescaling ourselves */
if( p_vout->p_sys->p_overlay != NULL )
p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
}
/* Pointer change */
if( ! p_vout->p_sys->b_cursor_autohidden &&
( mdate() - p_vout->p_sys->i_lastmoved > 2000000 ) )
{
/* Hide the mouse automatically */
p_vout->p_sys->b_cursor_autohidden = 1;
SDL_ShowCursor( 0 );
}
return VLC_SUCCESS;
}
void CmdVolumeUp::execute()
{
aout_VolumeUp( getIntf(), 1, NULL );
}
/*****************************************************************************
* Run: main loop
*****************************************************************************/
static void Run( intf_thread_t *p_intf )
{
char *code, *c;
playlist_t *p_playlist;
input_thread_t *p_input;
vout_thread_t *p_vout = NULL;
while( !p_intf->b_die )
{
/* Sleep a bit */
msleep( INTF_IDLE_SLEEP );
/* Update the input */
if( p_intf->p_sys->p_input == NULL )
{
p_intf->p_sys->p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
FIND_ANYWHERE );
}
else if( p_intf->p_sys->p_input->b_dead )
{
vlc_object_release( p_intf->p_sys->p_input );
p_intf->p_sys->p_input = NULL;
}
p_input = p_intf->p_sys->p_input;
/* Update the vout */
if( p_vout == NULL )
{
p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT,
FIND_ANYWHERE );
p_intf->p_sys->p_vout = p_vout;
}
else if( p_vout->b_die )
{
vlc_object_release( p_vout );
p_vout = NULL;
p_intf->p_sys->p_vout = NULL;
}
/* We poll the lircsocket */
if( lirc_nextcode(&code) != 0 )
{
break;
}
if( code == NULL )
{
continue;
}
while( !p_intf->b_die
&& lirc_code2char( p_intf->p_sys->config, code, &c ) == 0
&& c != NULL )
{
if( !strcmp( c, "QUIT" ) )
{
p_intf->p_vlc->b_die = VLC_TRUE;
vout_OSDMessage( p_intf, DEFAULT_CHAN, _("Quit" ) );
continue;
}
else if( !strcmp( c, "VOL_UP" ) )
{
audio_volume_t i_newvol;
aout_VolumeUp( p_intf, 1, &i_newvol );
vout_OSDMessage( p_intf, DEFAULT_CHAN, _("Vol %%%d"),
i_newvol * 100 / AOUT_VOLUME_MAX );
}
else if( !strcmp( c, "VOL_DOWN" ) )
{
audio_volume_t i_newvol;
aout_VolumeDown( p_intf, 1, &i_newvol );
vout_OSDMessage( p_intf, DEFAULT_CHAN, _("Vol %%%d"),
i_newvol * 100 / AOUT_VOLUME_MAX );
}
else if( !strcmp( c, "MUTE" ) )
{
audio_volume_t i_newvol = -1;
aout_VolumeMute( p_intf, &i_newvol );
if( i_newvol == 0 )
{
vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Mute" ) );
}
else
{
vout_OSDMessage( p_intf, DEFAULT_CHAN, _("Vol %d%%"),
i_newvol * 100 / AOUT_VOLUME_MAX );
}
}
if( p_vout )
{
if( !strcmp( c, "FULLSCREEN" ) )
{
p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
continue;
}
if( !strcmp( c, "ACTIVATE" ) )
{
vlc_value_t val;
val.psz_string = "ENTER";
if (var_Set( p_vout, "key-pressed", val ) != VLC_SUCCESS)
{
msg_Warn( p_intf, "key-press failed" );
}
continue;
}
if( !strcmp( c, "LEFT" ) )
{
vlc_value_t val;
val.psz_string = "LEFT";
if (var_Set( p_vout, "key-pressed", val ) != VLC_SUCCESS)
{
msg_Warn( p_intf, "key-press failed" );
}
continue;
}
if( !strcmp( c, "RIGHT" ) )
{
vlc_value_t val;
val.psz_string = "RIGHT";
if (var_Set( p_vout, "key-pressed", val ) != VLC_SUCCESS)
{
msg_Warn( p_intf, "key-press failed" );
}
continue;
}
if( !strcmp( c, "UP" ) )
{
vlc_value_t val;
val.psz_string = "UP";
if (var_Set( p_vout, "key-pressed", val ) != VLC_SUCCESS)
{
msg_Warn( p_intf, "key-press failed" );
}
continue;
}
if( !strcmp( c, "DOWN" ) )
{
vlc_value_t val;
val.psz_string = "DOWN";
if (var_Set( p_vout, "key-pressed", val ) != VLC_SUCCESS)
{
msg_Warn( p_intf, "key-press failed" );
}
continue;
}
}
if( !strcmp( c, "PLAY" ) )
{
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist )
{
playlist_Play( p_playlist );
vlc_object_release( p_playlist );
}
continue;
}
if( !strcmp( c, "PLAYPAUSE" ) )
{
vlc_value_t val;
val.i_int = PLAYING_S;
if( p_input )
{
var_Get( p_input, "state", &val );
}
if( p_input && val.i_int != PAUSE_S )
{
vout_OSDMessage( VLC_OBJECT(p_intf), DEFAULT_CHAN,
_( "Pause" ) );
val.i_int = PAUSE_S;
var_Set( p_input, "state", val );
}
else
{
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist )
{
vlc_mutex_lock( &p_playlist->object_lock );
if( p_playlist->i_size )
{
vlc_mutex_unlock( &p_playlist->object_lock );
vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Play" ) );
playlist_Play( p_playlist );
vlc_object_release( p_playlist );
}
}
}
continue;
}
else if( p_input )
{
if( !strcmp( c, "AUDIO_TRACK" ) )
{
vlc_value_t val, list, list2;
int i_count, i;
var_Get( p_input, "audio-es", &val );
var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
&list, &list2 );
i_count = list.p_list->i_count;
for( i = 0; i < i_count; i++ )
{
if( val.i_int == list.p_list->p_values[i].i_int )
{
break;
}
}
/* value of audio-es was not in choices list */
if( i == i_count )
{
msg_Warn( p_input,
"invalid current audio track, selecting 0" );
var_Set( p_input, "audio-es",
list.p_list->p_values[0] );
i = 0;
}
else if( i == i_count - 1 )
{
var_Set( p_input, "audio-es",
list.p_list->p_values[0] );
i = 0;
}
else
{
var_Set( p_input, "audio-es",
list.p_list->p_values[i+1] );
i++;
}
vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
_("Audio track: %s"),
list2.p_list->p_values[i].psz_string );
}
else if( !strcmp( c, "SUBTITLE_TRACK" ) )
{
vlc_value_t val, list, list2;
int i_count, i;
var_Get( p_input, "spu-es", &val );
var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
&list, &list2 );
i_count = list.p_list->i_count;
for( i = 0; i < i_count; i++ )
{
if( val.i_int == list.p_list->p_values[i].i_int )
{
break;
}
}
/* value of audio-es was not in choices list */
if( i == i_count )
{
msg_Warn( p_input, "invalid current subtitle track, selecting 0" );
var_Set( p_input, "spu-es", list.p_list->p_values[0] );
i = 0;
}
else if( i == i_count - 1 )
{
var_Set( p_input, "spu-es", list.p_list->p_values[0] );
i = 0;
}
else
{
var_Set( p_input, "spu-es", list.p_list->p_values[i+1] );
i = i + 1;
}
vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
_("Subtitle track: %s"),
list2.p_list->p_values[i].psz_string );
}
else if( !strcmp( c, "PAUSE" ) )
{
vlc_value_t val;
vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Pause" ) );
val.i_int = PAUSE_S;
var_Set( p_input, "state", val );
}
else if( !strcmp( c, "NEXT" ) )
{
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist )
{
playlist_Next( p_playlist );
vlc_object_release( p_playlist );
}
}
else if( !strcmp( c, "PREV" ) )
{
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist )
{
playlist_Prev( p_playlist );
vlc_object_release( p_playlist );
}
}
else if( !strcmp( c, "STOP" ) )
{
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
FIND_ANYWHERE );
if( p_playlist )
{
playlist_Stop( p_playlist );
vlc_object_release( p_playlist );
}
}
else if( !strcmp( c, "FAST" ) )
{
vlc_value_t val; val.b_bool = VLC_TRUE;
var_Set( p_input, "rate-faster", val );
}
else if( !strcmp( c, "SLOW" ) )
{
vlc_value_t val; val.b_bool = VLC_TRUE;
var_Set( p_input, "rate-slower", val );
}
/* beginning of modifications by stephane Thu Jun 19 15:29:49 CEST 2003 */
else if ( !strcmp(c, "CHAPTER_N" ) ||
!strcmp( c, "CHAPTER_P" ) )
{
unsigned int i_chapter = 0;
if( !strcmp( c, "CHAPTER_N" ) )
{
var_SetVoid( p_input, "next-chapter" );
}
else if( !strcmp( c, "CHAPTER_P" ) )
{
var_SetVoid( p_input, "prev-chapter" );
}
}
/* end of modification by stephane Thu Jun 19 15:29:49 CEST 2003 */
}
}
free( code );
}
}
void CmdVolumeUp::execute()
{
aout_VolumeUp( getIntf()->p_sys->p_playlist, 1, NULL );
}
/*****************************************************************************
* RunIntf: main loop
*****************************************************************************/
static void RunIntf( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
int canc = vlc_savecancel();
input_thread_t *p_input;
/* Main loop */
while( vlc_object_alive( p_intf ) )
{
vlc_mutex_lock( &p_sys->lock );
/*
* mouse cursor
*/
if( p_sys->b_got_gesture )
{
int i_interval = 0;
/* Do something */
/* If you modify this, please try to follow this convention:
Start with LEFT, RIGHT for playback related commands
and UP, DOWN, for other commands */
playlist_t * p_playlist = pl_Get( p_intf );
switch( p_sys->i_pattern )
{
case LEFT:
msg_Dbg( p_intf, "Go backward in the movie!" );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
i_interval = var_InheritInteger( p_intf , "short-jump-size" );
if ( i_interval > 0 )
{
mtime_t i_time = ( (mtime_t)( -i_interval ) * 1000000L);
var_SetTime( p_input, "time-offset", i_time );
}
vlc_object_release( p_input );
}
break;
case RIGHT:
msg_Dbg( p_intf, "Go forward in the movie!" );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
i_interval = var_InheritInteger( p_intf , "short-jump-size" );
if ( i_interval > 0 )
{
mtime_t i_time = ( (mtime_t)( i_interval ) * 1000000L);
var_SetTime( p_input, "time-offset", i_time );
}
vlc_object_release( p_input );
}
break;
case GESTURE(LEFT,UP,NONE,NONE):
msg_Dbg( p_intf, "Going slower." );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
var_TriggerCallback( p_input, "rate-slower" );
vlc_object_release( p_input );
}
break;
case GESTURE(RIGHT,UP,NONE,NONE):
msg_Dbg( p_intf, "Going faster." );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
var_TriggerCallback( p_input, "rate-faster" );
vlc_object_release( p_input );
}
break;
case GESTURE(LEFT,RIGHT,NONE,NONE):
case GESTURE(RIGHT,LEFT,NONE,NONE):
msg_Dbg( p_intf, "Play/Pause" );
p_input = playlist_CurrentInput( p_playlist );
if( p_input )
{
int i_state = var_GetInteger( p_input, "state" );
var_SetInteger( p_input, "state", ( i_state != PLAYING_S )
? PLAYING_S : PAUSE_S );
vlc_object_release( p_input );
}
break;
case GESTURE(LEFT,DOWN,NONE,NONE):
playlist_Prev( p_playlist );
break;
case GESTURE(RIGHT,DOWN,NONE,NONE):
playlist_Next( p_playlist );
break;
case UP:
msg_Dbg(p_intf, "Louder");
aout_VolumeUp( p_playlist, 1, NULL );
break;
case DOWN:
msg_Dbg(p_intf, "Quieter");
aout_VolumeDown( p_playlist, 1, NULL );
break;
case GESTURE(UP,DOWN,NONE,NONE):
case GESTURE(DOWN,UP,NONE,NONE):
msg_Dbg( p_intf, "Mute sound" );
aout_ToggleMute( p_playlist, NULL );
break;
case GESTURE(UP,RIGHT,NONE,NONE):
{
vlc_value_t list, list2;
int i_count, i, i_audio_es;
p_input = playlist_CurrentInput( p_playlist );
if( !p_input )
break;
i_audio_es = var_GetInteger( p_input, "audio-es" );
var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
&list, &list2 );
i_count = list.p_list->i_count;
if( i_count <= 1 )
{
var_FreeList( &list, &list2 );
vlc_object_release( p_input );
break;
}
for( i = 0; i < i_count; i++ )
{
if( i_audio_es == list.p_list->p_values[i].i_int )
break;
}
/* value of audio-es was not in choices list */
if( i == i_count )
{
msg_Warn( p_input,
"invalid current audio track, selecting 0" );
i = 0;
}
else if( i == i_count - 1 )
i = 1;
else
i++;
var_SetInteger( p_input, "audio-es", list.p_list->p_values[i].i_int );
var_FreeList( &list, &list2 );
vlc_object_release( p_input );
}
break;
case GESTURE(DOWN,RIGHT,NONE,NONE):
{
vlc_value_t list, list2;
int i_count, i, i_spu_es;
p_input = playlist_CurrentInput( p_playlist );
if( !p_input )
break;
i_spu_es = var_GetInteger( p_input, "spu-es" );
var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
&list, &list2 );
i_count = list.p_list->i_count;
if( i_count <= 1 )
{
vlc_object_release( p_input );
var_FreeList( &list, &list2 );
break;
}
for( i = 0; i < i_count; i++ )
{
if( i_spu_es == list.p_list->p_values[i].i_int )
{
break;
}
}
/* value of spu-es was not in choices list */
if( i == i_count )
{
msg_Warn( p_input,
"invalid current subtitle track, selecting 0" );
i = 0;
}
else if( i == i_count - 1 )
i = 0;
else
i++;
var_SetInteger( p_input, "spu-es", list.p_list->p_values[i].i_int);
var_FreeList( &list, &list2 );
vlc_object_release( p_input );
}
break;
case GESTURE(UP,LEFT,NONE,NONE):
{
bool val = var_ToggleBool( pl_Get( p_intf ), "fullscreen" );
if( p_sys->p_vout )
var_SetBool( p_sys->p_vout, "fullscreen", val );
break;
}
case GESTURE(DOWN,LEFT,NONE,NONE):
/* FIXME: Should close the vout!"*/
libvlc_Quit( p_intf->p_libvlc );
break;
case GESTURE(DOWN,LEFT,UP,RIGHT):
case GESTURE(UP,RIGHT,DOWN,LEFT):
msg_Dbg( p_intf, "a square was drawn!" );
break;
default:
break;
}
p_sys->i_num_gestures = 0;
p_sys->i_pattern = 0;
p_sys->b_got_gesture = false;
}
/*
* video output
*/
if( p_sys->p_vout && !vlc_object_alive( p_sys->p_vout ) )
{
var_DelCallback( p_sys->p_vout, "mouse-moved",
MouseEvent, p_intf );
var_DelCallback( p_sys->p_vout, "mouse-button-down",
MouseEvent, p_intf );
vlc_object_release( p_sys->p_vout );
p_sys->p_vout = NULL;
}
if( p_sys->p_vout == NULL )
{
p_input = playlist_CurrentInput( pl_Get( p_intf ) );
if( p_input )
{
p_sys->p_vout = input_GetVout( p_input );
vlc_object_release( p_input );
}
if( p_sys->p_vout )
{
var_AddCallback( p_sys->p_vout, "mouse-moved",
MouseEvent, p_intf );
var_AddCallback( p_sys->p_vout, "mouse-button-down",
MouseEvent, p_intf );
}
}
vlc_mutex_unlock( &p_sys->lock );
/* Wait a bit */
msleep( INTF_IDLE_SLEEP );
}
vlc_restorecancel( canc );
}
/*****************************************************************************
* aout_VolumeDown : lower the output volume
*****************************************************************************
* If pi_volume != NULL, *pi_volume will contain the volume at the end of the
* function.
*****************************************************************************/
int aout_VolumeDown( vlc_object_t * p_object, int i_nb_steps,
audio_volume_t * pi_volume )
{
return aout_VolumeUp( p_object, -i_nb_steps, pi_volume );
}
