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  *
   8  * Authors:
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include "defs.h"
  29
  30 #include <errno.h>                                                 /* ENOMEM */
  31 #include <stdlib.h>                                      /* free(), strtol() */
  32 #include <stdio.h>                                                   /* FILE */
  33 #include <string.h>                                            /* strerror() */
  34
  35 #include "config.h"
  36 #include "common.h"
  37 #include "threads.h"
  38 #include "mtime.h"
  39 #include "modules.h"
  40
  41 #include "stream_control.h"
  42 #include "input_ext-intf.h"
  43
  44 #include "audio_output.h"
  45
  46 #include "intf_msg.h"
  47 #include "interface.h"
  48 #include "intf_cmd.h"
  49 #include "intf_plst.h"
  50 #include "intf_channels.h"
  51 #include "keystrokes.h"
  52
  53 #include "video.h"
  54 #include "video_output.h"
  55
  56 #include "main.h"
  57
  58 /*****************************************************************************
  59  * Local prototypes
  60  *****************************************************************************/
  61 static void intf_Manage( intf_thread_t *p_intf );
  62
  63 /*****************************************************************************
  64  * intf_Create: prepare interface before main loop
  65  *****************************************************************************
  66  * This function opens output devices and creates specific interfaces. It sends
  67  * its own error messages.
  68  *****************************************************************************/
  69 intf_thread_t* intf_Create( void )
  70 {
  71     intf_thread_t * p_intf;
  72
  73     /* Allocate structure */
  74     p_intf = malloc( sizeof( intf_thread_t ) );
  75     if( !p_intf )
  76     {
  77         intf_ErrMsg( "intf error: cannot create interface thread (%s)",
  78                      strerror( ENOMEM ) );
  79         return( NULL );
  80     }
  81
  82     /* Choose the best module */
  83     p_intf->p_module = module_Need( p_main->p_bank,
  84                                     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_main->p_bank, 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( p_main->p_bank );
 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_PlstNext( 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_main->p_bank, 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
 325     switch( k_reply.key )
 326     {
 327     case INTF_KEY_QUIT:                                                  /* quit order */
 328         p_intf->b_die = 1;
 329         break;
 330     case INTF_KEY_SET_CHANNEL:
 331         /* Change channel - return code is ignored since SelectChannel displays
 332          * its own error messages */
 333         intf_SelectChannel( p_intf, k_reply.param );
 334         break;
 335     case INTF_KEY_INC_VOLUME:                                    /* volume + */
 336         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol < VOLUME_MAX) )
 337             p_main->p_aout->vol += VOLUME_STEP;
 338         break;
 339     case INTF_KEY_DEC_VOLUME:                                    /* volume - */
 340         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol > VOLUME_STEP) )
 341             p_main->p_aout->vol -= VOLUME_STEP;
 342         break;
 343     case INTF_KEY_TOGGLE_VOLUME:                              /* toggle mute */
 344         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol))
 345         {
 346             i_volbackup = p_main->p_aout->vol;
 347             p_main->p_aout->vol = 0;
 348         }
 349         else if( (p_main->p_aout != NULL) && (!p_main->p_aout->vol))
 350             p_main->p_aout->vol = i_volbackup;
 351         break;
 352     case INTF_KEY_DEC_GAMMA:                                      /* gamma - */
 353         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
 354         {
 355             /* FIXME: we should lock if called from the interface */
 356             p_main->p_vout->f_gamma   -= INTF_GAMMA_STEP;
 357             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 358         }
 359         break;
 360     case INTF_KEY_INC_GAMMA:                                      /* gamma + */
 361         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
 362         {
 363             /* FIXME: we should lock if called from the interface */
 364             p_main->p_vout->f_gamma   += INTF_GAMMA_STEP;
 365             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 366         }
 367         break;
 368    case INTF_KEY_DUMP_STREAM:
 369         if( p_intf->p_input != NULL )
 370         {
 371             vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
 372             input_DumpStream( p_intf->p_input );
 373             vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
 374         }
 375         break;
 376    default:                                                   /* unknown key */
 377         return( 1 );
 378     }
 379
 380     return( 0 );
 381 }
 382