Skip to content

V
vlc-gpu
Commit d7a54c80 authored by Pierre Baillet's avatar Pierre Baillet
Browse files
Options

many minor style fixes (thanx to sam).

parent 0765875a
Hide whitespace changes
Inline Side-by-side
Showing with 302 additions and 314 deletions
include/keystrokes.h
View file @ d7a54c80
#ifndef VLC_KEYS #ifndef VLC_KEYS
#define VLC_KEYS #define VLC_KEYS
#define VLC_QUIT 0x01 #define INTF_KEY_QUIT 0x01
#define VLC_CHANNEL 0x02 #define INTF_KEY_SET_CHANNEL 0x02
#define VLC_LOUDER 0x03 #define INTF_KEY_DEC_VOLUME 0x03
#define VLC_QUIETER 0x04 #define INTF_KEY_INC_VOLUME 0x04
#define VLC_MUTE 0x05 #define INTF_KEY_TOGGLE_VOLUME 0x05
#define VLC_LESS_GAMMA 0x06 #define INTF_KEY_DEC_GAMMA 0x06
#define VLC_MORE_GAMMA 0x07 #define INTF_KEY_INC_GAMMA 0x07
#define VLC_GRAYSCALE 0x08 #define INTF_KEY_TOGGLE_GRAYSCALE 0x08
#define VLC_INTERFACE 0x09 #define INTF_KEY_TOGGLE_INTERFACE 0x09
#define VLC_INFO 0x0A #define INTF_KEY_TOGGLE_INFO 0x0A
#define VLC_SCALING 0x0B #define INTF_KEY_TOGGLE_SCALING 0x0B
#define VLC_UNKNOWN 0x0C #define INTF_KEY_UNKNOWN 0x0C
//#define VLC_CHANNEL 0x0D
#endif #endif
plugins/sdl/intf_sdl.c
View file @ d7a54c80
...@@ -148,7 +148,7 @@ void intf_SDLManage( intf_thread_t *p_intf ) ...@@ -148,7 +148,7 @@ void intf_SDLManage( intf_thread_t *p_intf )
} }
break; break;
case SDL_QUIT: case SDL_QUIT:
intf_ProcessKey( p_intf, VLC_QUIT ); intf_ProcessKey( p_intf, INTF_KEY_QUIT );
break; break;
default: default:
break; break;
...@@ -161,29 +161,29 @@ void intf_SDLManage( intf_thread_t *p_intf ) ...@@ -161,29 +161,29 @@ void intf_SDLManage( intf_thread_t *p_intf )
void intf_SDL_Keymap(intf_thread_t * p_intf ) void intf_SDL_Keymap(intf_thread_t * p_intf )
{ {
p_intf->p_intf_getKey = intf_getKey; p_intf->p_intf_getKey = intf_getKey;
intf_AssignSKey(p_intf, SDLK_q, VLC_QUIT); intf_AssignKey(p_intf, SDLK_q, INTF_KEY_QUIT, NULL);
intf_AssignSKey(p_intf, SDLK_ESCAPE, VLC_QUIT); intf_AssignKey(p_intf, SDLK_ESCAPE, INTF_KEY_QUIT, NULL);
/* intf_AssignKey(p_intf,3,'Q'); */ /* intf_AssignKey(p_intf,3,'Q'); */
intf_AssignKey(p_intf, SDLK_0, VLC_CHANNEL,0); intf_AssignKey(p_intf, SDLK_0, INTF_KEY_SET_CHANNEL,0);
intf_AssignKey(p_intf, SDLK_1, VLC_CHANNEL,1); intf_AssignKey(p_intf, SDLK_1, INTF_KEY_SET_CHANNEL,1);
intf_AssignKey(p_intf, SDLK_2, VLC_CHANNEL,2); intf_AssignKey(p_intf, SDLK_2, INTF_KEY_SET_CHANNEL,2);
intf_AssignKey(p_intf, SDLK_3, VLC_CHANNEL,3); intf_AssignKey(p_intf, SDLK_3, INTF_KEY_SET_CHANNEL,3);
intf_AssignKey(p_intf, SDLK_4, VLC_CHANNEL,4); intf_AssignKey(p_intf, SDLK_4, INTF_KEY_SET_CHANNEL,4);
intf_AssignKey(p_intf, SDLK_5, VLC_CHANNEL,5); intf_AssignKey(p_intf, SDLK_5, INTF_KEY_SET_CHANNEL,5);
intf_AssignKey(p_intf, SDLK_6, VLC_CHANNEL,6); intf_AssignKey(p_intf, SDLK_6, INTF_KEY_SET_CHANNEL,6);
intf_AssignKey(p_intf, SDLK_7, VLC_CHANNEL,7); intf_AssignKey(p_intf, SDLK_7, INTF_KEY_SET_CHANNEL,7);
intf_AssignKey(p_intf, SDLK_8, VLC_CHANNEL,8); intf_AssignKey(p_intf, SDLK_8, INTF_KEY_SET_CHANNEL,8);
intf_AssignKey(p_intf, SDLK_9, VLC_CHANNEL,9); intf_AssignKey(p_intf, SDLK_9, INTF_KEY_SET_CHANNEL,9);
intf_AssignSKey(p_intf, SDLK_PLUS, VLC_LOUDER); intf_AssignKey(p_intf, SDLK_PLUS, INTF_KEY_INC_VOLUME, NULL);
intf_AssignSKey(p_intf, SDLK_MINUS, VLC_QUIETER); intf_AssignKey(p_intf, SDLK_MINUS, INTF_KEY_DEC_VOLUME, NULL);
intf_AssignSKey(p_intf, SDLK_m, VLC_MUTE); intf_AssignKey(p_intf, SDLK_m, INTF_KEY_TOGGLE_VOLUME, NULL);
/* intf_AssignKey(p_intf,'M','M'); */ /* intf_AssignKey(p_intf,'M','M'); */
intf_AssignSKey(p_intf, SDLK_g, VLC_LESS_GAMMA); intf_AssignSKey(p_intf, SDLK_g, INTF_KEY_DEC_GAMMA, NULL);
/* intf_AssignKey(p_intf,'G','G'); */ /* intf_AssignKey(p_intf,'G','G'); */
intf_AssignSKey(p_intf, SDLK_c, VLC_GRAYSCALE); intf_AssignSKey(p_intf, SDLK_c, INTF_KEY_TOGGLE_GRAYSCALE, NULL);
intf_AssignSKey(p_intf, SDLK_SPACE, VLC_INTERFACE); intf_AssignSKey(p_intf, SDLK_SPACE, INTF_KEY_TOGGLE_INTERFACE, NULL);
intf_AssignSKey(p_intf, 'i', VLC_INFO); intf_AssignSKey(p_intf, 'i', INTF_KEY_TOGGLE_INFO, NULL);
intf_AssignSKey(p_intf, SDLK_s, VLC_SCALING); intf_AssignSKey(p_intf, SDLK_s, INTF_KEY_TOGGLE_SCALING, NULL);
} }
src/interface/interface.c
View file @ d7a54c80
...@@ -124,273 +124,262 @@ intf_thread_t* intf_Create( void ) ...@@ -124,273 +124,262 @@ intf_thread_t* intf_Create( void )
} }
} }
if( i_best_score == 0 ) if( i_best_score == 0 )
{ {
free( p_intf ); free( p_intf );
return( NULL ); return( NULL );
} }
/* Get the plugin functions */ /* Get the plugin functions */
( (intf_getplugin_t *) ( (intf_getplugin_t *)
p_main->p_bank->p_info[ i_best_index ]->intf_GetPlugin )( p_intf ); p_main->p_bank->p_info[ i_best_index ]->intf_GetPlugin )( p_intf );
/* Initialize structure */ /* Initialize structure */
p_intf->b_die = 0; p_intf->b_die = 0;
p_intf->p_vout = NULL; p_intf->p_vout = NULL;
p_intf->p_input = NULL; p_intf->p_input = NULL;
p_intf->p_keys = NULL; p_intf->p_keys = NULL;
/* Load channels - the pointer will be set to NULL on failure. The /* Load channels - the pointer will be set to NULL on failure. The
* return value is ignored since the program can work without * return value is ignored since the program can work without
* channels */ * channels */
LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR, INTF_CHANNELS_DEFAULT )); LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR, INTF_CHANNELS_DEFAULT ));
/* Start interfaces */ /* Start interfaces */
p_intf->p_console = intf_ConsoleCreate(); p_intf->p_console = intf_ConsoleCreate();
if( p_intf->p_console == NULL ) if( p_intf->p_console == NULL )
{ {
intf_ErrMsg("error: can't create control console\n"); intf_ErrMsg("error: can't create control console\n");
free( p_intf ); free( p_intf );
return( NULL ); return( NULL );
} }
if( p_intf->p_sys_create( p_intf ) ) if( p_intf->p_sys_create( p_intf ) )
{ {
intf_ErrMsg("error: can't create interface\n"); intf_ErrMsg("error: can't create interface\n");
intf_ConsoleDestroy( p_intf->p_console ); intf_ConsoleDestroy( p_intf->p_console );
free( p_intf ); free( p_intf );
return( NULL ); return( NULL );
} }
intf_Msg("Interface initialized\n"); intf_Msg("Interface initialized\n");
return( p_intf ); return( p_intf );
} }
/***************************************************************************** /*****************************************************************************
* intf_Run * intf_Run
***************************************************************************** *****************************************************************************
* Initialization script and main interface loop. * Initialization script and main interface loop.
*****************************************************************************/ *****************************************************************************/
void intf_Run( intf_thread_t *p_intf ) void intf_Run( intf_thread_t *p_intf )
{ {
if( p_main->p_playlist->p_list ) if( p_main->p_playlist->p_list )
{ {
p_intf->p_input = input_CreateThread( INPUT_METHOD_TS_FILE, NULL, 0, 0, p_main->p_intf->p_vout, p_main->p_aout, NULL ); p_intf->p_input = input_CreateThread( INPUT_METHOD_TS_FILE, NULL, 0, 0, p_main->p_intf->p_vout, p_main->p_aout, NULL );
} }
/* Execute the initialization script - if a positive number is returned, /* Execute the initialization script - if a positive number is returned,
* the script could be executed but failed */ * the script could be executed but failed */
else if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 ) else if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 )
{ {
intf_ErrMsg("warning: error(s) during startup script\n"); intf_ErrMsg("warning: error(s) during startup script\n");
} }
/* Main loop */ /* Main loop */
while(!p_intf->b_die) while(!p_intf->b_die)
{ {
/* Flush waiting messages */ /* Flush waiting messages */
intf_FlushMsg(); intf_FlushMsg();
/* Manage specific interface */ /* Manage specific interface */
p_intf->p_sys_manage( p_intf ); p_intf->p_sys_manage( p_intf );
/* Check attached threads status */ /* Check attached threads status */
if( (p_intf->p_vout != NULL) && p_intf->p_vout->b_error ) if( (p_intf->p_vout != NULL) && p_intf->p_vout->b_error )
{ {
/* FIXME: add aout error detection ?? */ /* FIXME: add aout error detection ?? */
p_intf->b_die = 1; p_intf->b_die = 1;
} }
if( (p_intf->p_input != NULL) && p_intf->p_input->b_error ) if( (p_intf->p_input != NULL) && p_intf->p_input->b_error )
{ {
input_DestroyThread( p_intf->p_input, NULL ); input_DestroyThread( p_intf->p_input, NULL );
p_intf->p_input = NULL; p_intf->p_input = NULL;
intf_DbgMsg("Input thread destroyed\n"); intf_DbgMsg("Input thread destroyed\n");
} }
/* Sleep to avoid using all CPU - since some interfaces needs to access /* Sleep to avoid using all CPU - since some interfaces needs to access
* keyboard events, a 100ms delay is a good compromise */ * keyboard events, a 100ms delay is a good compromise */
msleep( INTF_IDLE_SLEEP ); msleep( INTF_IDLE_SLEEP );
} }
} }
/***************************************************************************** /*****************************************************************************
* intf_Destroy: clean interface after main loop * intf_Destroy: clean interface after main loop
***************************************************************************** *****************************************************************************
* This function destroys specific interfaces and close output devices. * This function destroys specific interfaces and close output devices.
*****************************************************************************/ *****************************************************************************/
void intf_Destroy( intf_thread_t *p_intf ) void intf_Destroy( intf_thread_t *p_intf )
{ {
p_intf_key p_cur; p_intf_key p_cur;
p_intf_key p_next; p_intf_key p_next;
/* Destroy interfaces */ /* Destroy interfaces */
p_intf->p_sys_destroy( p_intf ); p_intf->p_sys_destroy( p_intf );
intf_ConsoleDestroy( p_intf->p_console ); intf_ConsoleDestroy( p_intf->p_console );
/* Unload channels */ /* Unload channels */
UnloadChannels( p_intf ); UnloadChannels( p_intf );
/* Destroy keymap */ /* Destroy keymap */
p_cur = p_intf->p_keys; p_cur = p_intf->p_keys;
while( p_cur != NULL) while( p_cur != NULL)
{ {
p_next = p_cur->next; p_next = p_cur->next;
free(p_cur); free(p_cur);
p_cur = p_next; p_cur = p_next;
} }
/* Free structure */ /* Free structure */
free( p_intf ); free( p_intf );
} }
/***************************************************************************** /*****************************************************************************
* intf_SelectChannel: change channel * intf_SelectChannel: change channel
***************************************************************************** *****************************************************************************
* Kill existing input, if any, and try to open a new one, using an input * Kill existing input, if any, and try to open a new one, using an input
* configuration table. * configuration table.
*****************************************************************************/ *****************************************************************************/
int intf_SelectChannel( intf_thread_t * p_intf, int i_channel ) int intf_SelectChannel( intf_thread_t * p_intf, int i_channel )
{ {
intf_channel_t * p_channel; /* channel */ intf_channel_t * p_channel; /* channel */
/* Look for channel in array */ /* Look for channel in array */
if( p_intf->p_channel != NULL ) if( p_intf->p_channel != NULL )
{ {
for( p_channel = p_intf->p_channel; p_channel->i_channel != -1; p_channel++ ) for( p_channel = p_intf->p_channel; p_channel->i_channel != -1; p_channel++ )
{ {
if( p_channel->i_channel == i_channel ) if( p_channel->i_channel == i_channel )
{ {
/* /*
* Change channel * Change channel
*/ */
/* Kill existing input, if any */ /* Kill existing input, if any */
if( p_intf->p_input != NULL ) if( p_intf->p_input != NULL )
{ {
input_DestroyThread( p_intf->p_input, NULL ); input_DestroyThread( p_intf->p_input, NULL );
} }
intf_Msg("Channel %d: %s\n", i_channel, p_channel->psz_description ); intf_Msg("Channel %d: %s\n", i_channel, p_channel->psz_description );
/* Open a new input */ /* Open a new input */
p_intf->p_input = input_CreateThread( p_channel->i_input_method, p_channel->psz_input_source, p_intf->p_input = input_CreateThread( p_channel->i_input_method, p_channel->psz_input_source,
p_channel->i_input_port, p_channel->i_input_vlan, p_channel->i_input_port, p_channel->i_input_vlan,
p_intf->p_vout, p_main->p_aout, NULL ); p_intf->p_vout, p_main->p_aout, NULL );
return( p_intf->p_input == NULL ); return( p_intf->p_input == NULL );
} }
} }
} }
/* Channel does not exist */ /* Channel does not exist */
intf_Msg("Channel %d does not exist\n", i_channel ); intf_Msg("Channel %d does not exist\n", i_channel );
return( 1 ); return( 1 );
} }
/***************************************************************************** /*****************************************************************************
* intf_AssignKey: assign standartkeys * * intf_AssignKey: assign standartkeys *
***************************************************************************** *****************************************************************************
* This function fills in the associative array that links the key pressed * * This function fills in the associative array that links the key pressed *
* and the key we use internally. Support one extra parameter. * * and the key we use internally. Support one extra parameter. *
****************************************************************************/ ****************************************************************************/
void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param) void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
{ {
p_intf_key p_cur = p_intf->p_keys; p_intf_key p_cur = p_intf->p_keys;
if( p_cur == NULL )
if( p_cur == NULL ) {
{ p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) ); p_cur->received_key = r_key;
p_cur->received_key = r_key; p_cur->forwarded.key = f_key;
p_cur->forwarded.key = f_key; p_cur->forwarded.param = param;
p_cur->forwarded.param = param; p_cur->next = NULL;
p_cur->next = NULL; p_intf->p_keys = p_cur;
p_intf->p_keys = p_cur; }
} else { else
while( p_cur->next != NULL && p_cur ->received_key != r_key) {
{ while( p_cur->next != NULL && p_cur ->received_key != r_key)
p_cur = p_cur->next; {
} p_cur = p_cur->next;
if( p_cur->next == NULL ) }
{ if( p_cur->next == NULL )
p_cur->next = ( p_intf_key )( malloc( sizeof( intf_key ) ) ); {
p_cur = p_cur->next; p_cur->next = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
p_cur->next = NULL; p_cur = p_cur->next;
p_cur->forwarded.param = param; p_cur->next = NULL;
p_cur->received_key = r_key; p_cur->forwarded.param = param;
} p_cur->received_key = r_key;
p_cur->forwarded.key = f_key; }
} p_cur->forwarded.key = f_key;
} }
}
/*****************************************************************************
* intf_AssignSKey: assign standartkeys * /* Basic getKey function... */
***************************************************************************** keyparm intf_getKey( intf_thread_t *p_intf, int r_key)
* This function fills in the associative array that links the key pressed * {
* and the key we use internally. * keyparm reply;
****************************************************************************/
void intf_AssignSKey(intf_thread_t *p_intf, int r_key, int f_key) p_intf_key current = p_intf->p_keys;
{ while(current != NULL && current->received_key != r_key)
intf_AssignKey( p_intf, r_key, f_key, 0); {
} current = current->next;
}
if(current == NULL)
/* Basic getKey function... */ { /* didn't find any key in the array */
keyparm intf_getKey( intf_thread_t *p_intf, int r_key) reply.key=INTF_KEY_UNKNOWN;
{ reply.param=0;
keyparm reply; }
else
p_intf_key current = p_intf->p_keys; {
while(current != NULL && current->received_key != r_key) reply.key = current->forwarded.key;
{ reply.param = current->forwarded.param;
current = current->next; }
} return reply;
if(current == NULL) }
{ /* didn't find any key in the array */
reply.key=VLC_UNKNOWN; /*****************************************************************************
reply.param=0; * intf_AssignNormalKeys: used for normal interfaces.
} *****************************************************************************
else * This function assign the basic key to the normal keys.
{ *****************************************************************************/
reply.key = current->forwarded.key;
reply.param = current->forwarded.param;
}
return reply;
}
/*****************************************************************************
* intf_AssignNormalKeys: used for normal interfaces.
*****************************************************************************
* This function assign the basic key to the normal keys.
*****************************************************************************/
void intf_AssignNormalKeys( intf_thread_t *p_intf) void intf_AssignNormalKeys( intf_thread_t *p_intf)
{ {
p_intf->p_intf_getKey = intf_getKey; p_intf->p_intf_getKey = intf_getKey;
intf_AssignSKey( p_intf , 'Q', VLC_QUIT); intf_AssignKey( p_intf , 'Q', INTF_KEY_QUIT, 0);
intf_AssignSKey( p_intf , 'q', VLC_QUIT); intf_AssignKey( p_intf , 'q', INTF_KEY_QUIT, 0);
intf_AssignSKey( p_intf , 27, VLC_QUIT); intf_AssignKey( p_intf , 27, INTF_KEY_QUIT, 0);
intf_AssignSKey( p_intf , 3, VLC_QUIT); intf_AssignKey( p_intf , 3, INTF_KEY_QUIT, 0);
intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0); intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
intf_AssignKey( p_intf , '1', VLC_CHANNEL, 1); intf_AssignKey( p_intf , '1', INTF_KEY_SET_CHANNEL, 1);
intf_AssignKey( p_intf , '2', VLC_CHANNEL, 2); intf_AssignKey( p_intf , '2', INTF_KEY_SET_CHANNEL, 2);
intf_AssignKey( p_intf , '3', VLC_CHANNEL, 3); intf_AssignKey( p_intf , '3', INTF_KEY_SET_CHANNEL, 3);
intf_AssignKey( p_intf , '4', VLC_CHANNEL, 4); intf_AssignKey( p_intf , '4', INTF_KEY_SET_CHANNEL, 4);
intf_AssignKey( p_intf , '5', VLC_CHANNEL, 5); intf_AssignKey( p_intf , '5', INTF_KEY_SET_CHANNEL, 5);
intf_AssignKey( p_intf , '6', VLC_CHANNEL, 6); intf_AssignKey( p_intf , '6', INTF_KEY_SET_CHANNEL, 6);
intf_AssignKey( p_intf , '7', VLC_CHANNEL, 7); intf_AssignKey( p_intf , '7', INTF_KEY_SET_CHANNEL, 7);
intf_AssignKey( p_intf , '8', VLC_CHANNEL, 8); intf_AssignKey( p_intf , '8', INTF_KEY_SET_CHANNEL, 8);
intf_AssignKey( p_intf , '9', VLC_CHANNEL, 9); intf_AssignKey( p_intf , '9', INTF_KEY_SET_CHANNEL, 9);
intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0); intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
intf_AssignSKey( p_intf , '+', VLC_LOUDER); intf_AssignKey( p_intf , '+', INTF_KEY_INC_VOLUME, 0);
intf_AssignSKey( p_intf , '-', VLC_QUIETER); intf_AssignKey( p_intf , '-', INTF_KEY_DEC_VOLUME, 0);
intf_AssignSKey( p_intf , 'm', VLC_MUTE); intf_AssignKey( p_intf , 'm', INTF_KEY_TOGGLE_VOLUME, 0);
intf_AssignSKey( p_intf , 'M', VLC_MUTE); intf_AssignKey( p_intf , 'M', INTF_KEY_TOGGLE_VOLUME, 0);
intf_AssignSKey( p_intf , 'g', VLC_LESS_GAMMA); intf_AssignKey( p_intf , 'g', INTF_KEY_DEC_GAMMA, 0);
intf_AssignSKey( p_intf , 'G', VLC_MORE_GAMMA); intf_AssignKey( p_intf , 'G', INTF_KEY_INC_GAMMA, 0);
intf_AssignSKey( p_intf , 'c', VLC_GRAYSCALE); intf_AssignKey( p_intf , 'c', INTF_KEY_TOGGLE_GRAYSCALE, 0);
intf_AssignSKey( p_intf , ' ', VLC_INTERFACE); intf_AssignKey( p_intf , ' ', INTF_KEY_TOGGLE_INTERFACE, 0);
intf_AssignSKey( p_intf , 'i', VLC_INFO); intf_AssignKey( p_intf , 'i', INTF_KEY_TOGGLE_INFO, 0);
intf_AssignSKey( p_intf , 's', VLC_SCALING); intf_AssignKey( p_intf , 's', INTF_KEY_TOGGLE_SCALING, 0);
} }
/***************************************************************************** /*****************************************************************************
...@@ -402,29 +391,29 @@ void intf_AssignNormalKeys( intf_thread_t *p_intf) ...@@ -402,29 +391,29 @@ void intf_AssignNormalKeys( intf_thread_t *p_intf)
int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
{ {
static int i_volbackup; static int i_volbackup;
keyparm i_reply; keyparm k_reply;
i_reply = intf_getKey( p_intf, g_key); k_reply = intf_getKey( p_intf, g_key);
switch( i_reply.key ) switch( k_reply.key )
{ {
case VLC_QUIT: /* quit order */ case INTF_KEY_QUIT: /* quit order */
p_intf->b_die = 1; p_intf->b_die = 1;
break; break;
case VLC_CHANNEL: case INTF_KEY_SET_CHANNEL:
/* Change channel - return code is ignored since SelectChannel displays /* Change channel - return code is ignored since SelectChannel displays
* its own error messages */ * its own error messages */
intf_SelectChannel( p_intf, i_reply.param - '0' ); intf_SelectChannel( p_intf, k_reply.param - '0' );
break; break;
case VLC_LOUDER: /* volume + */ case INTF_KEY_INC_VOLUME: /* volume + */
if( (p_main->p_aout != NULL) && (p_main->p_aout->vol < VOLMAX) ) if( (p_main->p_aout != NULL) && (p_main->p_aout->vol < VOLMAX) )
p_main->p_aout->vol += VOLSTEP; p_main->p_aout->vol += VOLSTEP;
break; break;
case VLC_QUIETER: /* volume - */ case INTF_KEY_DEC_VOLUME: /* volume - */
if( (p_main->p_aout != NULL) && (p_main->p_aout->vol > VOLSTEP) ) if( (p_main->p_aout != NULL) && (p_main->p_aout->vol > VOLSTEP) )
p_main->p_aout->vol -= VOLSTEP; p_main->p_aout->vol -= VOLSTEP;
break; break;
case VLC_MUTE: /* toggle mute */ case INTF_KEY_TOGGLE_VOLUME: /* toggle mute */
if( (p_main->p_aout != NULL) && (p_main->p_aout->vol)) if( (p_main->p_aout != NULL) && (p_main->p_aout->vol))
{ {
i_volbackup = p_main->p_aout->vol; i_volbackup = p_main->p_aout->vol;
...@@ -433,7 +422,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -433,7 +422,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
else if( (p_main->p_aout != NULL) && (!p_main->p_aout->vol)) else if( (p_main->p_aout != NULL) && (!p_main->p_aout->vol))
p_main->p_aout->vol = i_volbackup; p_main->p_aout->vol = i_volbackup;
break; break;
case VLC_LESS_GAMMA: /* gamma - */ case INTF_KEY_DEC_GAMMA: /* gamma - */
if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma > -INTF_GAMMA_LIMIT) ) if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
...@@ -442,7 +431,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -442,7 +431,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
vlc_mutex_unlock( &p_intf->p_vout->change_lock ); vlc_mutex_unlock( &p_intf->p_vout->change_lock );
} }
break; break;
case VLC_MORE_GAMMA: /* gamma + */ case INTF_KEY_INC_GAMMA: /* gamma + */
if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma < INTF_GAMMA_LIMIT) ) if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
...@@ -451,7 +440,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -451,7 +440,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
vlc_mutex_unlock( &p_intf->p_vout->change_lock ); vlc_mutex_unlock( &p_intf->p_vout->change_lock );
} }
break; break;
case VLC_GRAYSCALE: /* toggle grayscale */ case INTF_KEY_TOGGLE_GRAYSCALE: /* toggle grayscale */
if( p_intf->p_vout != NULL ) if( p_intf->p_vout != NULL )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
...@@ -460,7 +449,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -460,7 +449,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
vlc_mutex_unlock( &p_intf->p_vout->change_lock ); vlc_mutex_unlock( &p_intf->p_vout->change_lock );
} }
break; break;
case VLC_INTERFACE: /* toggle interface */ case INTF_KEY_TOGGLE_INTERFACE: /* toggle interface */
if( p_intf->p_vout != NULL ) if( p_intf->p_vout != NULL )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
...@@ -469,7 +458,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -469,7 +458,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
vlc_mutex_unlock( &p_intf->p_vout->change_lock ); vlc_mutex_unlock( &p_intf->p_vout->change_lock );
} }
break; break;
case VLC_INFO: /* toggle info */ case INTF_KEY_TOGGLE_INFO: /* toggle info */
if( p_intf->p_vout != NULL ) if( p_intf->p_vout != NULL )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
...@@ -478,7 +467,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -478,7 +467,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
vlc_mutex_unlock( &p_intf->p_vout->change_lock ); vlc_mutex_unlock( &p_intf->p_vout->change_lock );
} }
break; break;
case VLC_SCALING: /* toggle scaling */ case INTF_KEY_TOGGLE_SCALING: /* toggle scaling */
if( p_intf->p_vout != NULL ) if( p_intf->p_vout != NULL )
{ {
vlc_mutex_lock( &p_intf->p_vout->change_lock ); vlc_mutex_lock( &p_intf->p_vout->change_lock );
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment