开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
rtci.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：38k
源码类别：

多媒体

开发平台：

MultiPlatform

rtci.c：源码内容
  1. /*****************************************************************************
  2.  * rtci.c : real time control interface stdin/stdout module for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2004 VideoLAN
  5.  * $Id: rc.c 8847 2004-09-29 11:36:37Z markfm $
  6.  *
  7.  * Author: Peter Surda <shurdeek@panorama.sth.ac.at>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. /****************************************************************************** 
  25.  *  Module purpose -- provide a socket based interface to control various 
  26.  *  VLC parameters and obtain status information on the fly.  Output 
  27.  *  will be purposely less verbose than on some interfaces -- this 
  28.  *  interface is intended more for comms with an external program than a human
  29.  *****************************************************************************/
  30.  
  31. /*****************************************************************************
  32.  * Preamble
  33.  *****************************************************************************/
  34. #include <stdlib.h>                                      /* malloc(), free() */
  35. #include <string.h>
  37. #include <errno.h>                                                 /* ENOMEM */
  38. #include <stdio.h>
  39. #include <ctype.h>
  40. #include <signal.h>
  42. #include <vlc/vlc.h>
  43. #include <vlc/intf.h>
  44. #include <vlc/aout.h>
  45. #include <vlc/vout.h>
  47. #ifdef HAVE_UNISTD_H
  48. #    include <unistd.h>
  49. #endif
  51. #ifdef HAVE_SYS_TIME_H
  52. #    include <sys/time.h>
  53. #endif
  54. #include <sys/types.h>
  56. #include "vlc_error.h"
  57. #include "network.h"
  59. #if defined(PF_UNIX) && !defined(PF_LOCAL)
  60. #    define PF_LOCAL PF_UNIX
  61. #endif
  62. #if defined(AF_UNIX) && !defined(AF_LOCAL)
  63. #    define AF_LOCAL AF_UNIX
  64. #endif
  66. #ifdef PF_LOCAL
  67. #    include <sys/un.h>
  68. #endif
  70. #define MAX_LINE_LENGTH 256
  72. /*****************************************************************************
  73.  * Local prototypes
  74.  *****************************************************************************/
  75. static int  Activate     ( vlc_object_t * );
  76. static void Deactivate   ( vlc_object_t * );
  77. static void Run          ( intf_thread_t * );
  79. static vlc_bool_t ReadCommand( intf_thread_t *, char *, int * );
  81. static int  Input        ( vlc_object_t *, char const *,
  82.                            vlc_value_t, vlc_value_t, void * );
  83. static int  Playlist     ( vlc_object_t *, char const *,
  84.                            vlc_value_t, vlc_value_t, void * );
  85. static int  Other        ( vlc_object_t *, char const *,
  86.                            vlc_value_t, vlc_value_t, void * );
  87. static int  Quit         ( vlc_object_t *, char const *,
  88.                            vlc_value_t, vlc_value_t, void * );
  89. static int  Intf         ( vlc_object_t *, char const *,
  90.                            vlc_value_t, vlc_value_t, void * );
  91. static int  Volume       ( vlc_object_t *, char const *,
  92.                            vlc_value_t, vlc_value_t, void * );
  93. static int  VolumeMove   ( vlc_object_t *, char const *,
  94.                            vlc_value_t, vlc_value_t, void * );
  95. static int  AudioConfig  ( vlc_object_t *, char const *,
  96.                            vlc_value_t, vlc_value_t, void * );
  98. struct intf_sys_t
  99. {
  100.     int i_socket_listen;
  101.     int i_socket;
  102.     char *psz_unix_path;
  103.     vlc_bool_t b_extend;
  104.     
  105. #ifdef WIN32
  106.     HANDLE hConsoleIn;
  107. #endif
  108. };
  110. #ifdef HAVE_VARIADIC_MACROS
  111. #   define msg_rtci( psz_format, args... ) 
  112.       __msg_rtci( p_intf, psz_format, ## args )
  113. #endif
  115. static void __msg_rtci( intf_thread_t *p_intf, const char *psz_fmt, ... )
  116. {
  117.     va_list args;
  118.     va_start( args, psz_fmt );
  119.     if( p_intf->p_sys->i_socket == -1 ) vprintf( psz_fmt, args );
  120.     else net_vaPrintf( p_intf, p_intf->p_sys->i_socket, psz_fmt, args );
  121.     va_end( args );
  122. }
  124. /*****************************************************************************
  125.  * Module descriptor
  126.  *****************************************************************************/
  127. #define POS_TEXT N_("Show stream position")
  128. #define POS_LONGTEXT N_("Show the current position in seconds within the " 
  129.                         "stream from time to time." )
  131. #define TTY_TEXT N_("Fake TTY")
  132. #define TTY_LONGTEXT N_("Force the rtci module to use stdin as if it was a TTY.")
  134. #define UNIX_TEXT N_("UNIX socket command input")
  135. #define UNIX_LONGTEXT N_("Accept commands over a Unix socket rather than " 
  136.                          "stdin." )
  138. #define HOST_TEXT N_("TCP command input")
  139. #define HOST_LONGTEXT N_("Accept commands over a socket rather than stdin. " 
  140.             "You can set the address and port the interface will bind to." )
  141. #define EXTEND_TEXT N_("Extended help")
  142. #define EXTEND_LONGTEXT N_("List additional commands.")
  143.             
  145. #ifdef WIN32
  146. #define QUIET_TEXT N_("Do not open a DOS command box interface")
  147. #define QUIET_LONGTEXT N_( 
  148.     "By default the rtci interface plugin will start a DOS command box. " 
  149.     "Enabling the quiet mode will not launch this command box." )
  150. #endif
  152. vlc_module_begin();
  153.     set_description( _("Real time control interface") );
  154.     add_bool( "rtci-show-pos", 0, NULL, POS_TEXT, POS_LONGTEXT, VLC_TRUE );
  155. #ifdef HAVE_ISATTY
  156.     add_bool( "rtci-fake-tty", 0, NULL, TTY_TEXT, TTY_LONGTEXT, VLC_TRUE );
  157. #endif
  158.     add_string( "rtci-unix", 0, NULL, UNIX_TEXT, UNIX_LONGTEXT, VLC_TRUE );
  159.     add_string( "rtci-host", 0, NULL, HOST_TEXT, HOST_LONGTEXT, VLC_TRUE );
  161. #ifdef WIN32
  162.     add_bool( "rtci-quiet", 0, NULL, QUIET_TEXT, QUIET_LONGTEXT, VLC_FALSE );
  163. #endif
  164.     add_bool( "rtci-extend", 0, NULL, EXTEND_TEXT, EXTEND_LONGTEXT, VLC_FALSE );
  166.     set_capability( "interface", 20 );
  167.     set_callbacks( Activate, Deactivate );
  168. vlc_module_end();
  170. /*****************************************************************************
  171.  * Activate: initialize and create stuff
  172.  *****************************************************************************/
  173. static int Activate( vlc_object_t *p_this )
  174. {
  175.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  176.     char *psz_host, *psz_unix_path;
  177.     int i_socket = -1;
  179. #if defined(HAVE_ISATTY) && !defined(WIN32)
  180.     /* Check that stdin is a TTY */
  181.     if( !config_GetInt( p_intf, "rtci-fake-tty" ) && !isatty( 0 ) )
  182.     {
  183.         msg_Warn( p_intf, "fd 0 is not a TTY" );
  184.         return VLC_EGENERIC;
  185.     }
  186. #endif
  188.     psz_unix_path = config_GetPsz( p_intf, "rtci-unix" );
  189.     if( psz_unix_path )
  190.     {
  191. #ifndef PF_LOCAL
  192.         msg_Warn( p_intf, "your OS doesn't support filesystem sockets" );
  193.         free( psz_unix_path );
  194.         return VLC_EGENERIC;
  195. #else
  196.         struct sockaddr_un addr;
  197.         int i_ret;
  199.         memset( &addr, 0, sizeof(struct sockaddr_un) );
  201.         msg_Dbg( p_intf, "trying UNIX socket" );
  203.         if( (i_socket = socket( PF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
  204.         {
  205.             msg_Warn( p_intf, "can't open socket: %s", strerror(errno) );
  206.             free( psz_unix_path );
  207.             return VLC_EGENERIC;
  208.         }
  210.         addr.sun_family = AF_LOCAL;
  211.         strncpy( addr.sun_path, psz_unix_path, sizeof( addr.sun_path ) );
  212.         addr.sun_path[sizeof( addr.sun_path ) - 1] = '';
  214.         if( (i_ret = bind( i_socket, (struct sockaddr*)&addr,
  215.                            sizeof(struct sockaddr_un) ) ) < 0 )
  216.         {
  217.             msg_Warn( p_intf, "couldn't bind socket to address: %s",
  218.                       strerror(errno) );
  219.             free( psz_unix_path );
  220.             net_Close( i_socket );
  221.             return VLC_EGENERIC;
  222.         }
  224.         if( ( i_ret = listen( i_socket, 1 ) ) < 0 )
  225.         {
  226.             msg_Warn( p_intf, "can't listen on socket: %s", strerror(errno));
  227.             free( psz_unix_path );
  228.             net_Close( i_socket );
  229.             return VLC_EGENERIC;
  230.         }
  231. #endif
  232.     }
  234.     if( ( i_socket == -1) &&
  235.         ( psz_host = config_GetPsz( p_intf, "rtci-host" ) ) != NULL )
  236.     {
  237.         vlc_url_t url;
  239.         vlc_UrlParse( &url, psz_host, 0 );
  241.         msg_Dbg( p_intf, "base %s port %d", url.psz_host, url.i_port );
  243.         if( (i_socket = net_ListenTCP(p_this, url.psz_host, url.i_port)) == -1)
  244.         {
  245.             msg_Warn( p_intf, "can't listen to %s port %i",
  246.                       url.psz_host, url.i_port );
  247.             vlc_UrlClean( &url );
  248.             free( psz_host );
  249.             return VLC_EGENERIC;
  250.         }
  252.         vlc_UrlClean( &url );
  253.         free( psz_host );
  254.     }
  256.     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
  257.     if( !p_intf->p_sys )
  258.     {
  259.         msg_Err( p_intf, "no memory" );
  260.         return VLC_ENOMEM;
  261.     }
  263.     p_intf->p_sys->i_socket_listen = i_socket;
  264.     p_intf->p_sys->i_socket = -1;
  265.     p_intf->p_sys->psz_unix_path = psz_unix_path;
  267.     /* Non-buffered stdout */
  268.     setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
  270.     p_intf->pf_run = Run;
  272. #ifdef WIN32
  273.     if( !config_GetInt( p_intf, "rtci-quiet" ) ) { CONSOLE_INTRO_MSG; }
  274. #else
  275.     CONSOLE_INTRO_MSG;
  276. #endif
  278.     msg_rtci( _("Real time control interface initialized, `h' for helpn") );
  279.     return VLC_SUCCESS;
  280. }
  282. /*****************************************************************************
  283.  * Deactivate: uninitialize and cleanup
  284.  *****************************************************************************/
  285. static void Deactivate( vlc_object_t *p_this )
  286. {
  287.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  289.     if( p_intf->p_sys->i_socket_listen != -1 )
  290.         net_Close( p_intf->p_sys->i_socket_listen );
  291.     if( p_intf->p_sys->i_socket != -1 )
  292.         net_Close( p_intf->p_sys->i_socket );
  293.     if( p_intf->p_sys->psz_unix_path != NULL )
  294.     {
  295. #ifdef PF_LOCAL
  296.         unlink( p_intf->p_sys->psz_unix_path );
  297. #endif
  298.         free( p_intf->p_sys->psz_unix_path );
  299.     }
  300.     free( p_intf->p_sys );
  301. }
  303. /*****************************************************************************
  304.  * Run: rtci thread
  305.  *****************************************************************************
  306.  * This part of the interface is in a separate thread so that we can call
  307.  * exec() from within it without annoying the rest of the program.
  308.  *****************************************************************************/
  309. static void Run( intf_thread_t *p_intf )
  310. {
  311.     input_thread_t * p_input;
  312.     playlist_t *     p_playlist;
  314.     char       p_buffer[ MAX_LINE_LENGTH + 1 ];
  315.     vlc_bool_t b_showpos = config_GetInt( p_intf, "rtci-show-pos" );
  317.     int        i_size = 0;
  318.     int        i_oldpos = 0;
  319.     int        i_newpos;
  321.     p_buffer[0] = 0;
  322.     p_input = NULL;
  323.     p_playlist = NULL;
  324.  
  325.     p_intf->p_sys->b_extend = config_GetInt( p_intf, "rtci-extend" );
  326.     /* Register commands that will be cleaned up upon object destruction */
  327.     var_Create( p_intf, "quit", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  328.     var_AddCallback( p_intf, "quit", Quit, NULL );
  329.     var_Create( p_intf, "intf", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  330.     var_AddCallback( p_intf, "intf", Intf, NULL );
  332.     var_Create( p_intf, "add", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  333.     var_AddCallback( p_intf, "add", Playlist, NULL );
  334.     var_Create( p_intf, "playlist", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  335.     var_AddCallback( p_intf, "playlist", Playlist, NULL );
  336.     var_Create( p_intf, "play", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  337.     var_AddCallback( p_intf, "play", Playlist, NULL );
  338.     var_Create( p_intf, "stop", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  339.     var_AddCallback( p_intf, "stop", Playlist, NULL );
  340.     var_Create( p_intf, "prev", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  341.     var_AddCallback( p_intf, "prev", Playlist, NULL );
  342.     var_Create( p_intf, "next", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  343.     var_AddCallback( p_intf, "next", Playlist, NULL );
  344.   
  345.     var_Create( p_intf, "marq-marquee", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  346.     var_AddCallback( p_intf, "marq-marquee", Other, NULL );
  347.     var_Create( p_intf, "marq-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
  348.     var_AddCallback( p_intf, "marq-x", Other, NULL );
  349.     var_Create( p_intf, "marq-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
  350.     var_AddCallback( p_intf, "marq-y", Other, NULL );
  351.     var_Create( p_intf, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
  352.     var_AddCallback( p_intf, "marq-timeout", Other, NULL );
  354.     var_Create( p_intf, "pause", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  355.     var_AddCallback( p_intf, "pause", Input, NULL );
  356.     var_Create( p_intf, "seek", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
  357.     var_AddCallback( p_intf, "seek", Input, NULL );
  358.     var_Create( p_intf, "title", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  359.     var_AddCallback( p_intf, "title", Input, NULL );
  360.     var_Create( p_intf, "title_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  361.     var_AddCallback( p_intf, "title_n", Input, NULL );
  362.     var_Create( p_intf, "title_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  363.     var_AddCallback( p_intf, "title_p", Input, NULL );
  364.     var_Create( p_intf, "chapter", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  365.     var_AddCallback( p_intf, "chapter", Input, NULL );
  366.     var_Create( p_intf, "chapter_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  367.     var_AddCallback( p_intf, "chapter_n", Input, NULL );
  368.     var_Create( p_intf, "chapter_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  369.     var_AddCallback( p_intf, "chapter_p", Input, NULL );
  371.     var_Create( p_intf, "volume", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  372.     var_AddCallback( p_intf, "volume", Volume, NULL );
  373.     var_Create( p_intf, "volup", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  374.     var_AddCallback( p_intf, "volup", VolumeMove, NULL );
  375.     var_Create( p_intf, "voldown", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  376.     var_AddCallback( p_intf, "voldown", VolumeMove, NULL );
  377.     var_Create( p_intf, "adev", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  378.     var_AddCallback( p_intf, "adev", AudioConfig, NULL );
  379.     var_Create( p_intf, "achan", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  380.     var_AddCallback( p_intf, "achan", AudioConfig, NULL );
  382. #ifdef WIN32
  383.     /* Get the file descriptor of the console input */
  384.     p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
  385.     if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE )
  386.     {
  387.         msg_Err( p_intf, "Couldn't open STD_INPUT_HANDLE" );
  388.         p_intf->b_die = VLC_TRUE;
  389.     }
  390. #endif
  392.     while( !p_intf->b_die )
  393.     {
  394.         char *psz_cmd, *psz_arg;
  395.         vlc_bool_t b_complete;
  397.         if( p_intf->p_sys->i_socket_listen != - 1 &&
  398.             p_intf->p_sys->i_socket == -1 )
  399.         {
  400.             p_intf->p_sys->i_socket =
  401.                 net_Accept( p_intf, p_intf->p_sys->i_socket_listen, 0 );
  402.         }
  404.         b_complete = ReadCommand( p_intf, p_buffer, &i_size );
  406.         /* Manage the input part */
  407.         if( p_input == NULL )
  408.         {
  409.             if( p_playlist )
  410.             {
  411.                 p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT,
  412.                                                        FIND_CHILD );
  413.             }
  414.             else
  415.             {
  416.                 p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
  417.                                                    FIND_ANYWHERE );
  418.                 if( p_input )
  419.                 {
  420.                     p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
  421.                                                            FIND_PARENT );
  422.                 }
  423.             }
  424.         }
  425.         else if( p_input->b_dead )
  426.         {
  427.             vlc_object_release( p_input );
  428.             p_input = NULL;
  429.         }
  431.         if( p_input && b_showpos )
  432.         {
  433.             i_newpos = 100 * var_GetFloat( p_input, "position" );
  434.             if( i_oldpos != i_newpos )
  435.             {
  436.                 i_oldpos = i_newpos;
  437.                 msg_rtci( "pos: %d%%n", i_newpos );
  438.             }
  439.         }
  441.         /* Is there something to do? */
  442.         if( !b_complete ) continue;
  445.         /* Skip heading spaces */
  446.         psz_cmd = p_buffer;
  447.         while( *psz_cmd == ' ' )
  448.         {
  449.             psz_cmd++;
  450.         }
  452.         /* Split psz_cmd at the first space and make sure that
  453.          * psz_arg is valid */
  454.         psz_arg = strchr( psz_cmd, ' ' );
  455.         if( psz_arg )
  456.         {
  457.             *psz_arg++ = 0;
  458.             while( *psz_arg == ' ' )
  459.             {
  460.                 psz_arg++;
  461.             }
  462.         }
  463.         else
  464.         {
  465.             psz_arg = "";
  466.         }
  468.         /* If the user typed a registered local command, try it */
  469.         if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND )
  470.         {
  471.             vlc_value_t val;
  472.             int i_ret;
  474.             val.psz_string = psz_arg;
  475.             i_ret = var_Set( p_intf, psz_cmd, val );
  476.             msg_rtci( "%s: returned %i (%s)n",
  477.                     psz_cmd, i_ret, vlc_error( i_ret ) );
  478.         }
  479.         /* Or maybe it's a global command */
  480.         else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND )
  481.         {
  482.             vlc_value_t val;
  483.             int i_ret;
  485.             val.psz_string = psz_arg;
  486.             /* FIXME: it's a global command, but we should pass the
  487.              * local object as an argument, not p_intf->p_libvlc. */
  488.             i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val );
  489.             if( i_ret != 0 )
  490.             {
  491.                 msg_rtci( "%s: returned %i (%s)n",
  492.                          psz_cmd, i_ret, vlc_error( i_ret ) );
  493.             }
  494.         }
  495.         else if( !strcmp( psz_cmd, "logout" ) )
  496.         {
  497.             /* Close connection */
  498.             if( p_intf->p_sys->i_socket != -1 )
  499.             {
  500.                 net_Close( p_intf->p_sys->i_socket );
  501.             }
  502.             p_intf->p_sys->i_socket = -1;
  503.         }
  504.         else if( !strcmp( psz_cmd, "info" ) )
  505.         {
  506.             if( p_input )
  507.             {
  508.                 int i, j;
  509.                 vlc_mutex_lock( &p_input->input.p_item->lock );
  510.                 for ( i = 0; i < p_input->input.p_item->i_categories; i++ )
  511.                 {
  512.                     info_category_t *p_category =
  513.                         p_input->input.p_item->pp_categories[i];
  515.                     msg_rtci( "+----[ %s ]n", p_category->psz_name );
  516.                     msg_rtci( "| n" );
  517.                     for ( j = 0; j < p_category->i_infos; j++ )
  518.                     {
  519.                         info_t *p_info = p_category->pp_infos[j];
  520.                         msg_rtci( "| %s: %sn", p_info->psz_name,
  521.                                 p_info->psz_value );
  522.                     }
  523.                     msg_rtci( "| n" );
  524.                 }
  525.                 msg_rtci( "+----[ end of stream info ]n" );
  526.                 vlc_mutex_unlock( &p_input->input.p_item->lock );
  527.             }
  528.             else
  529.             {
  530.                 msg_rtci( "no inputn" );
  531.             }
  532.         }
  533.         else if( !strcmp( psz_cmd, "is_playing" ) )
  534.         {
  535.             if( ! p_input )
  536.             {
  537.                 msg_rtci( "0n" );
  538.             }
  539.             else
  540.             {
  541.                 msg_rtci( "1n" );
  542.             }
  543.         }
  544.         else if( !strcmp( psz_cmd, "get_time" ) )
  545.         {
  546.             if( ! p_input )
  547.             {
  548.                 msg_rtci("0n");
  549.             }
  550.             else
  551.             {
  552.                 vlc_value_t time;
  553.                 var_Get( p_input, "time", &time );
  554.                 msg_rtci( "%in", time.i_time / 1000000);
  555.             }
  556.         }
  557.         else if( !strcmp( psz_cmd, "get_length" ) )
  558.         {
  559.             if( ! p_input )
  560.             {
  561.                 msg_rtci("0n");
  562.             }
  563.             else
  564.             {
  565.                 vlc_value_t time;
  566.                 var_Get( p_input, "length", &time );
  567.                 msg_rtci( "%in", time.i_time / 1000000);
  568.             }
  569.         }
  570.         else if( !strcmp( psz_cmd, "get_title" ) )
  571.         {
  572.             if( ! p_input )
  573.             {
  574.                 msg_rtci("n");
  575.             }
  576.             else
  577.             {
  578.                 msg_rtci( "%sn", p_input->input.p_item->psz_name );
  579.             }
  580.         }
  581.         else switch( psz_cmd[0] )
  582.         {
  583.         case 'f':
  584.         case 'F':
  585.             if( p_input )
  586.             {
  587.                 vout_thread_t *p_vout;
  588.                 p_vout = vlc_object_find( p_input,
  589.                                           VLC_OBJECT_VOUT, FIND_CHILD );
  591.                 if( p_vout )
  592.                 {
  593.                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
  594.                     vlc_object_release( p_vout );
  595.                 }
  596.             }
  597.             break;
  599.         case 's':
  600.         case 'S':
  601.             ;
  602.             break;
  604.         case '?':
  605.         case 'h':
  606.         case 'H':
  607.             msg_rtci(_("+----[ Remote control commands ]n"));
  608.             msg_rtci("| n");
  609.             msg_rtci(_("| add XYZ  . . . . . . . . . . add XYZ to playlistn"));
  610.             msg_rtci(_("| playlist . . .  show items currently in playlistn"));
  611.             msg_rtci(_("| play . . . . . . . . . . . . . . . . play streamn"));
  612.             msg_rtci(_("| stop . . . . . . . . . . . . . . . . stop streamn"));
  613.             msg_rtci(_("| next . . . . . . . . . . . .  next playlist itemn"));
  614.             msg_rtci(_("| prev . . . . . . . . . .  previous playlist itemn"));
  615.             msg_rtci(_("| title [X]  . . . . set/get title in current itemn"));
  616.             msg_rtci(_("| title_n  . . . . . .  next title in current itemn"));
  617.             msg_rtci(_("| title_p  . . . .  previous title in current itemn"));
  618.             msg_rtci(_("| chapter [X]  . . set/get chapter in current itemn"));
  619.             msg_rtci(_("| chapter_n  . . . .  next chapter in current itemn"));
  620.             msg_rtci(_("| chapter_p  . .  previous chapter in current itemn"));
  621.             msg_rtci("| n");
  622.             msg_rtci(_("| seek X . seek in seconds, for instance `seek 12'n"));
  623.             msg_rtci(_("| pause  . . . . . . . . . . . . . .  toggle pausen"));
  624.             msg_rtci(_("| f  . . . . . . . . . . . . . . toggle fullscreenn"));
  625.             msg_rtci(_("| info . . .  information about the current streamn"));
  626.             msg_rtci("| n");
  627.             msg_rtci(_("| volume [X] . . . . . . . .  set/get audio volumen"));
  628.             msg_rtci(_("| volup [X]  . . . . .  raise audio volume X stepsn"));
  629.             msg_rtci(_("| voldown [X]  . . . .  lower audio volume X stepsn"));
  630.             msg_rtci(_("| adev [X] . . . . . . . . .  set/get audio devicen"));
  631.             msg_rtci(_("| achan [X]. . . . . . . .  set/get audio channelsn"));
  632.             msg_rtci("| n");
  633.             if (p_intf->p_sys->b_extend)
  634.             {
  635.            msg_rtci(_("| marq-marquee STRING  . . overlay STRING in videon"));
  636.                msg_rtci(_("| marq-x X . . . . . .offset of marquee, from leftn"));
  637.                msg_rtci(_("| marq-y Y . . . . . . offset of marquee, from topn"));
  638.                msg_rtci(_("| marq-timeout T. . . . .timeout of marquee, in msn"));
  639.                msg_rtci("| n");
  640.             }    
  641.             msg_rtci(_("| help . . . . . . . . . . . . . this help messagen"));
  642.             msg_rtci(_("| logout . . . . . .exit (if in socket connection)n"));
  643.             msg_rtci(_("| quit . . . . . . . . . . . . . . . . .  quit vlcn"));
  644.             msg_rtci("| n");
  645.             msg_rtci(_("+----[ end of help ]n"));
  646.             break;
  648.         case '':
  649.             /* Ignore empty lines */
  650.             break;
  652.         default:
  653.             msg_rtci(_("unknown command `%s', type `help' for helpn"), psz_cmd);
  654.             break;
  655.         }
  657.         /* Command processed */
  658.         i_size = 0; p_buffer[0] = 0;
  659.     }
  661.     if( p_input )
  662.     {
  663.         vlc_object_release( p_input );
  664.         p_input = NULL;
  665.     }
  667.     if( p_playlist )
  668.     {
  669.         vlc_object_release( p_playlist );
  670.         p_playlist = NULL;
  671.     }
  672. }
  674. static int Input( vlc_object_t *p_this, char const *psz_cmd,
  675.                   vlc_value_t oldval, vlc_value_t newval, void *p_data )
  676. {
  677.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  678.     input_thread_t *p_input;
  679.     vlc_value_t     val;
  681.     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
  682.     if( !p_input ) return VLC_ENOOBJ;
  684.     /* Parse commands that only require an input */
  685.     if( !strcmp( psz_cmd, "pause" ) )
  686.     {
  687.         val.i_int = PAUSE_S;
  689.         var_Set( p_input, "state", val );
  690.         vlc_object_release( p_input );
  691.         return VLC_SUCCESS;
  692.     }
  693.     else if( !strcmp( psz_cmd, "seek" ) )
  694.     {
  695.         if( strlen( newval.psz_string ) > 0 &&
  696.             newval.psz_string[strlen( newval.psz_string ) - 1] == '%' )
  697.         {
  698.             val.f_float = (float)atoi( newval.psz_string ) / 100.0;
  699.             var_Set( p_input, "position", val );
  700.         }
  701.         else
  702.         {
  703.             val.i_time = ((int64_t)atoi( newval.psz_string )) * 1000000;
  704.             var_Set( p_input, "time", val );
  705.         }
  706.         vlc_object_release( p_input );
  707.         return VLC_SUCCESS;
  708.     }
  709.    
  710.     else if( !strcmp( psz_cmd, "chapter" ) ||
  711.              !strcmp( psz_cmd, "chapter_n" ) ||
  712.              !strcmp( psz_cmd, "chapter_p" ) )
  713.     {
  714.         if( !strcmp( psz_cmd, "chapter" ) )
  715.         {
  716.             if ( *newval.psz_string )
  717.             {
  718.                 /* Set. */
  719.                 val.i_int = atoi( newval.psz_string );
  720.                 var_Set( p_input, "chapter", val );
  721.             }
  722.             else
  723.             {
  724.                 vlc_value_t val_list;
  726.                 /* Get. */
  727.                 var_Get( p_input, "chapter", &val );
  728.                 var_Change( p_input, "chapter", VLC_VAR_GETCHOICES,
  729.                             &val_list, NULL );
  730.                 msg_rtci( "Currently playing chapter %d/%dn",
  731.                         val.i_int, val_list.p_list->i_count );
  732.                 var_Change( p_this, "chapter", VLC_VAR_FREELIST,
  733.                             &val_list, NULL );
  734.             }
  735.         }
  736.         else if( !strcmp( psz_cmd, "chapter_n" ) )
  737.         {
  738.             val.b_bool = VLC_TRUE;
  739.             var_Set( p_input, "next-chapter", val );
  740.         }
  741.         else if( !strcmp( psz_cmd, "chapter_p" ) )
  742.         {
  743.             val.b_bool = VLC_TRUE;
  744.             var_Set( p_input, "prev-chapter", val );
  745.         }
  747.         vlc_object_release( p_input );
  748.         return VLC_SUCCESS;
  749.     }
  750.     else if( !strcmp( psz_cmd, "title" ) ||
  751.              !strcmp( psz_cmd, "title_n" ) ||
  752.              !strcmp( psz_cmd, "title_p" ) )
  753.     {
  754.         if( !strcmp( psz_cmd, "title" ) )
  755.         {
  756.             if ( *newval.psz_string )
  757.             {
  758.                 /* Set. */
  759.                 val.i_int = atoi( newval.psz_string );
  760.                 var_Set( p_input, "title", val );
  761.             }
  762.             else
  763.             {
  764.                 vlc_value_t val_list;
  766.                 /* Get. */
  767.                 var_Get( p_input, "title", &val );
  768.                 var_Change( p_input, "title", VLC_VAR_GETCHOICES,
  769.                             &val_list, NULL );
  770.                 msg_rtci( "Currently playing title %d/%dn",
  771.                         val.i_int, val_list.p_list->i_count );
  772.                 var_Change( p_this, "title", VLC_VAR_FREELIST,
  773.                             &val_list, NULL );
  774.             }
  775.         }
  776.         else if( !strcmp( psz_cmd, "title_n" ) )
  777.         {
  778.             val.b_bool = VLC_TRUE;
  779.             var_Set( p_input, "next-title", val );
  780.         }
  781.         else if( !strcmp( psz_cmd, "title_p" ) )
  782.         {
  783.             val.b_bool = VLC_TRUE;
  784.             var_Set( p_input, "prev-title", val );
  785.         }
  787.         vlc_object_release( p_input );
  788.         return VLC_SUCCESS;
  789.     }
  791.     /* Never reached. */
  792.     return VLC_EGENERIC;
  793. }
  795. static int Playlist( vlc_object_t *p_this, char const *psz_cmd,
  796.                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
  797. {
  798.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  799.     playlist_t *p_playlist;
  801.     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,
  802.                                            FIND_ANYWHERE );
  803.     if( !p_playlist )
  804.     {
  805.         return VLC_ENOOBJ;
  806.     }
  808.     /* Parse commands that require a playlist */
  809.     if( !strcmp( psz_cmd, "prev" ) )
  810.     {
  811.         playlist_Prev( p_playlist );
  812.     }
  813.     else if( !strcmp( psz_cmd, "next" ) )
  814.     {
  815.         playlist_Next( p_playlist );
  816.     }
  817.     else if( !strcmp( psz_cmd, "play" ) )
  818.     {
  819.         playlist_Play( p_playlist );
  820.     }
  821.     else if( !strcmp( psz_cmd, "stop" ) )
  822.     {
  823.         playlist_Stop( p_playlist );
  824.     }
  825.     else if( !strcmp( psz_cmd, "add" ) )
  826.     {
  827.         msg_rtci( "trying to add %s to playlistn", newval.psz_string );
  828.         playlist_Add( p_playlist, newval.psz_string, newval.psz_string,
  829.                       PLAYLIST_GO|PLAYLIST_APPEND, PLAYLIST_END );
  830.     }
  831.     else if( !strcmp( psz_cmd, "playlist" ) )
  832.     {
  833.         int i;
  834.         for ( i = 0; i < p_playlist->i_size; i++ )
  835.         {
  836.             msg_rtci( "|%s%s   %s|n", i == p_playlist->i_index?"*":" ",
  837.                     p_playlist->pp_items[i]->input.psz_name,
  838.                     p_playlist->pp_items[i]->input.psz_uri );
  839.         }
  840.         if ( i == 0 )
  841.         {
  842.             msg_rtci( "| no entriesn" );
  843.         }
  844.     }
  845.  
  846.     /*
  847.      * sanity check
  848.      */
  849.     else
  850.     {
  851.         msg_rtci( "unknown command!n" );
  852.     }
  854.     vlc_object_release( p_playlist );
  855.     return VLC_SUCCESS;
  856. }
  858. static int Other( vlc_object_t *p_this, char const *psz_cmd,
  859.                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
  860. {
  861.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  862.     vlc_object_t *p_pl;
  863.     vlc_value_t     val;
  865.     p_pl = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,
  866.                                            FIND_ANYWHERE );
  867.     if( !p_pl )
  868.     {
  869.         return VLC_ENOOBJ;
  870.     }
  872.     /* Parse miscellaneous commands */
  873.     if( !strcmp( psz_cmd, "marq-marquee" ) )
  874.     {
  875.         if( strlen( newval.psz_string ) > 0 )
  876.         {
  877.             val.psz_string = newval.psz_string;
  878.             var_Set( p_pl, "marq-marquee", val );
  879.         }
  880.         else 
  881.         {
  882.         val.psz_string = "";
  883.         var_Set( p_pl, "marq-marquee", val);
  884.         }
  885.     }
  886.     else if( !strcmp( psz_cmd, "marq-x" ) )
  887.     {
  888.         if( strlen( newval.psz_string ) > 0) 
  889.         {
  890.             val.i_int = atoi( newval.psz_string );
  891.             var_Set( p_pl, "marq-x", val );
  892.         }
  893.     }
  894.     else if( !strcmp( psz_cmd, "marq-y" ) )
  895.     {
  896.         if( strlen( newval.psz_string ) > 0) 
  897.         {
  898.             val.i_int = atoi( newval.psz_string );
  899.             var_Set( p_pl, "marq-y", val );
  900.         }
  901.     }
  902.     else if( !strcmp( psz_cmd, "marq-timeout" ) )
  903.     {
  904.         if( strlen( newval.psz_string ) > 0) 
  905.         {
  906.             val.i_int = atoi( newval.psz_string );
  907.             var_Set( p_pl, "marq-timeout", val );
  908.         }
  909.     }
  910.  
  911.     /*
  912.      * sanity check
  913.      */
  914.     else
  915.     {
  916.         msg_rtci( "unknown command!n" );
  917.     }
  919.     vlc_object_release( p_pl );
  920.     return VLC_SUCCESS;
  921. }
  923. static int Quit( vlc_object_t *p_this, char const *psz_cmd,
  924.                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
  925. {
  926.     p_this->p_vlc->b_die = VLC_TRUE;
  927.     return VLC_SUCCESS;
  928. }
  930. static int Intf( vlc_object_t *p_this, char const *psz_cmd,
  931.                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
  932. {
  933.     intf_thread_t *p_newintf;
  935.     p_newintf = intf_Create( p_this->p_vlc, newval.psz_string );
  937.     if( p_newintf )
  938.     {
  939.         p_newintf->b_block = VLC_FALSE;
  940.         if( intf_RunThread( p_newintf ) )
  941.         {
  942.             vlc_object_detach( p_newintf );
  943.             intf_Destroy( p_newintf );
  944.         }
  945.     }
  947.     return VLC_SUCCESS;
  948. }
  950. static int Volume( vlc_object_t *p_this, char const *psz_cmd,
  951.                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
  952. {
  953.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  954.     int i_error;
  956.     if ( *newval.psz_string )
  957.     {
  958.         /* Set. */
  959.         audio_volume_t i_volume = atoi( newval.psz_string );
  960.         if ( i_volume > AOUT_VOLUME_MAX )
  961.         {
  962.             msg_rtci( "Volume must be in the range %d-%dn", AOUT_VOLUME_MIN,
  963.                     AOUT_VOLUME_MAX );
  964.             i_error = VLC_EBADVAR;
  965.         }
  966.         else i_error = aout_VolumeSet( p_this, i_volume );
  967.     }
  968.     else
  969.     {
  970.         /* Get. */
  971.         audio_volume_t i_volume;
  972.         if ( aout_VolumeGet( p_this, &i_volume ) < 0 )
  973.         {
  974.             i_error = VLC_EGENERIC;
  975.         }
  976.         else
  977.         {
  978.             msg_rtci( "Volume is %dn", i_volume );
  979.             i_error = VLC_SUCCESS;
  980.         }
  981.     }
  983.     return i_error;
  984. }
  986. static int VolumeMove( vlc_object_t *p_this, char const *psz_cmd,
  987.                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
  988. {
  989.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  990.     audio_volume_t i_volume;
  991.     int i_nb_steps = atoi(newval.psz_string);
  992.     int i_error = VLC_SUCCESS;
  994.     if ( i_nb_steps <= 0 || i_nb_steps > (AOUT_VOLUME_MAX/AOUT_VOLUME_STEP) )
  995.     {
  996.         i_nb_steps = 1;
  997.     }
  999.     if ( !strcmp(psz_cmd, "volup") )
  1000.     {
  1001.         if ( aout_VolumeUp( p_this, i_nb_steps, &i_volume ) < 0 )
  1002.             i_error = VLC_EGENERIC;
  1003.     }
  1004.     else
  1005.     {
  1006.         if ( aout_VolumeDown( p_this, i_nb_steps, &i_volume ) < 0 )
  1007.             i_error = VLC_EGENERIC;
  1008.     }
  1010.     if ( !i_error ) msg_rtci( "Volume is %dn", i_volume );
  1011.     return i_error;
  1012. }
  1014. static int AudioConfig( vlc_object_t *p_this, char const *psz_cmd,
  1015.                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
  1016. {
  1017.     intf_thread_t *p_intf = (intf_thread_t*)p_this;
  1018.     aout_instance_t * p_aout;
  1019.     const char * psz_variable;
  1020.     vlc_value_t val_name;
  1021.     int i_error;
  1023.     p_aout = vlc_object_find( p_this, VLC_OBJECT_AOUT, FIND_ANYWHERE );
  1024.     if ( p_aout == NULL ) return VLC_ENOOBJ;
  1026.     if ( !strcmp( psz_cmd, "adev" ) )
  1027.     {
  1028.         psz_variable = "audio-device";
  1029.     }
  1030.     else
  1031.     {
  1032.         psz_variable = "audio-channels";
  1033.     }
  1035.     /* Get the descriptive name of the variable */
  1036.     var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_GETTEXT,
  1037.                  &val_name, NULL );
  1038.     if( !val_name.psz_string ) val_name.psz_string = strdup(psz_variable);
  1040.     if ( !*newval.psz_string )
  1041.     {
  1042.         /* Retrieve all registered ***. */
  1043.         vlc_value_t val, text;
  1044.         int i, i_value;
  1046.         if ( var_Get( (vlc_object_t *)p_aout, psz_variable, &val ) < 0 )
  1047.         {
  1048.             vlc_object_release( (vlc_object_t *)p_aout );
  1049.             return VLC_EGENERIC;
  1050.         }
  1051.         i_value = val.i_int;
  1053.         if ( var_Change( (vlc_object_t *)p_aout, psz_variable,
  1054.                          VLC_VAR_GETLIST, &val, &text ) < 0 )
  1055.         {
  1056.             vlc_object_release( (vlc_object_t *)p_aout );
  1057.             return VLC_EGENERIC;
  1058.         }
  1060.         msg_rtci( "+----[ %s ]n", val_name.psz_string );
  1061.         for ( i = 0; i < val.p_list->i_count; i++ )
  1062.         {
  1063.             if ( i_value == val.p_list->p_values[i].i_int )
  1064.                 msg_rtci( "| %i - %s *n", val.p_list->p_values[i].i_int,
  1065.                         text.p_list->p_values[i].psz_string );
  1066.             else
  1067.                 msg_rtci( "| %i - %sn", val.p_list->p_values[i].i_int,
  1068.                         text.p_list->p_values[i].psz_string );
  1069.         }
  1070.         var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_FREELIST,
  1071.                     &val, &text );
  1072.         msg_rtci( "+----[ end of %s ]n", val_name.psz_string );
  1074.         if( val_name.psz_string ) free( val_name.psz_string );
  1075.         i_error = VLC_SUCCESS;
  1076.     }
  1077.     else
  1078.     {
  1079.         vlc_value_t val;
  1080.         val.i_int = atoi( newval.psz_string );
  1082.         i_error = var_Set( (vlc_object_t *)p_aout, psz_variable, val );
  1083.     }
  1084.     vlc_object_release( (vlc_object_t *)p_aout );
  1086.     return i_error;
  1087. }
  1089. #ifdef WIN32
  1090. vlc_bool_t ReadWin32( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
  1091. {
  1092.     INPUT_RECORD input_record;
  1093.     DWORD i_dw;
  1095.     /* On Win32, select() only works on socket descriptors */
  1096.     while( WaitForSingleObject( p_intf->p_sys->hConsoleIn,
  1097.                                 INTF_IDLE_SLEEP/1000 ) == WAIT_OBJECT_0 )
  1098.     {
  1099.         while( !p_intf->b_die && *pi_size < MAX_LINE_LENGTH &&
  1100.                ReadConsoleInput( p_intf->p_sys->hConsoleIn, &input_record,
  1101.                                  1, &i_dw ) )
  1102.         {
  1103.             if( input_record.EventType != KEY_EVENT ||
  1104.                 !input_record.Event.KeyEvent.bKeyDown ||
  1105.                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT ||
  1106.                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL||
  1107.                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_MENU ||
  1108.                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CAPITAL )
  1109.             {
  1110.                 /* nothing interesting */
  1111.                 continue;
  1112.             }
  1114.             p_buffer[ *pi_size ] = input_record.Event.KeyEvent.uChar.AsciiChar;
  1116.             /* Echo out the command */
  1117.             putc( p_buffer[ *pi_size ], stdout );
  1119.             /* Handle special keys */
  1120.             if( p_buffer[ *pi_size ] == 'r' || p_buffer[ *pi_size ] == 'n' )
  1121.             {
  1122.                 putc( 'n', stdout );
  1123.                 break;
  1124.             }
  1125.             switch( p_buffer[ *pi_size ] )
  1126.             {
  1127.             case 'b':
  1128.                 if( *pi_size )
  1129.                 {
  1130.                     *pi_size -= 2;
  1131.                     putc( ' ', stdout );
  1132.                     putc( 'b', stdout );
  1133.                 }
  1134.                 break;
  1135.             case 'r':
  1136.                 (*pi_size) --;
  1137.                 break;
  1138.             }
  1140.             (*pi_size)++;
  1141.         }
  1143.         if( *pi_size == MAX_LINE_LENGTH ||
  1144.             p_buffer[ *pi_size ] == 'r' || p_buffer[ *pi_size ] == 'n' )
  1145.         {
  1146.             p_buffer[ *pi_size ] = 0;
  1147.             return VLC_TRUE;
  1148.         }
  1149.     }
  1151.     return VLC_FALSE;
  1152. }
  1153. #endif
  1155. vlc_bool_t ReadCommand( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
  1156. {
  1157.     int i_read = 0;
  1159. #ifdef WIN32
  1160.     if( p_intf->p_sys->i_socket == -1 )
  1161.         return ReadWin32( p_intf, p_buffer, pi_size );
  1162. #endif
  1164.     while( !p_intf->b_die && *pi_size < MAX_LINE_LENGTH &&
  1165.            (i_read = net_ReadNonBlock( p_intf, p_intf->p_sys->i_socket == -1 ?
  1166.                        STDIN_FILENO : p_intf->p_sys->i_socket,
  1167.                        p_buffer + *pi_size, 1, INTF_IDLE_SLEEP ) ) > 0 )
  1168.     {
  1169.         if( p_buffer[ *pi_size ] == 'r' || p_buffer[ *pi_size ] == 'n' )
  1170.             break;
  1172.         (*pi_size)++;
  1173.     }
  1175.     /* Connection closed */
  1176.     if( i_read == -1 )
  1177.     {
  1178.         p_intf->p_sys->i_socket = -1;
  1179.         p_buffer[ *pi_size ] = 0;
  1180.         return VLC_TRUE;
  1181.     }
  1183.     if( *pi_size == MAX_LINE_LENGTH ||
  1184.         p_buffer[ *pi_size ] == 'r' || p_buffer[ *pi_size ] == 'n' )
  1185.     {
  1186.         p_buffer[ *pi_size ] = 0;
  1187.         return VLC_TRUE;
  1188.     }
  1190.     return VLC_FALSE;
  1191. }