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 "plugins.h"
  40 #include "modules.h"
  41 #include "playlist.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_cmd.h"
  51 #include "intf_console.h"
  52 #include "keystrokes.h"
  53
  54 #include "video.h"
  55 #include "video_output.h"
  56
  57 #include "main.h"
  58
  59 /*****************************************************************************
  60  * intf_channel_t: channel description
  61  *****************************************************************************
  62  * A 'channel' is a descriptor of an input method. It is used to switch easily
  63  * from source to source without having to specify the whole input thread
  64  * configuration. The channels array, stored in the interface thread object, is
  65  * loaded in intf_Create, and unloaded in intf_Destroy.
  66  *****************************************************************************/
  67 typedef struct intf_channel_s
  68 {
  69     /* Channel description */
  70     int         i_channel;            /* channel number, -1 for end of array */
  71     char *      psz_description;              /* channel description (owned) */
  72
  73     /* Input configuration */
  74     int         i_input_method;                   /* input method descriptor */
  75     char *      psz_input_source;                   /* source string (owned) */
  76     int         i_input_port;                                        /* port */
  77     int         i_input_vlan_id;                                  /* vlan id */
  78 } intf_channel_t;
  79
  80 /*****************************************************************************
  81  * Local prototypes
  82  *****************************************************************************/
  83 static int      LoadChannels    ( intf_thread_t *p_intf, char *psz_filename );
  84 static void     UnloadChannels  ( intf_thread_t *p_intf );
  85 static int      ParseChannel    ( intf_channel_t *p_channel, char *psz_str );
  86
  87 /*****************************************************************************
  88  * intf_Create: prepare interface before main loop
  89  *****************************************************************************
  90  * This function opens output devices and creates specific interfaces. It sends
  91  * its own error messages.
  92  *****************************************************************************/
  93 intf_thread_t* intf_Create( void )
  94 {
  95     intf_thread_t * p_intf;
  96     typedef void    ( intf_getplugin_t ) ( intf_thread_t * p_intf );
  97     int             i_index;
  98     int             i_best_index = 0, i_best_score = 0;
  99
 100     /* Allocate structure */
 101     p_intf = malloc( sizeof( intf_thread_t ) );
 102     if( !p_intf )
 103     {
 104         intf_ErrMsg( "intf error: cannot create interface thread (%s)",
 105                      strerror( ENOMEM ) );
 106         return( NULL );
 107     }
 108
 109     /* Get a suitable interface plugin */
 110     for( i_index = 0 ; i_index < p_main->p_bank->i_plugin_count ; i_index++ )
 111     {
 112         /* If there's a plugin in p_info ... */
 113         if( p_main->p_bank->p_info[ i_index ] != NULL )
 114         {
 115             /* ... and if this plugin provides the functions we want ... */
 116             if( p_main->p_bank->p_info[ i_index ]->intf_GetPlugin != NULL )
 117             {
 118                 /* ... and if this plugin has a good score ... */
 119                 if( p_main->p_bank->p_info[ i_index ]->i_score > i_best_score )
 120                 {
 121                     /* ... then take it */
 122                     i_best_score = p_main->p_bank->p_info[ i_index ]->i_score;
 123                     i_best_index = i_index;
 124                 }
 125             }
 126         }
 127     }
 128
 129     if( i_best_score == 0 )
 130     {
 131         free( p_intf );
 132         intf_ErrMsg( "intf error: no suitable plugin" );
 133         return( NULL );
 134     }
 135
 136     /* Get the plugin functions */
 137     ( (intf_getplugin_t *)
 138       p_main->p_bank->p_info[ i_best_index ]->intf_GetPlugin )( p_intf );
 139
 140     /* Initialize structure */
 141     p_intf->b_die =     0;
 142     p_intf->p_vout =    NULL;
 143     p_intf->p_input =   NULL;
 144     p_intf->p_keys =    NULL;
 145
 146     /* Warning level initialisation */
 147     p_intf->i_warning_level = main_GetIntVariable( INTF_WARNING_VAR, INTF_WARNING_DEFAULT );
 148
 149     /* Load channels - the pointer will be set to NULL on failure. The
 150      * return value is ignored since the program can work without
 151      * channels */
 152     LoadChannels( p_intf, main_GetPszVariable( INTF_CHANNELS_VAR, INTF_CHANNELS_DEFAULT ));
 153
 154     /* Start interfaces */
 155     p_intf->p_console = intf_ConsoleCreate();
 156     if( p_intf->p_console == NULL )
 157     {
 158         intf_ErrMsg( "intf error: cannot create control console" );
 159         free( p_intf );
 160         return( NULL );
 161     }
 162     if( p_intf->p_sys_create( p_intf ) )
 163     {
 164         intf_ErrMsg("intf error: cannot create interface");
 165         intf_ConsoleDestroy( p_intf->p_console );
 166         free( p_intf );
 167         return( NULL );
 168     }
 169
 170     intf_Msg("Interface initialized");
 171     return( p_intf );
 172 }
 173
 174 /*****************************************************************************
 175  * intf_Run
 176  *****************************************************************************
 177  * Initialization script and main interface loop.
 178  *****************************************************************************/
 179 void intf_Run( intf_thread_t *p_intf )
 180 {
 181     char * psz_server = main_GetPszVariable( INPUT_SERVER_VAR, NULL );
 182     input_config_t *    p_input_config;
 183
 184     /* Flush messages before spawning input */
 185     intf_FlushMsg();
 186
 187     /* If a server was specified */
 188     if( psz_server )
 189     {
 190         if( (p_input_config =
 191               (input_config_t *)malloc( sizeof(input_config_t) )) == NULL )
 192         {
 193             intf_ErrMsg( "intf error: cannot create input_config_t" );
 194         }
 195         else
 196         {
 197             p_input_config->i_method = INPUT_METHOD_UCAST;
 198             p_input_config->p_source = psz_server;
 199             p_input_config->p_default_aout = p_main->p_aout;
 200             p_input_config->p_default_vout = p_intf->p_vout;
 201
 202             p_intf->p_input = input_CreateThread( p_input_config, NULL );
 203         }
 204     }
 205     /* Or if a file was specified */
 206     else if( p_main->p_playlist->p_list != NULL )
 207     {
 208         if( (p_input_config =
 209               (input_config_t *)malloc( sizeof(input_config_t) )) == NULL )
 210         {
 211             intf_ErrMsg( "intf error: cannot create input_config_t" );
 212         }
 213         else
 214         {
 215             p_input_config->i_method = INPUT_METHOD_FILE;
 216             p_input_config->p_source = p_main->p_playlist->p_list[0]; /* FIXME ??? */
 217             p_input_config->p_default_aout = p_main->p_aout;
 218             p_input_config->p_default_vout = p_intf->p_vout;
 219
 220             p_intf->p_input = input_CreateThread( p_input_config, NULL );
 221         }
 222     }
 223     /* Execute the initialization script - if a positive number is returned,
 224      * the script could be executed but failed */
 225     else if( intf_ExecScript( main_GetPszVariable( INTF_INIT_SCRIPT_VAR, INTF_INIT_SCRIPT_DEFAULT ) ) > 0 )
 226     {
 227         intf_ErrMsg( "intf error: errors occured during startup script" );
 228     }
 229
 230     /* Main loop */
 231     while(!p_intf->b_die)
 232     {
 233         /* Flush waiting messages */
 234         intf_FlushMsg();
 235
 236         /* Manage specific interface */
 237         p_intf->p_sys_manage( p_intf );
 238
 239         /* Manage module bank */
 240         module_ManageBank( p_main->p_module_bank );
 241
 242         /* Check attached threads status */
 243         if( (p_intf->p_vout != NULL) && p_intf->p_vout->b_error )
 244         {
 245             /* FIXME: add aout error detection ?? */
 246             p_intf->b_die = 1;
 247         }
 248         if( (p_intf->p_input != NULL) && p_intf->p_input->b_error )
 249         {
 250             input_DestroyThread( p_intf->p_input, NULL );
 251             p_intf->p_input = NULL;
 252             intf_DbgMsg("Input thread destroyed");
 253         }
 254
 255         /* Sleep to avoid using all CPU - since some interfaces needs to access
 256          * keyboard events, a 100ms delay is a good compromise */
 257         msleep( INTF_IDLE_SLEEP );
 258     }
 259 }
 260
 261 /*****************************************************************************
 262  * intf_Destroy: clean interface after main loop
 263  *****************************************************************************
 264  * This function destroys specific interfaces and close output devices.
 265  *****************************************************************************/
 266 void intf_Destroy( intf_thread_t *p_intf )
 267 {
 268     p_intf_key  p_cur;
 269     p_intf_key  p_next;
 270     /* Destroy interfaces */
 271     p_intf->p_sys_destroy( p_intf );
 272     intf_ConsoleDestroy( p_intf->p_console );
 273
 274     /* Unload channels */
 275     UnloadChannels( p_intf );
 276
 277     /* Destroy keymap */
 278     p_cur = p_intf->p_keys;
 279     while( p_cur != NULL)
 280     {
 281         p_next = p_cur->next;
 282         free(p_cur);
 283         p_cur = p_next;
 284     }
 285
 286
 287         /* Free structure */
 288     free( p_intf );
 289 }
 290
 291 /*****************************************************************************
 292  * intf_SelectChannel: change channel
 293  *****************************************************************************
 294  * Kill existing input, if any, and try to open a new one, using an input
 295  * configuration table.
 296  *****************************************************************************/
 297 int intf_SelectChannel( intf_thread_t * p_intf, int i_channel )
 298 {
 299     /* FIXME */
 300 #if 0
 301     intf_channel_t *    p_channel;                                /* channel */
 302
 303     /* Look for channel in array */
 304     if( p_intf->p_channel != NULL )
 305     {
 306         for( p_channel = p_intf->p_channel; p_channel->i_channel != -1; p_channel++ )
 307         {
 308             if( p_channel->i_channel == i_channel )
 309             {
 310             /*
 311              * Change channel
 312              */
 313
 314             /* Kill existing input, if any */
 315             if( p_intf->p_input != NULL )
 316             {
 317                 input_DestroyThread( p_intf->p_input, NULL );
 318             }
 319
 320             intf_Msg("Channel %d: %s", i_channel, p_channel->psz_description );
 321
 322             /* Open a new input */
 323             p_intf->p_input = input_CreateThread( p_channel->i_input_method, p_channel->psz_input_source,
 324                                   p_channel->i_input_port, p_channel->i_input_vlan_id,
 325                                   p_intf->p_vout, p_main->p_aout, NULL );
 326             return( p_intf->p_input == NULL );
 327             }
 328         }
 329     }
 330
 331     /* Channel does not exist */
 332     intf_Msg("Channel %d does not exist", i_channel );
 333 #endif
 334     return( 1 );
 335 }
 336
 337 /*****************************************************************************
 338  * intf_AssignKey: assign standartkeys                                       *
 339  *****************************************************************************
 340  * This function fills in the associative array that links the key pressed   *
 341  * and the key we use internally. Support one extra parameter.               *
 342  ****************************************************************************/
 343 void intf_AssignKey( intf_thread_t *p_intf, int r_key, int f_key, int param)
 344 {
 345     p_intf_key  p_cur =  p_intf->p_keys;
 346     if( p_cur == NULL )
 347     {
 348         p_cur = (p_intf_key )(malloc ( sizeof( intf_key ) ) );
 349         p_cur->received_key = r_key;
 350         p_cur->forwarded.key = f_key;
 351         p_cur->forwarded.param = param;
 352         p_cur->next = NULL;
 353         p_intf->p_keys = p_cur;
 354     }
 355     else
 356     {
 357         while( p_cur->next != NULL && p_cur ->received_key != r_key)
 358         {
 359             p_cur = p_cur->next;
 360         }
 361         if( p_cur->next == NULL )
 362         {
 363             p_cur->next  = ( p_intf_key )( malloc( sizeof( intf_key ) ) );
 364             p_cur = p_cur->next;
 365             p_cur->next = NULL;
 366             p_cur->forwarded.param = param;
 367             p_cur->received_key = r_key;
 368         }
 369         p_cur->forwarded.key = f_key;
 370     }
 371 }
 372
 373 /* Basic getKey function... */
 374 keyparm intf_GetKey( intf_thread_t *p_intf, int r_key)
 375 {
 376     keyparm reply;
 377
 378     p_intf_key current = p_intf->p_keys;
 379     while(current != NULL && current->received_key != r_key)
 380     {
 381         current = current->next;
 382     }
 383     if(current == NULL)
 384     {   /* didn't find any key in the array */
 385         reply.key = INTF_KEY_UNKNOWN;
 386         reply.param = 0;
 387     }
 388     else
 389     {
 390         reply.key = current->forwarded.key;
 391         reply.param = current->forwarded.param;
 392     }
 393     return reply;
 394 }
 395
 396 /*****************************************************************************
 397 * intf_AssignNormalKeys: used for normal interfaces.
 398 *****************************************************************************
 399 * This function assign the basic key to the normal keys.
 400 *****************************************************************************/
 401
 402 void intf_AssignNormalKeys( intf_thread_t *p_intf)
 403 {
 404     p_intf->p_intf_get_key = intf_GetKey;
 405
 406     intf_AssignKey( p_intf , 'Q', INTF_KEY_QUIT, 0);
 407     intf_AssignKey( p_intf , 'q', INTF_KEY_QUIT, 0);
 408     intf_AssignKey( p_intf ,  27, INTF_KEY_QUIT, 0);
 409     intf_AssignKey( p_intf ,   3, INTF_KEY_QUIT, 0);
 410     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 411     intf_AssignKey( p_intf , '1', INTF_KEY_SET_CHANNEL, 1);
 412     intf_AssignKey( p_intf , '2', INTF_KEY_SET_CHANNEL, 2);
 413     intf_AssignKey( p_intf , '3', INTF_KEY_SET_CHANNEL, 3);
 414     intf_AssignKey( p_intf , '4', INTF_KEY_SET_CHANNEL, 4);
 415     intf_AssignKey( p_intf , '5', INTF_KEY_SET_CHANNEL, 5);
 416     intf_AssignKey( p_intf , '6', INTF_KEY_SET_CHANNEL, 6);
 417     intf_AssignKey( p_intf , '7', INTF_KEY_SET_CHANNEL, 7);
 418     intf_AssignKey( p_intf , '8', INTF_KEY_SET_CHANNEL, 8);
 419     intf_AssignKey( p_intf , '9', INTF_KEY_SET_CHANNEL, 9);
 420     intf_AssignKey( p_intf , '0', INTF_KEY_SET_CHANNEL, 0);
 421     intf_AssignKey( p_intf , '+', INTF_KEY_INC_VOLUME, 0);
 422     intf_AssignKey( p_intf , '-', INTF_KEY_DEC_VOLUME, 0);
 423     intf_AssignKey( p_intf , 'm', INTF_KEY_TOGGLE_VOLUME, 0);
 424     intf_AssignKey( p_intf , 'M', INTF_KEY_TOGGLE_VOLUME, 0);
 425     intf_AssignKey( p_intf , 'g', INTF_KEY_DEC_GAMMA, 0);
 426     intf_AssignKey( p_intf , 'G', INTF_KEY_INC_GAMMA, 0);
 427     intf_AssignKey( p_intf , 'c', INTF_KEY_TOGGLE_GRAYSCALE, 0);
 428     intf_AssignKey( p_intf , ' ', INTF_KEY_TOGGLE_INTERFACE, 0);
 429     intf_AssignKey( p_intf , 'i', INTF_KEY_TOGGLE_INFO, 0);
 430     intf_AssignKey( p_intf , 's', INTF_KEY_TOGGLE_SCALING, 0);
 431 }
 432
 433 /*****************************************************************************
 434  * intf_ProcessKey: process standard keys
 435  *****************************************************************************
 436  * This function will process standard keys and return non 0 if the key was
 437  * unknown.
 438  *****************************************************************************/
 439 int intf_ProcessKey( intf_thread_t *p_intf, int g_key )
 440 {
 441     static int i_volbackup;
 442     keyparm k_reply;
 443
 444     k_reply = intf_GetKey( p_intf, g_key);
 445
 446     switch( k_reply.key )
 447     {
 448     case INTF_KEY_QUIT:                                                  /* quit order */
 449         p_intf->b_die = 1;
 450         break;
 451     case INTF_KEY_SET_CHANNEL:
 452         /* Change channel - return code is ignored since SelectChannel displays
 453          * its own error messages */
 454         intf_SelectChannel( p_intf, k_reply.param );
 455         break;
 456     case INTF_KEY_INC_VOLUME:                                                    /* volume + */
 457         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol < VOLUME_MAX) )
 458             p_main->p_aout->vol += VOLUME_STEP;
 459         break;
 460     case INTF_KEY_DEC_VOLUME:                                                    /* volume - */
 461         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol > VOLUME_STEP) )
 462             p_main->p_aout->vol -= VOLUME_STEP;
 463         break;
 464     case INTF_KEY_TOGGLE_VOLUME:                                                 /* toggle mute */
 465         if( (p_main->p_aout != NULL) && (p_main->p_aout->vol))
 466         {
 467             i_volbackup = p_main->p_aout->vol;
 468             p_main->p_aout->vol = 0;
 469         }
 470         else if( (p_main->p_aout != NULL) && (!p_main->p_aout->vol))
 471             p_main->p_aout->vol = i_volbackup;
 472         break;
 473     case INTF_KEY_DEC_GAMMA:                                                     /* gamma - */
 474         if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma > -INTF_GAMMA_LIMIT) )
 475         {
 476             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 477             p_intf->p_vout->f_gamma   -= INTF_GAMMA_STEP;
 478             p_intf->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 479             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 480         }
 481         break;
 482     case INTF_KEY_INC_GAMMA:                                                     /* gamma + */
 483         if( (p_intf->p_vout != NULL) && (p_intf->p_vout->f_gamma < INTF_GAMMA_LIMIT) )
 484         {
 485             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 486             p_intf->p_vout->f_gamma   += INTF_GAMMA_STEP;
 487             p_intf->p_vout->i_changes |= VOUT_GAMMA_CHANGE;
 488             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 489         }
 490         break;
 491     case INTF_KEY_TOGGLE_GRAYSCALE:                                            /* toggle grayscale */
 492         if( p_intf->p_vout != NULL )
 493         {
 494             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 495             p_intf->p_vout->b_grayscale = !p_intf->p_vout->b_grayscale;
 496             p_intf->p_vout->i_changes  |= VOUT_GRAYSCALE_CHANGE;
 497             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 498         }
 499         break;
 500     case INTF_KEY_TOGGLE_INTERFACE:                                            /* toggle interface */
 501         if( p_intf->p_vout != NULL )
 502         {
 503             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 504             p_intf->p_vout->b_interface     = !p_intf->p_vout->b_interface;
 505             p_intf->p_vout->i_changes |= VOUT_INTF_CHANGE;
 506             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 507         }
 508         break;
 509     case INTF_KEY_TOGGLE_INFO:                                                 /* toggle info */
 510         if( p_intf->p_vout != NULL )
 511         {
 512             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 513             p_intf->p_vout->b_info     = !p_intf->p_vout->b_info;
 514             p_intf->p_vout->i_changes |= VOUT_INFO_CHANGE;
 515             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 516         }
 517         break;
 518     case INTF_KEY_TOGGLE_SCALING:                                              /* toggle scaling */
 519         if( p_intf->p_vout != NULL )
 520         {
 521             vlc_mutex_lock( &p_intf->p_vout->change_lock );
 522             p_intf->p_vout->b_scale    = !p_intf->p_vout->b_scale;
 523             p_intf->p_vout->i_changes |= VOUT_SCALE_CHANGE;
 524             vlc_mutex_unlock( &p_intf->p_vout->change_lock );
 525         }
 526         break;
 527    default:                                                   /* unknown key */
 528         return( 1 );
 529     }
 530
 531     return( 0 );
 532 }
 533
 534 /* following functions are local */
 535
 536 /*****************************************************************************
 537  * LoadChannels: load channels description from a file
 538  *****************************************************************************
 539  * This structe describes all interface-specific data of the main (interface)
 540  * thread.
 541  * Each line of the file is a semicolon separated list of the following
 542  * fields :
 543  *      integer         channel number
 544  *      string          channel description
 545  *      integer         input method (see input.h)
 546  *      string          input source
 547  *      integer         input port
 548  *      integer         input vlan id
 549  * The last field must end with a semicolon.
 550  * Comments and empty lines are not explicitely allowed, but lines with parsing
 551  * errors are ignored without warning.
 552  *****************************************************************************/
 553 static int LoadChannels( intf_thread_t *p_intf, char *psz_filename )
 554 {
 555     FILE *              p_file;                                      /* file */
 556     intf_channel_t *    p_channel;                        /* current channel */
 557     char                psz_line[INTF_MAX_CMD_SIZE];          /* line buffer */
 558     int                 i_index;                   /* channel or field index */
 559
 560     /* Set default value */
 561     p_intf->p_channel = NULL;
 562
 563     /* FIXME: channels are disabled */
 564     //return( 0 );
 565
 566     /* Open file */
 567     p_file = fopen( psz_filename, "r" );
 568     if( p_file == NULL )
 569     {
 570         intf_ErrMsg( "intf error: cannot open %s (%s)",
 571                      psz_filename, strerror(errno) );
 572         return( 1 );
 573     }
 574
 575     /* First pass: count number of lines */
 576     for( i_index = 0; fgets( psz_line, INTF_MAX_CMD_SIZE, p_file ) != NULL; i_index++ )
 577     {
 578         ;
 579     }
 580
 581     if( i_index != 0 )
 582     {
 583         /* Allocate array and rewind - some of the lines may be invalid, and the
 584          * array will probably be larger than the actual number of channels, but
 585          * it has no consequence. */
 586         p_intf->p_channel = malloc( sizeof( intf_channel_t ) * i_index );
 587         if( p_intf->p_channel == NULL )
 588         {
 589             intf_ErrMsg( "intf error: cannot create intf_channel_t (%s)",
 590                          strerror(ENOMEM) );
 591             fclose( p_file );
 592             return( 1 );
 593         }
 594         p_channel = p_intf->p_channel;
 595         rewind( p_file );
 596
 597         /* Second pass: read channels descriptions */
 598         while( fgets( psz_line, INTF_MAX_CMD_SIZE, p_file ) != NULL )
 599         {
 600             if( !ParseChannel( p_channel, psz_line ) )
 601             {
 602                 intf_DbgMsg( "channel [%d] %s : method %d (%s:%d vlan id %d)",
 603                          p_channel->i_channel, p_channel->psz_description,
 604                          p_channel->i_input_method,
 605                          p_channel->psz_input_source,
 606                          p_channel->i_input_port, p_channel->i_input_vlan_id );
 607                 p_channel++;
 608             }
 609         }
 610
 611         /* Add marker at the end of the array */
 612         p_channel->i_channel = -1;
 613     }
 614
 615     /* Close file */
 616     fclose( p_file );
 617     return( 0 );
 618 }
 619
 620 /*****************************************************************************
 621  * UnloadChannels: unload channels description
 622  *****************************************************************************
 623  * This function free all resources allocated by LoadChannels, if any.
 624  *****************************************************************************/
 625 static void UnloadChannels( intf_thread_t *p_intf )
 626 {
 627     int i_channel;                                          /* channel index */
 628
 629     if( p_intf->p_channel != NULL )
 630     {
 631         /* Free allocated strings */
 632         for( i_channel = 0;
 633              p_intf->p_channel[ i_channel ].i_channel != -1;
 634              i_channel++ )
 635         {
 636             if( p_intf->p_channel[ i_channel ].psz_description != NULL )
 637             {
 638                 free( p_intf->p_channel[ i_channel ].psz_description );
 639             }
 640             if( p_intf->p_channel[ i_channel ].psz_input_source != NULL )
 641             {
 642                 free( p_intf->p_channel[ i_channel ].psz_input_source );
 643             }
 644         }
 645
 646         /* Free array */
 647         free( p_intf->p_channel );
 648         p_intf->p_channel = NULL;
 649     }
 650 }
 651
 652
 653 /*****************************************************************************
 654  * ParseChannel: parse a channel description line
 655  *****************************************************************************
 656  * See LoadChannels. This function return non 0 on parsing error.
 657  *****************************************************************************/
 658 static int ParseChannel( intf_channel_t *p_channel, char *psz_str )
 659 {
 660     char *      psz_index;                              /* current character */
 661     char *      psz_end;                           /* end pointer for strtol */
 662     int         i_field;                        /* field number, -1 on error */
 663     int         i_field_length;             /* field length, for text fields */
 664
 665     /* Set some default fields */
 666     p_channel->i_channel =              0;
 667     p_channel->psz_description =        NULL;
 668     p_channel->i_input_method =         0;
 669     p_channel->psz_input_source =       NULL;
 670     p_channel->i_input_port =           0;
 671     p_channel->i_input_vlan_id =        0;
 672
 673     /* Parse string */
 674     i_field = 0;
 675     for( psz_index = psz_str; (i_field != -1) && (*psz_index != '\0'); psz_index++ )
 676     {
 677         if( *psz_index == ';' )
 678         {
 679             /* Mark end of field */
 680             *psz_index = '\0';
 681
 682             /* Parse field */
 683             switch( i_field++ )
 684             {
 685             case 0:                                        /* channel number */
 686                 p_channel->i_channel = strtol( psz_str, &psz_end, 0);
 687                 if( (*psz_str == '\0') || (*psz_end != '\0') )
 688                 {
 689                     i_field = -1;
 690                 }
 691                 break;
 692             case 1:                                   /* channel description */
 693                 i_field_length = strlen( psz_str );
 694                 if( i_field_length != 0 )
 695                 {
 696                     p_channel->psz_description = malloc( i_field_length + 1 );
 697                     if( p_channel->psz_description == NULL )
 698                     {
 699                         intf_ErrMsg( "intf error: cannot create channel "
 700                                      "description (%s)", strerror( ENOMEM ) );
 701                         i_field = -1;
 702                     }
 703                     else
 704                     {
 705                         strcpy( p_channel->psz_description, psz_str );
 706                     }
 707                 }
 708                 break;
 709             case 2:                                          /* input method */
 710                 p_channel->i_input_method = strtol( psz_str, &psz_end, 0);
 711                 if( (*psz_str == '\0') || (*psz_end != '\0') )
 712                 {
 713                     i_field = -1;
 714                 }
 715                 break;
 716             case 3:                                          /* input source */
 717                 i_field_length = strlen( psz_str );
 718                 if( i_field_length != 0 )
 719                 {
 720                     p_channel->psz_input_source = malloc( i_field_length + 1 );
 721                     if( p_channel->psz_input_source == NULL )
 722                     {
 723                         intf_ErrMsg( "intf error: cannot create input "
 724                                      "source (%s)", strerror( ENOMEM ) );
 725                         i_field = -1;
 726                     }
 727                     else
 728                     {
 729                         strcpy( p_channel->psz_input_source, psz_str );
 730                     }
 731                 }
 732                 break;
 733             case 4:                                            /* input port */
 734                 p_channel->i_input_port = strtol( psz_str, &psz_end, 0);
 735                 if( (*psz_str == '\0') || (*psz_end != '\0') )
 736                 {
 737                     i_field = -1;
 738                 }
 739                 break;
 740             case 5:                                          /* input vlan id */
 741                 p_channel->i_input_vlan_id = strtol( psz_str, &psz_end, 0);
 742                 if( (*psz_str == '\0') || (*psz_end != '\0') )
 743                 {
 744                     i_field = -1;
 745                 }
 746                 break;
 747                 /* ... following fields are ignored */
 748             }
 749
 750             /* Set new beginning of field */
 751             psz_str = psz_index + 1;
 752         }
 753     }
 754
 755     /* At least the first three fields must be parsed sucessfully for function
 756      * success. Other parsing errors are returned using i_field = -1. */
 757     if( i_field < 3 )
 758     {
 759         /* Function fails. Free allocated strings */
 760         if( p_channel->psz_description != NULL )
 761         {
 762             free( p_channel->psz_description );
 763         }
 764         if( p_channel->psz_input_source != NULL )
 765         {
 766             free( p_channel->psz_input_source );
 767         }
 768         return( 1 );
 769     }
 770
 771     /* Return success */
 772     return( 0 );
 773 }