git.sesse.net Git - vlc/blob - src/interface/interface.c

   1 /*****************************************************************************
   2  * interface.c: interface access for other threads
   3  * This library provides basic functions for threads to interact with user
   4  * interface, such as command line.
   5  *****************************************************************************
   6  * Copyright (C) 1998, 1999, 2000 VideoLAN
   7  * $Id: interface.c,v 1.75 2001/05/01 04:18:18 sam Exp $
   8  *
   9  * Authors: Vincent Seguin <seguin@via.ecp.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include "defs.h"
  30
  31 #include <errno.h>                                                 /* ENOMEM */
  32 #include <stdlib.h>                                      /* free(), strtol() */
  33 #include <stdio.h>                                                   /* FILE */
  34 #include <string.h>                                            /* strerror() */
  35 #include <sys/types.h>                                              /* off_t */
  36
  37 #include "config.h"
  38 #include "common.h"
  39 #include "threads.h"
  40 #include "mtime.h"
  41 #include "modules.h"
  42
  43 #include "stream_control.h"
  44 #include "input_ext-intf.h"
  45
  46 #include "audio_output.h"
  47
  48 #include "intf_msg.h"
  49 #include "interface.h"
  50 #include "intf_playlist.h"
  51 #include "intf_channels.h"
  52 #include "keystrokes.h"
  53
  54 #include "video.h"
  55 #include "video_output.h"
  56
  57 #include "main.h"
  58
  59 /*****************************************************************************
  60  * Local prototypes
  61  *****************************************************************************/
  62 static void intf_Manage( intf_thread_t *p_intf );
  63
  64 /*****************************************************************************
  65  * intf_Create: prepare interface before main loop
  66  *****************************************************************************
  67  * This function opens output devices and creates specific interfaces. It sends
  68  * its own error messages.
  69  *****************************************************************************/
  70 intf_thread_t* intf_Create( void )
  71 {
  72     intf_thread_t * p_intf;
  73
  74     /* Allocate structure */
  75     p_intf = malloc( sizeof( intf_thread_t ) );
  76     if( !p_intf )
  77     {
  78         intf_ErrMsg( "intf error: cannot create interface thread (%s)",
  79                      strerror( ENOMEM ) );
  80         return( NULL );
  81     }
  82
  83     /* Choose the best module */
  84     p_intf->p_module = module_Need( MODULE_CAPABILITY_INTF, NULL );
  85
  86     if( p_intf->p_module == NULL )
  87     {
  88         intf_ErrMsg( "intf error: no suitable intf module" );
  89         free( p_intf );
  90         return( NULL );
  91     }
  92
  93 #define f p_intf->p_module->p_functions->intf.functions.intf
  94     p_intf->pf_open       = f.pf_open;
  95     p_intf->pf_close      = f.pf_close;
  96     p_intf->pf_run        = f.pf_run;
  97 #undef f
  98
  99     /* Initialize callbacks */
 100     p_intf->pf_manage     = intf_Manage;
 101
 102     /* Initialize structure */
 103     p_intf->b_die         = 0;
 104
 105     p_intf->p_input       = NULL;
 106     p_intf->p_keys        = NULL;
 107     p_intf->b_menu        = 0;
 108     p_intf->b_menu_change = 0;
 109
 110     if( p_intf->pf_open( p_intf ) )
 111     {
 112         intf_ErrMsg("intf error: cannot create interface");
 113         module_Unneed( p_intf->p_module );
 114         free( p_intf );
 115         return( NULL );
 116     }
 117
 118     /* Initialize mutexes */
 119     vlc_mutex_init( &p_intf->change_lock );
 120
 121     /* Load channels - the pointer will be set to NULL on failure. The
 122      * return value is ignored since the program can work without
 123      * channels */
 124     intf_LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR,
 125                                                     INTF_CHANNELS_DEFAULT ));
 126
 127     intf_Msg("intf: interface initialized");
 128     return( p_intf );
 129 }
 130
 131 /*****************************************************************************
 132  * intf_Manage: manage interface
 133  *****************************************************************************
 134  * This function has to be called regularly by the interface plugin. It
 135  * checks for playlist end, module expiration, message flushing, and a few
 136  * other useful things.
 137  *****************************************************************************/
 138 static void intf_Manage( intf_thread_t *p_intf )
 139 {
 140     /* Flush waiting messages */
 141     intf_FlushMsg();
 142
 143     /* Manage module bank */
 144     module_ManageBank( );
 145
 146     if( ( p_intf->p_input != NULL ) &&
 147             ( p_intf->p_input->b_error || p_intf->p_input->b_eof ) )
 148     {
 149         input_DestroyThread( p_intf->p_input, NULL );
 150         p_intf->p_input = NULL;
 151         intf_DbgMsg("Input thread destroyed");
 152     }
 153
 154     /* If no stream is being played, try to find one */
 155     if( p_intf->p_input == NULL && !p_intf->b_die )
 156     {
 157         /* Select the next playlist item */
 158         intf_PlaylistNext( p_main->p_playlist );
 159
 160         if( p_main->p_playlist->i_index == -1 )
 161         {
 162             /*    FIXME: wait for user to add stuff to playlist ? */
 163 #if 0
 164             p_intf->b_die = 1;
 165 #endif
 166         }
 167         else
 168         {
 169             p_intf->p_input =
 170                 input_CreateThread( &p_main->p_playlist->current, NULL );
 171         }
 172     }
 173 }
 174
 175 /*****************************************************************************
 176  * intf_Destroy: clean interface after main loop
 177  *****************************************************************************
 178  * This function destroys specific interfaces and close output devices.
 179  *****************************************************************************/
 180 void intf_Destroy( intf_thread_t *p_intf )
 181 {
 182     p_intf_key  p_cur;
 183     p_intf_key  p_next;
 184
 185     /* Unload channels */
 186     intf_UnloadChannels( p_intf );
 187
 188     /* Destroy interfaces */
 189     p_intf->pf_close( p_intf );
 190
 191     /* Close input thread, if any (blocking) */
 192     if( p_intf->p_input )
 193     {
 194         input_DestroyThread( p_intf->p_input, NULL );
 195     }
 196
 197     /* Destroy keymap */
 198     p_cur = p_intf->p_keys;
 199     while( p_cur != NULL)
 200     {
 201         p_next = p_cur->next;
 202         free(p_cur);
 203         p_cur = p_next;
 204     }
 205
 206     /* Unlock module */
 207     module_Unneed( p_intf->p_module );
 208
 209     vlc_mutex_destroy( &p_intf->change_lock );
 210
 211     /* Free structure */
 212     free( p_intf );
 213 }
 214
 215 /*****************************************************************************
 216  * intf_AssignKey: assign standartkeys                                       *
 217  *****************************************************************************
 218  * This function fills in the associative array that links the key pressed   *
 219  * and the key we use internally. Support one extra parameter.               *
 220  ****************************************************************************/
 221 void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
 222 {
 223     p_intf_key  p_cur =  p_intf->p_keys;
 224     if( p_cur == NULL )
 225     {
 226         p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
 227         p_cur->received_key = r_key;
 228         p_cur->forwarded.key = f_key;
 229         p_cur->forwarded.param = param;
 230         p_cur->next = NULL;
 231         p_intf->p_keys = p_cur;
 232     }
 233     else
 234     {
 235         while( p_cur->next != NULL && p_cur ->received_key != r_key)
 236         {
 237             p_cur = p_cur->next;
 238         }
 239         if( p_cur->next == NULL )
 240         {
 241             p_cur->next  = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
 242             p_cur = p_cur->next;
 243             p_cur->next = NULL;
 244             p_cur->forwarded.param = param;
 245             p_cur->received_key = r_key;
 246         }
 247         p_cur->forwarded.key = f_key;
 248     }
 249 }
 250
 251 /* Basic getKey function... */
 252 keyparm intf_GetKey( intf_thread_t *p_intf, int r_key)
 253 {
 254     keyparm reply;
 255
 256     p_intf_key current = p_intf->p_keys;
 257     while(current != NULL && current->received_key != r_key)
 258     {
 259         current = current->next;
 260     }
 261     if(current == NULL)
 262     {   /* didn't find any key in the array */
 263         reply.key = INTF_KEY_UNKNOWN;
 264         reply.param = 0;
 265     }
 266     else
 267     {
 268         reply.key = current->forwarded.key;
 269         reply.param = current->forwarded.param;
 270     }
 271     return reply;
 272 }
 273
 274 /*****************************************************************************
 275 * intf_AssignNormalKeys: used for normal interfaces.
 276 *****************************************************************************
 277 * This function assign the basic key to the normal keys.
 278 *****************************************************************************/
 279
 280 void intf_AssignNormalKeys( intf_thread_t *p_intf)
 281 {
 282     p_intf->p_intf_get_key = intf_GetKey;
 283
 284     intf_AssignKey( p_intf , 'Q', INTF_KEY_QUIT, 0);
 285     intf_AssignKey( p_intf , 'q', INTF_KEY_QUIT, 0);
 286     intf_AssignKey( p_intf ,  27, INTF_KEY_QUIT, 0);
 287     intf_AssignKey( p_intf ,   3, INTF_KEY_QUIT, 0);
 288     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 289     intf_AssignKey( p_intf , '1', INTF_KEY_SET_CHANNEL, 1);
 290     intf_AssignKey( p_intf , '2', INTF_KEY_SET_CHANNEL, 2);
 291     intf_AssignKey( p_intf , '3', INTF_KEY_SET_CHANNEL, 3);
 292     intf_AssignKey( p_intf , '4', INTF_KEY_SET_CHANNEL, 4);
 293     intf_AssignKey( p_intf , '5', INTF_KEY_SET_CHANNEL, 5);
 294     intf_AssignKey( p_intf , '6', INTF_KEY_SET_CHANNEL, 6);
 295     intf_AssignKey( p_intf , '7', INTF_KEY_SET_CHANNEL, 7);
 296     intf_AssignKey( p_intf , '8', INTF_KEY_SET_CHANNEL, 8);
 297     intf_AssignKey( p_intf , '9', INTF_KEY_SET_CHANNEL, 9);
 298     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 299     intf_AssignKey( p_intf , '+', INTF_KEY_INC_VOLUME, 0);
 300     intf_AssignKey( p_intf , '-', INTF_KEY_DEC_VOLUME, 0);
 301     intf_AssignKey( p_intf , 'm', INTF_KEY_TOGGLE_VOLUME, 0);
 302     intf_AssignKey( p_intf , 'M', INTF_KEY_TOGGLE_VOLUME, 0);
 303     intf_AssignKey( p_intf , 'g', INTF_KEY_DEC_GAMMA, 0);
 304     intf_AssignKey( p_intf , 'G', INTF_KEY_INC_GAMMA, 0);
 305     intf_AssignKey( p_intf , 'c', INTF_KEY_TOGGLE_GRAYSCALE, 0);
 306     intf_AssignKey( p_intf , ' ', INTF_KEY_TOGGLE_INTERFACE, 0);
 307     intf_AssignKey( p_intf , 'i', INTF_KEY_TOGGLE_INFO, 0);
 308     intf_AssignKey( p_intf , 's', INTF_KEY_TOGGLE_SCALING, 0);
 309     intf_AssignKey( p_intf , 'd', INTF_KEY_DUMP_STREAM, 0);
 310 }
 311
 312 /*****************************************************************************
 313  * intf_ProcessKey: process standard keys
 314  *****************************************************************************
 315  * This function will process standard keys and return non 0 if the key was
 316  * unknown.
 317  *****************************************************************************/
 318 int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
 319 {
 320     static int i_volbackup;
 321     keyparm k_reply;
 322
 323     k_reply = intf_GetKey( p_intf, g_key);
 324     switch( k_reply.key )
 325     {
 326     case INTF_KEY_QUIT:                                        /* quit order */
 327         p_intf->b_die = 1;
 328         break;
 329     case INTF_KEY_SET_CHANNEL:
 330         /* Change channel - return code is ignored since SelectChannel displays
 331          * its own error messages */
 332 /*        intf_SelectChannel( p_intf, k_reply.param ); */
 333 /*        network_ChannelJoin() */
 334 /* FIXME : keyboard event is for the time being half handled by the interface
 335  * half handled directly by the plugins. We should decide what to do. */
 336         break;
 337     case INTF_KEY_INC_VOLUME:                                    /* volume + */
 338         if( (p_main->p_aout != NULL) && (p_main->p_aout->i_vol < VOLUME_MAX) )
 339             p_main->p_aout->i_vol += VOLUME_STEP;
 340         break;
 341     case INTF_KEY_DEC_VOLUME:                                    /* volume - */
 342         if( (p_main->p_aout != NULL) && (p_main->p_aout->i_vol > VOLUME_STEP) )
 343             p_main->p_aout->i_vol -= VOLUME_STEP;
 344         break;
 345     case INTF_KEY_TOGGLE_VOLUME:                              /* toggle mute */
 346         if( (p_main->p_aout != NULL) && (p_main->p_aout->i_vol))
 347         {
 348             i_volbackup = p_main->p_aout->i_vol;
 349             p_main->p_aout->i_vol = 0;
 350         }
 351         else if( (p_main->p_aout != NULL) && (!p_main->p_aout->i_vol))
 352             p_main->p_aout->i_vol = i_volbackup;
 353         break;
 354     case INTF_KEY_DEC_GAMMA:                                      /* gamma - */
 355         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
 356         {
 357             /* FIXME: we should lock if called from the interface */
 358             p_main->p_vout->f_gamma   -= INTF_GAMMA_STEP;
 359             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 360         }
 361         break;
 362     case INTF_KEY_INC_GAMMA:                                      /* gamma + */
 363         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
 364         {
 365             /* FIXME: we should lock if called from the interface */
 366             p_main->p_vout->f_gamma   += INTF_GAMMA_STEP;
 367             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 368         }
 369         break;
 370    case INTF_KEY_DUMP_STREAM:
 371         if( p_intf->p_input != NULL )
 372         {
 373             vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
 374             input_DumpStream( p_intf->p_input );
 375             vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
 376         }
 377         break;
 378    default:                                                   /* unknown key */
 379         return( 1 );
 380     }
 381
 382     return( 0 );
 383 }