Skip to content

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

Hello, 

Some news things:

 . I am still going on modifiying the key event handling method to make it more flexible. I still have a few things to get what I'd like to
 . added a keystrokes.h include which contains a generic name of all the VLC keys binding
 . modified some of the core interface routines to allow the passing of an extra parameter with a keystroke (VLC_CHANNEL).
 . next step: move all the interface dependent parts (such as the getKey function) to the plugins.

Hope this will run on your boxes...
parent c48d981f
Show whitespace changes
Inline Side-by-side
Showing with 348 additions and 294 deletions
TODO
View file @ 0765875a
...@@ -7,6 +7,13 @@ ...@@ -7,6 +7,13 @@
# #
# Urgency values: Wishlist, Normal, Important, Critical # Urgency values: Wishlist, Normal, Important, Critical
Task: 0x36
Difficulty: Medium
Urgency: Normal
Description: Finish the new keyboard input interface to support
interfaces that allow modifiers. This will allow the SDL to run
properly.
Task: 0x35 Task: 0x35
Difficulty: Medium Difficulty: Medium
Urgency: Important Urgency: Important
......
include/interface.h
View file @ 0765875a
...@@ -48,10 +48,17 @@ typedef int ( intf_sys_create_t ) ( p_intf_thread_t p_intf ); ...@@ -48,10 +48,17 @@ typedef int ( intf_sys_create_t ) ( p_intf_thread_t p_intf );
typedef void ( intf_sys_destroy_t ) ( p_intf_thread_t p_intf ); typedef void ( intf_sys_destroy_t ) ( p_intf_thread_t p_intf );
typedef void ( intf_sys_manage_t ) ( p_intf_thread_t p_intf ); typedef void ( intf_sys_manage_t ) ( p_intf_thread_t p_intf );
typedef struct _keyparam
{
int key;
int param;
} keyparm;
typedef struct _key typedef struct _key
{ {
int received_key; int received_key;
int forwarded_key; keyparm forwarded;
struct _key * next; struct _key * next;
} intf_key; } intf_key;
...@@ -81,6 +88,9 @@ typedef struct intf_thread_s ...@@ -81,6 +88,9 @@ typedef struct intf_thread_s
p_vout_thread_t p_vout; p_vout_thread_t p_vout;
p_input_thread_t p_input; p_input_thread_t p_input;
/* Specific functions */
keyparm (*p_intf_getKey)(struct intf_thread_s *p_intf, int r_key) ;
} intf_thread_t; } intf_thread_t;
/***************************************************************************** /*****************************************************************************
...@@ -93,9 +103,11 @@ void intf_Destroy ( intf_thread_t * p_intf ); ...@@ -93,9 +103,11 @@ void intf_Destroy ( intf_thread_t * p_intf );
int intf_SelectChannel ( intf_thread_t * p_intf, int i_channel ); int intf_SelectChannel ( intf_thread_t * p_intf, int i_channel );
int intf_ProcessKey ( intf_thread_t * p_intf, int i_key ); int intf_ProcessKey ( intf_thread_t * p_intf, int i_key );
void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key); void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param);
void intf_AssignSKey( intf_thread_t *p_intf, int r_key, int f_key);
int intf_getKey( intf_thread_t *p_intf, int r_key); keyparm intf_getKey( intf_thread_t *p_intf, int r_key);
void intf_AssignNormalKeys( intf_thread_t *p_intf); void intf_AssignNormalKeys( intf_thread_t *p_intf);
include/keystrokes.h 0 → 100644
View file @ 0765875a
#ifndef VLC_KEYS
#define VLC_KEYS
#define VLC_QUIT 0x01
#define VLC_CHANNEL 0x02
#define VLC_LOUDER 0x03
#define VLC_QUIETER 0x04
#define VLC_MUTE 0x05
#define VLC_LESS_GAMMA 0x06
#define VLC_MORE_GAMMA 0x07
#define VLC_GRAYSCALE 0x08
#define VLC_INTERFACE 0x09
#define VLC_INFO 0x0A
#define VLC_SCALING 0x0B
#define VLC_UNKNOWN 0x0C
//#define VLC_CHANNEL 0x0D
#endif
plugins/sdl/intf_sdl.c
View file @ 0765875a
...@@ -44,6 +44,7 @@ ...@@ -44,6 +44,7 @@
#include "interface.h" #include "interface.h"
#include "intf_msg.h" #include "intf_msg.h"
#include "keystrokes.h"
#include "main.h" #include "main.h"
...@@ -147,7 +148,7 @@ void intf_SDLManage( intf_thread_t *p_intf ) ...@@ -147,7 +148,7 @@ void intf_SDLManage( intf_thread_t *p_intf )
} }
break; break;
case SDL_QUIT: case SDL_QUIT:
intf_ProcessKey( p_intf, 'Q' ); intf_ProcessKey( p_intf, VLC_QUIT );
break; break;
default: default:
break; break;
...@@ -155,31 +156,34 @@ void intf_SDLManage( intf_thread_t *p_intf ) ...@@ -155,31 +156,34 @@ 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 )
{ {
intf_AssignKey(p_intf, SDLK_q, 'Q'); p_intf->p_intf_getKey = intf_getKey;
intf_AssignKey(p_intf, SDLK_ESCAPE, 'Q'); intf_AssignSKey(p_intf, SDLK_q, VLC_QUIT);
intf_AssignSKey(p_intf, SDLK_ESCAPE, VLC_QUIT);
/* intf_AssignKey(p_intf,3,'Q'); */ /* intf_AssignKey(p_intf,3,'Q'); */
intf_AssignKey(p_intf, SDLK_0, '0'); intf_AssignKey(p_intf, SDLK_0, VLC_CHANNEL,0);
intf_AssignKey(p_intf, SDLK_1, '1'); intf_AssignKey(p_intf, SDLK_1, VLC_CHANNEL,1);
intf_AssignKey(p_intf, SDLK_2, '2'); intf_AssignKey(p_intf, SDLK_2, VLC_CHANNEL,2);
intf_AssignKey(p_intf, SDLK_3, '3'); intf_AssignKey(p_intf, SDLK_3, VLC_CHANNEL,3);
intf_AssignKey(p_intf, SDLK_4, '4'); intf_AssignKey(p_intf, SDLK_4, VLC_CHANNEL,4);
intf_AssignKey(p_intf, SDLK_5, '5'); intf_AssignKey(p_intf, SDLK_5, VLC_CHANNEL,5);
intf_AssignKey(p_intf, SDLK_6, '6'); intf_AssignKey(p_intf, SDLK_6, VLC_CHANNEL,6);
intf_AssignKey(p_intf, SDLK_7, '7'); intf_AssignKey(p_intf, SDLK_7, VLC_CHANNEL,7);
intf_AssignKey(p_intf, SDLK_8, '8'); intf_AssignKey(p_intf, SDLK_8, VLC_CHANNEL,8);
intf_AssignKey(p_intf, SDLK_9, '9'); intf_AssignKey(p_intf, SDLK_9, VLC_CHANNEL,9);
intf_AssignKey(p_intf, SDLK_PLUS, '+'); intf_AssignSKey(p_intf, SDLK_PLUS, VLC_LOUDER);
intf_AssignKey(p_intf, SDLK_MINUS, '-'); intf_AssignSKey(p_intf, SDLK_MINUS, VLC_QUIETER);
intf_AssignKey(p_intf, SDLK_m, 'M'); intf_AssignSKey(p_intf, SDLK_m, VLC_MUTE);
/* intf_AssignKey(p_intf,'M','M'); */ /* intf_AssignKey(p_intf,'M','M'); */
intf_AssignKey(p_intf, SDLK_g, 'g'); intf_AssignSKey(p_intf, SDLK_g, VLC_LESS_GAMMA);
/* intf_AssignKey(p_intf,'G','G'); */ /* intf_AssignKey(p_intf,'G','G'); */
intf_AssignKey(p_intf, SDLK_c, 'c'); intf_AssignSKey(p_intf, SDLK_c, VLC_GRAYSCALE);
intf_AssignKey(p_intf, SDLK_SPACE, ' '); intf_AssignSKey(p_intf, SDLK_SPACE, VLC_INTERFACE);
intf_AssignKey(p_intf, 'i', 'i'); intf_AssignSKey(p_intf, 'i', VLC_INFO);
intf_AssignKey(p_intf, SDLK_s, 's'); intf_AssignSKey(p_intf, SDLK_s, VLC_SCALING);
} }
src/interface/interface.c
View file @ 0765875a
...@@ -48,6 +48,7 @@ ...@@ -48,6 +48,7 @@
#include "interface.h" #include "interface.h"
#include "intf_cmd.h" #include "intf_cmd.h"
#include "intf_console.h" #include "intf_console.h"
#include "keystrokes.h"
#include "video.h" #include "video.h"
#include "video_output.h" #include "video_output.h"
...@@ -162,15 +163,15 @@ intf_thread_t* intf_Create( void ) ...@@ -162,15 +163,15 @@ intf_thread_t* intf_Create( void )
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 );
...@@ -208,15 +209,15 @@ void intf_Run( intf_thread_t *p_intf ) ...@@ -208,15 +209,15 @@ void intf_Run( intf_thread_t *p_intf )
* 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 */
...@@ -239,16 +240,16 @@ void intf_Destroy( intf_thread_t *p_intf ) ...@@ -239,16 +240,16 @@ void intf_Destroy( intf_thread_t *p_intf )
/* 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 */
...@@ -282,24 +283,25 @@ int intf_SelectChannel( intf_thread_t * p_intf, int i_channel ) ...@@ -282,24 +283,25 @@ int intf_SelectChannel( intf_thread_t * p_intf, int i_channel )
/* 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. * * and the key we use internally. Support one extra parameter. *
****************************************************************************/ ****************************************************************************/
void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key) 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->next = NULL; p_cur->next = NULL;
p_intf->p_keys = p_cur; p_intf->p_keys = p_cur;
} else { } else {
...@@ -312,64 +314,83 @@ void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key) ...@@ -312,64 +314,83 @@ void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key)
p_cur->next = ( p_intf_key )( malloc( sizeof( intf_key ) ) ); p_cur->next = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
p_cur = p_cur->next; p_cur = p_cur->next;
p_cur->next = NULL; p_cur->next = NULL;
p_cur->forwarded.param = param;
p_cur->received_key = r_key; p_cur->received_key = r_key;
} }
p_cur->forwarded_key = f_key; p_cur->forwarded.key = f_key;
}
} }
}
/*****************************************************************************
* intf_AssignSKey: assign standartkeys *
*****************************************************************************
* This function fills in the associative array that links the key pressed *
* and the key we use internally. *
****************************************************************************/
void intf_AssignSKey(intf_thread_t *p_intf, int r_key, int f_key)
{
intf_AssignKey( p_intf, r_key, f_key, 0);
}
/* Basic getKey function... */
keyparm intf_getKey( intf_thread_t *p_intf, int r_key)
{
keyparm reply;
int intf_getKey( intf_thread_t *p_intf, int r_key)
{
p_intf_key current = p_intf->p_keys; p_intf_key current = p_intf->p_keys;
while(current != NULL && current->received_key != r_key) while(current != NULL && current->received_key != r_key)
{ {
current = current->next; current = current->next;
} }
if(current == NULL) if(current == NULL)
/* didn't find any key in the array */ { /* didn't find any key in the array */
return( -1 ); reply.key=VLC_UNKNOWN;
reply.param=0;
}
else else
return( current->forwarded_key ); {
/* well, something went wrong */ reply.key = current->forwarded.key;
return( -1 ); reply.param = current->forwarded.param;
} }
return reply;
}
/***************************************************************************** /*****************************************************************************
* intf_AssignNormalKeys: used for normal interfaces. * intf_AssignNormalKeys: used for normal interfaces.
***************************************************************************** *****************************************************************************
* This function assign the basic key to the normal keys. * 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)
{ {
intf_AssignKey( p_intf , 'q', 'Q'); p_intf->p_intf_getKey = intf_getKey;
intf_AssignKey( p_intf , 'Q', 'Q');
intf_AssignKey( p_intf , 27, 'Q'); intf_AssignSKey( p_intf , 'Q', VLC_QUIT);
intf_AssignKey( p_intf , 3, 'Q'); intf_AssignSKey( p_intf , 'q', VLC_QUIT);
intf_AssignKey( p_intf , '0', '0'); intf_AssignSKey( p_intf , 27, VLC_QUIT);
intf_AssignKey( p_intf , '1', '1'); intf_AssignSKey( p_intf , 3, VLC_QUIT);
intf_AssignKey( p_intf , '2', '2'); intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0);
intf_AssignKey( p_intf , '3', '3'); intf_AssignKey( p_intf , '1', VLC_CHANNEL, 1);
intf_AssignKey( p_intf , '4', '4'); intf_AssignKey( p_intf , '2', VLC_CHANNEL, 2);
intf_AssignKey( p_intf , '5', '5'); intf_AssignKey( p_intf , '3', VLC_CHANNEL, 3);
intf_AssignKey( p_intf , '6', '6'); intf_AssignKey( p_intf , '4', VLC_CHANNEL, 4);
intf_AssignKey( p_intf , '7', '7'); intf_AssignKey( p_intf , '5', VLC_CHANNEL, 5);
intf_AssignKey( p_intf , '8', '8'); intf_AssignKey( p_intf , '6', VLC_CHANNEL, 6);
intf_AssignKey( p_intf , '9', '9'); intf_AssignKey( p_intf , '7', VLC_CHANNEL, 7);
intf_AssignKey( p_intf , '0', '0'); intf_AssignKey( p_intf , '8', VLC_CHANNEL, 8);
intf_AssignKey( p_intf , '+', '+'); intf_AssignKey( p_intf , '9', VLC_CHANNEL, 9);
intf_AssignKey( p_intf , '-', '-'); intf_AssignKey( p_intf , '0', VLC_CHANNEL, 0);
intf_AssignKey( p_intf , 'm', 'M'); intf_AssignSKey( p_intf , '+', VLC_LOUDER);
intf_AssignKey( p_intf , 'M', 'M'); intf_AssignSKey( p_intf , '-', VLC_QUIETER);
intf_AssignKey( p_intf , 'g', 'g'); intf_AssignSKey( p_intf , 'm', VLC_MUTE);
intf_AssignKey( p_intf , 'G', 'G'); intf_AssignSKey( p_intf , 'M', VLC_MUTE);
intf_AssignKey( p_intf , 'c', 'c'); intf_AssignSKey( p_intf , 'g', VLC_LESS_GAMMA);
intf_AssignKey( p_intf , ' ', ' '); intf_AssignSKey( p_intf , 'G', VLC_MORE_GAMMA);
intf_AssignKey( p_intf , 'i', 'i'); intf_AssignSKey( p_intf , 'c', VLC_GRAYSCALE);
intf_AssignKey( p_intf , 's', 's'); intf_AssignSKey( p_intf , ' ', VLC_INTERFACE);
intf_AssignSKey( p_intf , 'i', VLC_INFO);
intf_AssignSKey( p_intf , 's', VLC_SCALING);
} }
/***************************************************************************** /*****************************************************************************
...@@ -381,37 +402,29 @@ void intf_AssignNormalKeys( intf_thread_t *p_intf) ...@@ -381,37 +402,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;
int i_key; keyparm i_reply;
i_reply = intf_getKey( p_intf, g_key);
i_key = intf_getKey( p_intf, g_key); switch( i_reply.key )
switch( i_key )
{ {
case 'Q': /* quit order */ case VLC_QUIT: /* quit order */
p_intf->b_die = 1; p_intf->b_die = 1;
break; break;
case '0': /* source change */ case VLC_CHANNEL:
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* 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_key - '0' ); intf_SelectChannel( p_intf, i_reply.param - '0' );
break; break;
case '+': /* volume + */ case VLC_LOUDER: /* 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 '-': /* volume - */ case VLC_QUIETER: /* 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 'M': /* toggle mute */ case VLC_MUTE: /* 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;
...@@ -420,7 +433,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -420,7 +433,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 'g': /* gamma - */ case VLC_LESS_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 );
...@@ -429,7 +442,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -429,7 +442,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 'G': /* gamma + */ case VLC_MORE_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 );
...@@ -438,7 +451,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -438,7 +451,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 'c': /* toggle grayscale */ case VLC_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 );
...@@ -447,7 +460,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -447,7 +460,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 ' ': /* toggle interface */ case VLC_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 );
...@@ -456,7 +469,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -456,7 +469,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 'i': /* toggle info */ case VLC_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 );
...@@ -465,7 +478,7 @@ int intf_ProcessKey( intf_thread_t *p_intf, int g_key ) ...@@ -465,7 +478,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 's': /* toggle scaling */ case VLC_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