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.78 2001/05/15 01:01:44 stef 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_WarnMsg( 1, "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         if( !p_main->p_playlist->b_stopped )
 158         {
 159             /* Select the next playlist item */
 160             intf_PlaylistNext( p_main->p_playlist );
 161
 162             /* don't loop by default: stop at playlist end */
 163             if( p_main->p_playlist->i_index == -1 )
 164             {
 165                 p_main->p_playlist->b_stopped = 1;
 166             }
 167             else
 168             {
 169                 p_main->p_playlist->b_stopped = 0;
 170                 p_intf->p_input =
 171                     input_CreateThread( &p_main->p_playlist->current, NULL );
 172             }
 173         }
 174         else
 175         {
 176             /* playing has been stopped: we no longer need outputs */
 177             if( p_aout_bank->i_count )
 178             {
 179                 /* FIXME kludge that does not work with several outputs */
 180                 aout_DestroyThread( p_aout_bank->pp_aout[0], NULL );
 181                 p_aout_bank->i_count--;
 182             }
 183             if( p_vout_bank->i_count )
 184             {
 185                 vout_DestroyThread( p_vout_bank->pp_vout[0], NULL );
 186                 p_vout_bank->i_count--;
 187             }
 188         }
 189     }
 190 }
 191
 192 /*****************************************************************************
 193  * intf_Destroy: clean interface after main loop
 194  *****************************************************************************
 195  * This function destroys specific interfaces and close output devices.
 196  *****************************************************************************/
 197 void intf_Destroy( intf_thread_t *p_intf )
 198 {
 199     p_intf_key  p_cur;
 200     p_intf_key  p_next;
 201
 202     /* Unload channels */
 203     intf_UnloadChannels( p_intf );
 204
 205     /* Destroy interfaces */
 206     p_intf->pf_close( p_intf );
 207
 208     /* Close input thread, if any (blocking) */
 209     if( p_intf->p_input )
 210     {
 211         input_DestroyThread( p_intf->p_input, NULL );
 212     }
 213
 214     /* Destroy keymap */
 215     p_cur = p_intf->p_keys;
 216     while( p_cur != NULL)
 217     {
 218         p_next = p_cur->next;
 219         free(p_cur);
 220         p_cur = p_next;
 221     }
 222
 223     /* Unlock module */
 224     module_Unneed( p_intf->p_module );
 225
 226     vlc_mutex_destroy( &p_intf->change_lock );
 227
 228     /* Free structure */
 229     free( p_intf );
 230 }
 231
 232 /*****************************************************************************
 233  * intf_AssignKey: assign standartkeys                                       *
 234  *****************************************************************************
 235  * This function fills in the associative array that links the key pressed   *
 236  * and the key we use internally. Support one extra parameter.               *
 237  ****************************************************************************/
 238 void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
 239 {
 240     p_intf_key  p_cur =  p_intf->p_keys;
 241     if( p_cur == NULL )
 242     {
 243         p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
 244         p_cur->received_key = r_key;
 245         p_cur->forwarded.key = f_key;
 246         p_cur->forwarded.param = param;
 247         p_cur->next = NULL;
 248         p_intf->p_keys = p_cur;
 249     }
 250     else
 251     {
 252         while( p_cur->next != NULL && p_cur ->received_key != r_key)
 253         {
 254             p_cur = p_cur->next;
 255         }
 256         if( p_cur->next == NULL )
 257         {
 258             p_cur->next  = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
 259             p_cur = p_cur->next;
 260             p_cur->next = NULL;
 261             p_cur->forwarded.param = param;
 262             p_cur->received_key = r_key;
 263         }
 264         p_cur->forwarded.key = f_key;
 265     }
 266 }
 267
 268 /* Basic getKey function... */
 269 keyparm intf_GetKey( intf_thread_t *p_intf, int r_key)
 270 {
 271     keyparm reply;
 272
 273     p_intf_key current = p_intf->p_keys;
 274     while(current != NULL && current->received_key != r_key)
 275     {
 276         current = current->next;
 277     }
 278     if(current == NULL)
 279     {   /* didn't find any key in the array */
 280         reply.key = INTF_KEY_UNKNOWN;
 281         reply.param = 0;
 282     }
 283     else
 284     {
 285         reply.key = current->forwarded.key;
 286         reply.param = current->forwarded.param;
 287     }
 288     return reply;
 289 }
 290
 291 /*****************************************************************************
 292 * intf_AssignNormalKeys: used for normal interfaces.
 293 *****************************************************************************
 294 * This function assign the basic key to the normal keys.
 295 *****************************************************************************/
 296
 297 void intf_AssignNormalKeys( intf_thread_t *p_intf)
 298 {
 299     p_intf->p_intf_get_key = intf_GetKey;
 300
 301     intf_AssignKey( p_intf , 'Q', INTF_KEY_QUIT, 0);
 302     intf_AssignKey( p_intf , 'q', INTF_KEY_QUIT, 0);
 303     intf_AssignKey( p_intf ,  27, INTF_KEY_QUIT, 0);
 304     intf_AssignKey( p_intf ,   3, INTF_KEY_QUIT, 0);
 305     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 306     intf_AssignKey( p_intf , '1', INTF_KEY_SET_CHANNEL, 1);
 307     intf_AssignKey( p_intf , '2', INTF_KEY_SET_CHANNEL, 2);
 308     intf_AssignKey( p_intf , '3', INTF_KEY_SET_CHANNEL, 3);
 309     intf_AssignKey( p_intf , '4', INTF_KEY_SET_CHANNEL, 4);
 310     intf_AssignKey( p_intf , '5', INTF_KEY_SET_CHANNEL, 5);
 311     intf_AssignKey( p_intf , '6', INTF_KEY_SET_CHANNEL, 6);
 312     intf_AssignKey( p_intf , '7', INTF_KEY_SET_CHANNEL, 7);
 313     intf_AssignKey( p_intf , '8', INTF_KEY_SET_CHANNEL, 8);
 314     intf_AssignKey( p_intf , '9', INTF_KEY_SET_CHANNEL, 9);
 315     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 316     intf_AssignKey( p_intf , '+', INTF_KEY_INC_VOLUME, 0);
 317     intf_AssignKey( p_intf , '-', INTF_KEY_DEC_VOLUME, 0);
 318     intf_AssignKey( p_intf , 'm', INTF_KEY_TOGGLE_VOLUME, 0);
 319     intf_AssignKey( p_intf , 'M', INTF_KEY_TOGGLE_VOLUME, 0);
 320     intf_AssignKey( p_intf , 'g', INTF_KEY_DEC_GAMMA, 0);
 321     intf_AssignKey( p_intf , 'G', INTF_KEY_INC_GAMMA, 0);
 322     intf_AssignKey( p_intf , 'c', INTF_KEY_TOGGLE_GRAYSCALE, 0);
 323     intf_AssignKey( p_intf , ' ', INTF_KEY_TOGGLE_INTERFACE, 0);
 324     intf_AssignKey( p_intf , 'i', INTF_KEY_TOGGLE_INFO, 0);
 325     intf_AssignKey( p_intf , 's', INTF_KEY_TOGGLE_SCALING, 0);
 326     intf_AssignKey( p_intf , 'd', INTF_KEY_DUMP_STREAM, 0);
 327 }
 328
 329 /*****************************************************************************
 330  * intf_ProcessKey: process standard keys
 331  *****************************************************************************
 332  * This function will process standard keys and return non 0 if the key was
 333  * unknown.
 334  *****************************************************************************/
 335 int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
 336 {
 337     int i_index;
 338     keyparm k_reply;
 339
 340     k_reply = intf_GetKey( p_intf, g_key);
 341     switch( k_reply.key )
 342     {
 343     case INTF_KEY_QUIT:                                        /* quit order */
 344         p_intf->b_die = 1;
 345         break;
 346
 347     case INTF_KEY_SET_CHANNEL:
 348         /* Change channel - return code is ignored since SelectChannel displays
 349          * its own error messages */
 350 /*        intf_SelectChannel( p_intf, k_reply.param ); */
 351 /*        network_ChannelJoin() */
 352 /* FIXME : keyboard event is for the time being half handled by the interface
 353  * half handled directly by the plugins. We should decide what to do. */
 354         break;
 355
 356     case INTF_KEY_INC_VOLUME:                                    /* volume + */
 357         vlc_mutex_lock( &p_aout_bank->lock );
 358         for( i_index = 0 ; i_index < p_aout_bank->i_count ; i_index++ )
 359         {
 360             if( p_aout_bank->pp_aout[i_index]->i_volume
 361                                                    < VOLUME_MAX - VOLUME_STEP )
 362             {
 363                 p_aout_bank->pp_aout[i_index]->i_volume += VOLUME_STEP;
 364             }
 365             else
 366             {
 367                 p_aout_bank->pp_aout[i_index]->i_volume = VOLUME_MAX;
 368             }
 369         }
 370         vlc_mutex_unlock( &p_aout_bank->lock );
 371         break;
 372
 373     case INTF_KEY_DEC_VOLUME:                                    /* volume - */
 374         vlc_mutex_lock( &p_aout_bank->lock );
 375         for( i_index = 0 ; i_index < p_aout_bank->i_count ; i_index++ )
 376         {
 377             if( p_aout_bank->pp_aout[i_index]->i_volume > VOLUME_STEP )
 378             {
 379                 p_aout_bank->pp_aout[i_index]->i_volume -= VOLUME_STEP;
 380             }
 381             else
 382             {
 383                 p_aout_bank->pp_aout[i_index]->i_volume = 0;
 384             }
 385         }
 386         vlc_mutex_unlock( &p_aout_bank->lock );
 387         break;
 388
 389     case INTF_KEY_TOGGLE_VOLUME:                              /* toggle mute */
 390         vlc_mutex_lock( &p_aout_bank->lock );
 391         for( i_index = 0 ; i_index < p_aout_bank->i_count ; i_index++ )
 392         {
 393             if( p_aout_bank->pp_aout[i_index]->i_savedvolume )
 394             {
 395                 p_aout_bank->pp_aout[i_index]->i_volume =
 396                                 p_aout_bank->pp_aout[i_index]->i_savedvolume;
 397                 p_aout_bank->pp_aout[i_index]->i_savedvolume = 0;
 398             }
 399             else
 400             {
 401                 p_aout_bank->pp_aout[i_index]->i_savedvolume =
 402                                 p_aout_bank->pp_aout[i_index]->i_volume;
 403                 p_aout_bank->pp_aout[i_index]->i_volume = 0;
 404             }
 405         }
 406         vlc_mutex_unlock( &p_aout_bank->lock );
 407         break;
 408
 409 /* XXX: fix this later */
 410 #if 0
 411     case INTF_KEY_DEC_GAMMA:                                      /* gamma - */
 412         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
 413         {
 414             /* FIXME: we should lock if called from the interface */
 415             p_main->p_vout->f_gamma   -= INTF_GAMMA_STEP;
 416             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 417         }
 418         break;
 419     case INTF_KEY_INC_GAMMA:                                      /* gamma + */
 420         if( (p_main->p_vout != NULL) && (p_main->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
 421         {
 422             /* FIXME: we should lock if called from the interface */
 423             p_main->p_vout->f_gamma   += INTF_GAMMA_STEP;
 424             p_main->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 425         }
 426         break;
 427 #endif
 428
 429    case INTF_KEY_DUMP_STREAM:
 430         if( p_intf->p_input != NULL )
 431         {
 432             vlc_mutex_lock( &p_intf->p_input->stream.stream_lock );
 433             input_DumpStream( p_intf->p_input );
 434             vlc_mutex_unlock( &p_intf->p_input->stream.stream_lock );
 435         }
 436         break;
 437
 438     default:                                                  /* unknown key */
 439         return( 1 );
 440     }
 441
 442     return( 0 );
 443 }
 444