Remove E_()
authorRémi Denis-Courmont <rem@videolan.org>
Thu, 8 May 2008 16:16:45 +0000 (19:16 +0300)
committerRémi Denis-Courmont <rem@videolan.org>
Thu, 8 May 2008 16:23:43 +0000 (19:23 +0300)
110 files changed:
include/vlc_modules_macros.h
modules/access/dvb/access.c
modules/access/dvb/dvb.h
modules/access/dvb/en50221.c
modules/access/dvb/http.c
modules/access/dvb/linux_dvb.c
modules/access/mms/asf.c
modules/access/mms/asf.h
modules/access/mms/mms.c
modules/access/mms/mms.h
modules/access/mms/mmsh.c
modules/access/mms/mmstu.c
modules/access/vcdx/demux.c
modules/access/vcdx/vcd.c
modules/codec/cmml/cmml.c
modules/codec/cmml/intf.c
modules/codec/ffmpeg/audio.c
modules/codec/ffmpeg/chroma.c
modules/codec/ffmpeg/deinterlace.c
modules/codec/ffmpeg/demux.c
modules/codec/ffmpeg/encoder.c
modules/codec/ffmpeg/ffmpeg.c
modules/codec/ffmpeg/ffmpeg.h
modules/codec/ffmpeg/mux.c
modules/codec/ffmpeg/postprocess.c
modules/codec/ffmpeg/scale.c
modules/codec/ffmpeg/video.c
modules/codec/ffmpeg/video_filter.c
modules/codec/spudec/parse.c
modules/codec/spudec/spudec.c
modules/codec/spudec/spudec.h
modules/control/gestures.c
modules/control/http/http.c
modules/control/http/http.h
modules/control/http/macro.c
modules/control/http/mvar.c
modules/control/http/rpn.c
modules/control/http/util.c
modules/control/showintf.c
modules/demux/live555.cpp
modules/demux/playlist/asx.c
modules/demux/playlist/b4s.c
modules/demux/playlist/dvb.c
modules/demux/playlist/gvp.c
modules/demux/playlist/ifo.c
modules/demux/playlist/itml.c
modules/demux/playlist/m3u.c
modules/demux/playlist/playlist.c
modules/demux/playlist/playlist.h
modules/demux/playlist/pls.c
modules/demux/playlist/podcast.c
modules/demux/playlist/qtl.c
modules/demux/playlist/sgimb.c
modules/demux/playlist/shoutcast.c
modules/demux/playlist/xspf.c
modules/gui/beos/AudioOutput.cpp
modules/gui/beos/BeOS.cpp
modules/gui/beos/Interface.cpp
modules/gui/beos/VideoOutput.cpp
modules/gui/macosx/intf.m
modules/gui/macosx/macosx.m
modules/gui/macosx/voutgl.m
modules/gui/macosx/voutqt.m
modules/gui/minimal_macosx/intf.m
modules/gui/minimal_macosx/macosx.c
modules/gui/minimal_macosx/voutgl.m
modules/gui/pda/pda.c
modules/gui/pda/pda.h
modules/gui/pda/pda_callbacks.c
modules/gui/qnx/aout.c
modules/gui/qnx/qnx.c
modules/gui/qnx/vout.c
modules/misc/dummy/aout.c
modules/misc/dummy/decoder.c
modules/misc/dummy/dummy.c
modules/misc/dummy/dummy.h
modules/misc/dummy/encoder.c
modules/misc/dummy/input.c
modules/misc/dummy/interface.c
modules/misc/dummy/renderer.c
modules/misc/dummy/vout.c
modules/misc/lua/intf.c
modules/misc/lua/meta.c
modules/misc/lua/playlist.c
modules/misc/lua/vlc.c
modules/misc/lua/vlc.h
modules/misc/memcpy/memcpy.c
modules/misc/playlist/export.c
modules/misc/playlist/xspf.c
modules/misc/playlist/xspf.h
modules/mux/mpeg/csa.h
modules/mux/mpeg/pes.c
modules/mux/mpeg/pes.h
modules/mux/mpeg/ps.c
modules/mux/mpeg/ts.c
modules/video_chroma/i420_rgb.c
modules/video_chroma/i420_rgb.h
modules/video_chroma/i420_rgb16.c
modules/video_chroma/i420_rgb8.c
modules/video_output/msw/direct3d.c
modules/video_output/msw/directx.c
modules/video_output/msw/events.c
modules/video_output/msw/glwin32.c
modules/video_output/msw/vout.h
modules/video_output/msw/wingdi.c
modules/video_output/x11/glx.c
modules/video_output/x11/x11.c
modules/video_output/x11/xcommon.c
modules/video_output/x11/xvideo.c
modules/video_output/x11/xvmc.c

index 2c05ae0..599772c 100644 (file)
 /* If the module is built-in, then we need to define foo_InitModule instead
  * of InitModule. Same for Activate- and DeactivateModule. */
 #ifdef __PLUGIN__
-#   define E_( function )          CONCATENATE( function, MODULE_SYMBOL )
 #   define __VLC_SYMBOL( symbol  ) CONCATENATE( symbol, MODULE_SYMBOL )
 #else
-#   define E_( function )          CONCATENATE( function, MODULE_NAME )
 #   define __VLC_SYMBOL( symbol )  CONCATENATE( symbol, MODULE_NAME )
 #endif
 
@@ -96,7 +94,7 @@
  */
 #if defined (__PLUGIN__) || defined (__BUILTIN__)
 EXTERN_SYMBOL DLL_SYMBOL int CDECL_SYMBOL
-E_(vlc_entry) ( module_t *p_module );
+__VLC_SYMBOL(vlc_entry) ( module_t *p_module );
 #endif
 
 #define vlc_module_begin( )                                                   \
index 494efbc..da51365 100644 (file)
@@ -336,7 +336,7 @@ static int Open( vlc_object_t *p_this )
     }
 
     /* Getting frontend info */
-    if( E_(FrontendOpen)( p_access) )
+    if( FrontendOpen( p_access) )
     {
         free( p_sys );
         return VLC_EGENERIC;
@@ -344,17 +344,17 @@ static int Open( vlc_object_t *p_this )
 
     /* Setting frontend parameters for tuning the hardware */
     msg_Dbg( p_access, "trying to tune the frontend...");
-    if( E_(FrontendSet)( p_access ) < 0 )
+    if( FrontendSet( p_access ) < 0 )
     {
-        E_(FrontendClose)( p_access );
+        FrontendClose( p_access );
         free( p_sys );
         return VLC_EGENERIC;
     }
 
     /* Opening DVR device */
-    if( E_(DVROpen)( p_access ) < 0 )
+    if( DVROpen( p_access ) < 0 )
     {
-        E_(FrontendClose)( p_access );
+        FrontendClose( p_access );
         free( p_sys );
         return VLC_EGENERIC;
     }
@@ -371,7 +371,7 @@ static int Open( vlc_object_t *p_this )
         FilterSet( p_access, 0x0, OTHER_TYPE );
     }
 
-    E_(CAMOpen)( p_access );
+    CAMOpen( p_access );
 
     if( p_sys->b_budget_mode )
         p_sys->i_read_once = DVB_READ_ONCE;
@@ -379,7 +379,7 @@ static int Open( vlc_object_t *p_this )
         p_sys->i_read_once = DVB_READ_ONCE_START;
 
 #ifdef ENABLE_HTTPD
-    E_(HTTPOpen)( p_access );
+    HTTPOpen( p_access );
 #endif
 
     return VLC_SUCCESS;
@@ -395,12 +395,12 @@ static void Close( vlc_object_t *p_this )
 
     FilterUnset( p_access, p_sys->b_budget_mode ? 1 : MAX_DEMUX );
 
-    E_(DVRClose)( p_access );
-    E_(FrontendClose)( p_access );
-    E_(CAMClose)( p_access );
+    DVRClose( p_access );
+    FrontendClose( p_access );
+    CAMClose( p_access );
 
 #ifdef ENABLE_HTTPD
-    E_(HTTPClose)( p_access );
+    HTTPClose( p_access );
 #endif
 
     free( p_sys );
@@ -444,13 +444,13 @@ static block_t *Block( access_t *p_access )
 
         if ( p_sys->i_ca_handle && mdate() > p_sys->i_ca_next_event )
         {
-            E_(CAMPoll)( p_access );
+            CAMPoll( p_access );
             p_sys->i_ca_next_event = mdate() + p_sys->i_ca_timeout;
         }
 
         if ( ufds[1].revents )
         {
-            E_(FrontendPoll)( p_access );
+            FrontendPoll( p_access );
         }
 
 #ifdef ENABLE_HTTPD
@@ -475,19 +475,19 @@ static block_t *Block( access_t *p_access )
 
         if ( p_sys->b_request_frontend_info )
         {
-            E_(FrontendStatus)( p_access );
+            FrontendStatus( p_access );
         }
 
         if ( p_sys->b_request_mmi_info )
         {
-            E_(CAMStatus)( p_access );
+            CAMStatus( p_access );
         }
 #endif
 
         if ( p_sys->i_frontend_timeout && mdate() > p_sys->i_frontend_timeout )
         {
             msg_Warn( p_access, "no lock, tuning again" );
-            E_(FrontendSet)( p_access );
+            FrontendSet( p_access );
         }
 
         if ( ufds[0].revents )
@@ -569,7 +569,7 @@ static int Control( access_t *p_access, int i_query, va_list args )
 
             p_pmt = (dvbpsi_pmt_t *)va_arg( args, dvbpsi_pmt_t * );
 
-            E_(CAMSet)( p_access, p_pmt );
+            CAMSet( p_access, p_pmt );
             break;
         }
 
@@ -605,7 +605,7 @@ static void FilterSet( access_t *p_access, int i_pid, int i_type )
         return;
     }
 
-    if( E_(DMXSetFilter)( p_access, i_pid,
+    if( DMXSetFilter( p_access, i_pid,
                            &p_sys->p_demux_handles[i].i_handle, i_type ) )
     {
         msg_Err( p_access, "DMXSetFilter failed" );
@@ -627,7 +627,7 @@ static void FilterUnset( access_t *p_access, int i_max )
     {
         if( p_sys->p_demux_handles[i].i_type )
         {
-            E_(DMXUnsetFilter)( p_access, p_sys->p_demux_handles[i].i_handle );
+            DMXUnsetFilter( p_access, p_sys->p_demux_handles[i].i_handle );
             p_sys->p_demux_handles[i].i_type = 0;
         }
     }
@@ -643,7 +643,7 @@ static void FilterUnsetPID( access_t *p_access, int i_pid )
         if( p_sys->p_demux_handles[i].i_type &&
             p_sys->p_demux_handles[i].i_pid == i_pid )
         {
-            E_(DMXUnsetFilter)( p_access, p_sys->p_demux_handles[i].i_handle );
+            DMXUnsetFilter( p_access, p_sys->p_demux_handles[i].i_handle );
             p_sys->p_demux_handles[i].i_type = 0;
         }
     }
index d71b76e..f8f21e7 100644 (file)
@@ -181,42 +181,42 @@ struct access_sys_t
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-int  E_(FrontendOpen)( access_t * );
-void E_(FrontendPoll)( access_t *p_access );
-int  E_(FrontendSet)( access_t * );
-void E_(FrontendClose)( access_t * );
+int  FrontendOpen( access_t * );
+void FrontendPoll( access_t *p_access );
+int  FrontendSet( access_t * );
+void FrontendClose( access_t * );
 #ifdef ENABLE_HTTPD
-void E_(FrontendStatus)( access_t * );
+void FrontendStatus( access_t * );
 #endif
 
-int E_(DMXSetFilter)( access_t *, int i_pid, int * pi_fd, int i_type );
-int E_(DMXUnsetFilter)( access_t *, int i_fd );
+int DMXSetFilter( access_t *, int i_pid, int * pi_fd, int i_type );
+int DMXUnsetFilter( access_t *, int i_fd );
 
-int  E_(DVROpen)( access_t * );
-void E_(DVRClose)( access_t * );
+int  DVROpen( access_t * );
+void DVRClose( access_t * );
 
-int  E_(CAMOpen)( access_t * );
-int  E_(CAMPoll)( access_t * );
-int  E_(CAMSet)( access_t *, dvbpsi_pmt_t * );
-void E_(CAMClose)( access_t * );
+int  CAMOpen( access_t * );
+int  CAMPoll( access_t * );
+int  CAMSet( access_t *, dvbpsi_pmt_t * );
+void CAMClose( access_t * );
 #ifdef ENABLE_HTTPD
-void E_(CAMStatus)( access_t * );
+void CAMStatus( access_t * );
 #endif
 
-int E_(en50221_Init)( access_t * );
-int E_(en50221_Poll)( access_t * );
-int E_(en50221_SetCAPMT)( access_t *, dvbpsi_pmt_t * );
-int E_(en50221_OpenMMI)( access_t * p_access, int i_slot );
-int E_(en50221_CloseMMI)( access_t * p_access, int i_slot );
-en50221_mmi_object_t *E_(en50221_GetMMIObject)( access_t * p_access,
+int en50221_Init( access_t * );
+int en50221_Poll( access_t * );
+int en50221_SetCAPMT( access_t *, dvbpsi_pmt_t * );
+int en50221_OpenMMI( access_t * p_access, int i_slot );
+int en50221_CloseMMI( access_t * p_access, int i_slot );
+en50221_mmi_object_t *en50221_GetMMIObject( access_t * p_access,
                                                 int i_slot );
-void E_(en50221_SendMMIObject)( access_t * p_access, int i_slot,
+void en50221_SendMMIObject( access_t * p_access, int i_slot,
                                 en50221_mmi_object_t *p_object );
-void E_(en50221_End)( access_t * );
+void en50221_End( access_t * );
 
 #ifdef ENABLE_HTTPD
-int E_(HTTPOpen)( access_t *p_access );
-void E_(HTTPClose)( access_t *p_access );
-char *E_(HTTPExtractValue)( char *psz_uri, const char *psz_name,
+int HTTPOpen( access_t *p_access );
+void HTTPClose( access_t *p_access );
+char *HTTPExtractValue( char *psz_uri, const char *psz_name,
                             char *psz_value, int i_value_max );
 #endif
index b64ebae..3b18c85 100644 (file)
@@ -1844,7 +1844,7 @@ static int InitSlot( access_t * p_access, int i_slot )
 /*****************************************************************************
  * en50221_Init : Initialize the CAM for en50221
  *****************************************************************************/
-int E_(en50221_Init)( access_t * p_access )
+int en50221_Init( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -1941,7 +1941,7 @@ int E_(en50221_Init)( access_t * p_access )
 /*****************************************************************************
  * en50221_Poll : Poll the CAM for TPDUs
  *****************************************************************************/
-int E_(en50221_Poll)( access_t * p_access )
+int en50221_Poll( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int i_slot;
@@ -2088,7 +2088,7 @@ int E_(en50221_Poll)( access_t * p_access )
 /*****************************************************************************
  * en50221_SetCAPMT :
  *****************************************************************************/
-int E_(en50221_SetCAPMT)( access_t * p_access, dvbpsi_pmt_t *p_pmt )
+int en50221_SetCAPMT( access_t * p_access, dvbpsi_pmt_t *p_pmt )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int i, i_session_id;
@@ -2159,7 +2159,7 @@ int E_(en50221_SetCAPMT)( access_t * p_access, dvbpsi_pmt_t *p_pmt )
 /*****************************************************************************
  * en50221_OpenMMI :
  *****************************************************************************/
-int E_(en50221_OpenMMI)( access_t * p_access, int i_slot )
+int en50221_OpenMMI( access_t * p_access, int i_slot )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -2202,7 +2202,7 @@ int E_(en50221_OpenMMI)( access_t * p_access, int i_slot )
 /*****************************************************************************
  * en50221_CloseMMI :
  *****************************************************************************/
-int E_(en50221_CloseMMI)( access_t * p_access, int i_slot )
+int en50221_CloseMMI( access_t * p_access, int i_slot )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -2233,7 +2233,7 @@ int E_(en50221_CloseMMI)( access_t * p_access, int i_slot )
 /*****************************************************************************
  * en50221_GetMMIObject :
  *****************************************************************************/
-en50221_mmi_object_t *E_(en50221_GetMMIObject)( access_t * p_access,
+en50221_mmi_object_t *en50221_GetMMIObject( access_t * p_access,
                                                 int i_slot )
 {
     access_sys_t *p_sys = p_access->p_sys;
@@ -2262,7 +2262,7 @@ en50221_mmi_object_t *E_(en50221_GetMMIObject)( access_t * p_access,
 /*****************************************************************************
  * en50221_SendMMIObject :
  *****************************************************************************/
-void E_(en50221_SendMMIObject)( access_t * p_access, int i_slot,
+void en50221_SendMMIObject( access_t * p_access, int i_slot,
                                 en50221_mmi_object_t *p_object )
 {
     access_sys_t *p_sys = p_access->p_sys;
@@ -2284,7 +2284,7 @@ void E_(en50221_SendMMIObject)( access_t * p_access, int i_slot,
 /*****************************************************************************
  * en50221_End :
  *****************************************************************************/
-void E_(en50221_End)( access_t * p_access )
+void en50221_End( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int i_session_id, i;
index ec79ca2..91c98f9 100644 (file)
@@ -79,7 +79,7 @@ static int HttpCallback( httpd_file_sys_t *p_args,
 /*****************************************************************************
  * HTTPOpen: Start the internal HTTP server
  *****************************************************************************/
-int E_(HTTPOpen)( access_t *p_access )
+int HTTPOpen( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     char          *psz_address, *psz_cert = NULL, *psz_key = NULL,
@@ -194,7 +194,7 @@ int E_(HTTPOpen)( access_t *p_access )
 /*****************************************************************************
  * HTTPClose: Stop the internal HTTP server
  *****************************************************************************/
-void E_(HTTPClose)( access_t *p_access )
+void HTTPClose( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -295,7 +295,7 @@ static int HttpCallback( httpd_file_sys_t *p_args,
 /****************************************************************************
  * HTTPExtractValue: Extract a GET variable from psz_request
  ****************************************************************************/
-char *E_(HTTPExtractValue)( char *psz_uri, const char *psz_name,
+char *HTTPExtractValue( char *psz_uri, const char *psz_name,
                             char *psz_value, int i_value_max )
 {
     char *p = psz_uri;
index 6549573..f342777 100644 (file)
@@ -91,7 +91,7 @@ static int FrontendSetATSC( access_t * );
 /*****************************************************************************
  * FrontendOpen : Determine frontend device information and capabilities
  *****************************************************************************/
-int E_(FrontendOpen)( access_t *p_access )
+int FrontendOpen( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     frontend_t * p_frontend;
@@ -212,7 +212,7 @@ int E_(FrontendOpen)( access_t *p_access )
 /*****************************************************************************
  * FrontendClose : Close the frontend
  *****************************************************************************/
-void E_(FrontendClose)( access_t *p_access )
+void FrontendClose( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -228,7 +228,7 @@ void E_(FrontendClose)( access_t *p_access )
 /*****************************************************************************
  * FrontendSet : Tune !
  *****************************************************************************/
-int E_(FrontendSet)( access_t *p_access )
+int FrontendSet( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -283,7 +283,7 @@ int E_(FrontendSet)( access_t *p_access )
 /*****************************************************************************
  * FrontendPoll : Poll for frontend events
  *****************************************************************************/
-void E_(FrontendPoll)( access_t *p_access )
+void FrontendPoll( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     frontend_t * p_frontend = p_sys->p_frontend;
@@ -359,7 +359,7 @@ void E_(FrontendPoll)( access_t *p_access )
             {
                 /* The frontend was reinited. */
                 msg_Warn( p_access, "reiniting frontend");
-                E_(FrontendSet)( p_access );
+                FrontendSet( p_access );
             }
         }
 #undef IF_UP
@@ -370,7 +370,7 @@ void E_(FrontendPoll)( access_t *p_access )
 /*****************************************************************************
  * FrontendStatus : Read frontend status
  *****************************************************************************/
-void E_(FrontendStatus)( access_t *p_access )
+void FrontendStatus( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     frontend_t *p_frontend = p_sys->p_frontend;
@@ -1223,7 +1223,7 @@ static int FrontendSetATSC( access_t *p_access )
 /*****************************************************************************
  * DMXSetFilter : controls the demux to add a filter
  *****************************************************************************/
-int E_(DMXSetFilter)( access_t * p_access, int i_pid, int * pi_fd, int i_type )
+int DMXSetFilter( access_t * p_access, int i_pid, int * pi_fd, int i_type )
 {
     struct dmx_pes_filter_params s_filter_params;
     int i_ret;
@@ -1361,7 +1361,7 @@ int E_(DMXSetFilter)( access_t * p_access, int i_pid, int * pi_fd, int i_type )
 /*****************************************************************************
  * DMXUnsetFilter : removes a filter
  *****************************************************************************/
-int E_(DMXUnsetFilter)( access_t * p_access, int i_fd )
+int DMXUnsetFilter( access_t * p_access, int i_fd )
 {
     int i_ret;
 
@@ -1384,7 +1384,7 @@ int E_(DMXUnsetFilter)( access_t * p_access, int i_fd )
 /*****************************************************************************
  * DVROpen :
  *****************************************************************************/
-int E_(DVROpen)( access_t * p_access )
+int DVROpen( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     unsigned int i_adapter, i_device;
@@ -1421,7 +1421,7 @@ int E_(DVROpen)( access_t * p_access )
 /*****************************************************************************
  * DVRClose :
  *****************************************************************************/
-void E_(DVRClose)( access_t * p_access )
+void DVRClose( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -1436,7 +1436,7 @@ void E_(DVRClose)( access_t * p_access )
 /*****************************************************************************
  * CAMOpen :
  *****************************************************************************/
-int E_(CAMOpen)( access_t *p_access )
+int CAMOpen( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     char ca[128];
@@ -1522,13 +1522,13 @@ int E_(CAMOpen)( access_t *p_access )
     memset( p_sys->pb_slot_mmi_undisplayed, 0,
             sizeof(bool) * MAX_CI_SLOTS );
 
-    return E_(en50221_Init)( p_access );
+    return en50221_Init( p_access );
 }
 
 /*****************************************************************************
  * CAMPoll :
  *****************************************************************************/
-int E_(CAMPoll)( access_t * p_access )
+int CAMPoll( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     int i_ret = VLC_EGENERIC;
@@ -1541,7 +1541,7 @@ int E_(CAMPoll)( access_t * p_access )
     switch( p_sys->i_ca_type )
     {
     case CA_CI_LINK:
-        i_ret = E_(en50221_Poll)( p_access );
+        i_ret = en50221_Poll( p_access );
         break;
     case CA_CI:
         i_ret = VLC_SUCCESS;
@@ -1558,7 +1558,7 @@ int E_(CAMPoll)( access_t * p_access )
 /*****************************************************************************
  * CAMStatus :
  *****************************************************************************/
-void E_(CAMStatus)( access_t * p_access )
+void CAMStatus( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
     char *p;
@@ -1592,7 +1592,7 @@ void E_(CAMStatus)( access_t * p_access )
 
         p_sys->psz_request = NULL;
 
-        if ( E_(HTTPExtractValue)( psz_request, "slot", psz_value,
+        if ( HTTPExtractValue( psz_request, "slot", psz_value,
                                    sizeof(psz_value) ) == NULL )
         {
             p_sys->psz_mmi_info = strdup( "invalid request parameter\n" );
@@ -1600,27 +1600,27 @@ void E_(CAMStatus)( access_t * p_access )
         }
         i_slot = atoi(psz_value);
 
-        if ( E_(HTTPExtractValue)( psz_request, "open", psz_value,
+        if ( HTTPExtractValue( psz_request, "open", psz_value,
                                    sizeof(psz_value) ) != NULL )
         {
-            E_(en50221_OpenMMI)( p_access, i_slot );
+            en50221_OpenMMI( p_access, i_slot );
             return;
         }
 
-        if ( E_(HTTPExtractValue)( psz_request, "close", psz_value,
+        if ( HTTPExtractValue( psz_request, "close", psz_value,
                                    sizeof(psz_value) ) != NULL )
         {
-            E_(en50221_CloseMMI)( p_access, i_slot );
+            en50221_CloseMMI( p_access, i_slot );
             return;
         }
 
-        if ( E_(HTTPExtractValue)( psz_request, "cancel", psz_value,
+        if ( HTTPExtractValue( psz_request, "cancel", psz_value,
                                    sizeof(psz_value) ) == NULL )
         {
             b_ok = true;
         }
 
-        if ( E_(HTTPExtractValue)( psz_request, "type", psz_value,
+        if ( HTTPExtractValue( psz_request, "type", psz_value,
                                    sizeof(psz_value) ) == NULL )
         {
             p_sys->psz_mmi_info = strdup( "invalid request parameter\n" );
@@ -1637,7 +1637,7 @@ void E_(CAMStatus)( access_t * p_access )
             }
             else
             {
-                if ( E_(HTTPExtractValue)( psz_request, "answ", psz_value,
+                if ( HTTPExtractValue( psz_request, "answ", psz_value,
                                            sizeof(psz_value) ) == NULL )
                 {
                     p_sys->psz_mmi_info = strdup( "invalid request parameter\n" );
@@ -1656,7 +1656,7 @@ void E_(CAMStatus)( access_t * p_access )
             }
             else
             {
-                if ( E_(HTTPExtractValue)( psz_request, "choice", psz_value,
+                if ( HTTPExtractValue( psz_request, "choice", psz_value,
                                            sizeof(psz_value) ) == NULL )
                     mmi_object.u.menu_answ.i_choice = 0;
                 else
@@ -1664,7 +1664,7 @@ void E_(CAMStatus)( access_t * p_access )
             }
         }
 
-        E_(en50221_SendMMIObject)( p_access, i_slot, &mmi_object );
+        en50221_SendMMIObject( p_access, i_slot, &mmi_object );
         return;
     }
 
@@ -1739,7 +1739,7 @@ void E_(CAMStatus)( access_t * p_access )
 
         if ( sinfo.flags & CA_CI_MODULE_READY )
         {
-            en50221_mmi_object_t *p_object = E_(en50221_GetMMIObject)( p_access,
+            en50221_mmi_object_t *p_object = en50221_GetMMIObject( p_access,
                                                                        i_slot );
 
             p += sprintf( p, "module present and ready<p>\n" );
@@ -1818,7 +1818,7 @@ out:
 /*****************************************************************************
  * CAMSet :
  *****************************************************************************/
-int E_(CAMSet)( access_t * p_access, dvbpsi_pmt_t *p_pmt )
+int CAMSet( access_t * p_access, dvbpsi_pmt_t *p_pmt )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -1828,7 +1828,7 @@ int E_(CAMSet)( access_t * p_access, dvbpsi_pmt_t *p_pmt )
         return VLC_EGENERIC;
     }
 
-    E_(en50221_SetCAPMT)( p_access, p_pmt );
+    en50221_SetCAPMT( p_access, p_pmt );
 
     return VLC_SUCCESS;
 }
@@ -1836,11 +1836,11 @@ int E_(CAMSet)( access_t * p_access, dvbpsi_pmt_t *p_pmt )
 /*****************************************************************************
  * CAMClose :
  *****************************************************************************/
-void E_(CAMClose)( access_t * p_access )
+void CAMClose( access_t * p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
-    E_(en50221_End)( p_access );
+    en50221_End( p_access );
 
     if ( p_sys->i_ca_handle )
     {
index bde6239..23998c6 100644 (file)
@@ -45,7 +45,7 @@ static int CmpGuid( const guid_t *p_guid1, const guid_t *p_guid2 )
               p_guid1->v4[7] == p_guid2->v4[7] ) ? 1 : 0 );
 }
 
-void E_( GenerateGuid )( guid_t *p_guid )
+void  GenerateGuid ( guid_t *p_guid )
 {
     int i;
 
@@ -61,7 +61,7 @@ void E_( GenerateGuid )( guid_t *p_guid )
     }
 }
 
-void E_( asf_HeaderParse )( asf_header_t *hdr,
+void  asf_HeaderParse ( asf_header_t *hdr,
                             uint8_t *p_header, int i_header )
 {
     var_buffer_t buffer;
@@ -201,7 +201,7 @@ void E_( asf_HeaderParse )( asf_header_t *hdr,
     }
 }
 
-void E_( asf_StreamSelect ) ( asf_header_t *hdr,
+void  asf_StreamSelect  ( asf_header_t *hdr,
                               int i_bitrate_max,
                               bool b_all, bool b_audio, bool b_video )
 {
index e538853..4c198a5 100644 (file)
@@ -61,9 +61,9 @@ typedef struct guid_s
 } guid_t;
 
 
-void E_( GenerateGuid )     ( guid_t * );
-void E_( asf_HeaderParse )  ( asf_header_t *, uint8_t *, int );
-void E_( asf_StreamSelect ) ( asf_header_t *,
+void  GenerateGuid      ( guid_t * );
+void  asf_HeaderParse   ( asf_header_t *, uint8_t *, int );
+void  asf_StreamSelect  ( asf_header_t *,
                               int i_bitrate_max, bool b_all, bool b_audio,
                               bool b_video );
 
index 78ab1c4..8dd69d8 100644 (file)
@@ -123,23 +123,23 @@ static int Open( vlc_object_t *p_this )
     {
         if( !strncmp( p_access->psz_access, "mmsu", 4 ) )
         {
-            return E_( MMSTUOpen )( p_access );
+            return  MMSTUOpen ( p_access );
         }
         else if( !strncmp( p_access->psz_access, "mmst", 4 ) )
         {
-            return E_( MMSTUOpen )( p_access );
+            return  MMSTUOpen ( p_access );
         }
         else if( !strncmp( p_access->psz_access, "mmsh", 4 ) ||
                  !strncmp( p_access->psz_access, "http", 4 ) )
         {
-            return E_( MMSHOpen )( p_access );
+            return  MMSHOpen ( p_access );
         }
     }
 
-    if( E_( MMSTUOpen )( p_access ) )
+    if(  MMSTUOpen ( p_access ) )
     {
         /* try mmsh if mmstu failed */
-        return E_( MMSHOpen )( p_access );
+        return  MMSHOpen ( p_access );
     }
     return VLC_SUCCESS;
 }
@@ -155,10 +155,10 @@ static void Close( vlc_object_t *p_this )
     if( ( p_sys->i_proto == MMS_PROTO_TCP ) ||
         ( p_sys->i_proto == MMS_PROTO_UDP ) )
     {
-        E_( MMSTUClose )( p_access );
+         MMSTUClose ( p_access );
     }
     else if( p_sys->i_proto == MMS_PROTO_HTTP )
     {
-        E_( MMSHClose )( p_access );
+         MMSHClose ( p_access );
     }
 }
index b78fac3..979de0e 100644 (file)
 #define MMS_PROTO_HTTP  3
 
 /* mmst and mmsu */
-int  E_( MMSTUOpen )  ( access_t * );
-void E_( MMSTUClose ) ( access_t * );
+int   MMSTUOpen   ( access_t * );
+void  MMSTUClose  ( access_t * );
 
 /* mmsh */
-int  E_( MMSHOpen )  ( access_t * );
-void E_( MMSHClose ) ( access_t * );
+int   MMSHOpen   ( access_t * );
+void  MMSHClose  ( access_t * );
 
 #endif
 
index a9779d2..c188f93 100644 (file)
@@ -49,8 +49,8 @@
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int  E_(MMSHOpen)  ( access_t * );
-void E_(MMSHClose) ( access_t * );
+int  MMSHOpen  ( access_t * );
+void MMSHClose ( access_t * );
 
 static ssize_t Read( access_t *, uint8_t *, size_t );
 static ssize_t ReadRedirect( access_t *, uint8_t *, size_t );
@@ -73,7 +73,7 @@ static int Reset( access_t * );
 /****************************************************************************
  * Open: connect to ftp server and ask for file
  ****************************************************************************/
-int E_(MMSHOpen)( access_t *p_access )
+int MMSHOpen( access_t *p_access )
 {
     access_sys_t    *p_sys;
     char            *psz_location = NULL;
@@ -220,7 +220,7 @@ int E_(MMSHOpen)( access_t *p_access )
 /*****************************************************************************
  * Close: free unused data structures
  *****************************************************************************/
-void E_( MMSHClose )( access_t *p_access )
+void  MMSHClose ( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -472,13 +472,13 @@ static int Reset( access_t *p_access )
     if( p_sys->i_header <= 0 )
         return VLC_EGENERIC;
 
-    E_( asf_HeaderParse )( &p_sys->asfh,
+     asf_HeaderParse ( &p_sys->asfh,
                            p_sys->p_header, p_sys->i_header );
     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
              p_sys->asfh.i_data_packets_count,
              p_sys->asfh.i_min_data_packet_size );
 
-    E_( asf_StreamSelect)( &p_sys->asfh,
+     asf_StreamSelect( &p_sys->asfh,
                            var_CreateGetInteger( p_access, "mms-maxbitrate" ),
                            var_CreateGetInteger( p_access, "mms-all" ),
                            var_CreateGetInteger( p_access, "audio" ),
@@ -574,7 +574,7 @@ static int Describe( access_t  *p_access, char **ppsz_location )
     p_sys->i_packet_used = 0;
     p_sys->i_packet_length = 0;
     p_sys->p_packet = NULL;
-    E_( GenerateGuid )( &p_sys->guid );
+     GenerateGuid ( &p_sys->guid );
 
     if( OpenConnection( p_access ) )
         return VLC_EGENERIC;
@@ -703,13 +703,13 @@ static int Describe( access_t  *p_access, char **ppsz_location )
      *
      * TODO : stream bitrates properties(optional)
      *        and bitrate mutual exclusion(optional) */
-    E_( asf_HeaderParse )( &p_sys->asfh,
+     asf_HeaderParse ( &p_sys->asfh,
                            p_sys->p_header, p_sys->i_header );
     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
              p_sys->asfh.i_data_packets_count,
              p_sys->asfh.i_min_data_packet_size );
 
-    E_( asf_StreamSelect)( &p_sys->asfh,
+     asf_StreamSelect( &p_sys->asfh,
                            var_CreateGetInteger( p_access, "mms-maxbitrate" ),
                            var_CreateGetInteger( p_access, "mms-all" ),
                            var_CreateGetInteger( p_access, "audio" ),
index 4771166..6edd89f 100644 (file)
@@ -71,8 +71,8 @@
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int  E_( MMSTUOpen )  ( access_t * );
-void E_( MMSTUClose ) ( access_t * );
+int   MMSTUOpen   ( access_t * );
+void  MMSTUClose  ( access_t * );
 
 
 static ssize_t Read( access_t *, uint8_t *, size_t );
@@ -93,7 +93,7 @@ static int  mms_HeaderMediaRead( access_t *, int );
 static int  mms_ReceivePacket( access_t * );
 
 
-int  E_(MMSTUOpen)( access_t *p_access )
+int  MMSTUOpen( access_t *p_access )
 {
     access_sys_t   *p_sys;
     int             i_proto;
@@ -193,7 +193,7 @@ int  E_(MMSTUOpen)( access_t *p_access )
     if( MMSStart( p_access, 0xffffffff ) < 0 )
     {
         msg_Err( p_access, "cannot start stream" );
-        E_(MMSTUClose) ( p_access );
+        MMSTUClose ( p_access );
         return VLC_EGENERIC;
     }
     return VLC_SUCCESS;
@@ -202,7 +202,7 @@ int  E_(MMSTUOpen)( access_t *p_access )
 /*****************************************************************************
  * Close: free unused data structures
  *****************************************************************************/
-void E_(MMSTUClose)( access_t *p_access )
+void MMSTUClose( access_t *p_access )
 {
     access_sys_t *p_sys = p_access->p_sys;
 
@@ -499,7 +499,7 @@ static int MMSOpen( access_t  *p_access, vlc_url_t *p_url, int  i_proto )
     }
 
     /* *** Init context for mms prototcol *** */
-    E_( GenerateGuid )( &p_sys->guid );    /* used to identify client by server */
+     GenerateGuid ( &p_sys->guid );    /* used to identify client by server */
     msg_Dbg( p_access,
              "generated guid: "GUID_FMT,
              GUID_PRINT( p_sys->guid ) );
@@ -754,9 +754,9 @@ static int MMSOpen( access_t  *p_access, vlc_url_t *p_url, int  i_proto )
      *
      * TODO : stream bitrates properties(optional)
      *        and bitrate mutual exclusion(optional) */
-    E_( asf_HeaderParse )( &p_sys->asfh,
+     asf_HeaderParse ( &p_sys->asfh,
                            p_sys->p_header, p_sys->i_header );
-    E_( asf_StreamSelect)( &p_sys->asfh,
+     asf_StreamSelect( &p_sys->asfh,
                            var_CreateGetInteger( p_access, "mms-maxbitrate" ),
                            var_CreateGetInteger( p_access, "mms-all" ),
                            var_CreateGetInteger( p_access, "audio" ),
index a0497ad..c7c62e2 100644 (file)
@@ -74,7 +74,7 @@ struct demux_sys_t
 /*****************************************************************************
  * VCDInit: initializes structures
  *****************************************************************************/
-int E_(VCDInit) ( vlc_object_t *p_this )
+int VCDInit ( vlc_object_t *p_this )
 {
     input_thread_t *p_input = (input_thread_t *)p_this;
     vcd_data_t *    p_vcd = (vcd_data_t *)p_input->p_sys;
@@ -117,7 +117,7 @@ int E_(VCDInit) ( vlc_object_t *p_this )
 /*****************************************************************************
  * VCDEnd: frees unused data
  *****************************************************************************/
-void E_(VCDEnd) ( vlc_object_t *p_this )
+void VCDEnd ( vlc_object_t *p_this )
 {
     input_thread_t *p_input = (input_thread_t *)p_this;
     vcd_data_t *    p_vcd = p_input->p_demux_data->p_vcd;
index 8b639ef..ec54f71 100644 (file)
@@ -44,14 +44,14 @@ int  VCDOpen       ( vlc_object_t * );
 void VCDClose      ( vlc_object_t * );
 int  VCDOpenIntf   ( vlc_object_t * );
 void VCDCloseIntf  ( vlc_object_t * );
-int  E_(VCDInit)   ( vlc_object_t * );
-void E_(VCDEnd)    ( vlc_object_t * );
+int  VCDInit   ( vlc_object_t * );
+void VCDEnd    ( vlc_object_t * );
 
-int  E_(DebugCallback) ( vlc_object_t *p_this, const char *psz_name,
+int  DebugCallback ( vlc_object_t *p_this, const char *psz_name,
                          vlc_value_t oldval, vlc_value_t val,
                          void *p_data );
 
-int  E_(BlocksPerReadCallback) ( vlc_object_t *p_this, const char *psz_name,
+int  BlocksPerReadCallback ( vlc_object_t *p_this, const char *psz_name,
                  vlc_value_t oldval, vlc_value_t val,
                  void *p_data );
 
index 90e788f..fbf48aa 100644 (file)
@@ -63,8 +63,8 @@ static void          ParseText     ( decoder_t *, block_t * );
 /*****************************************************************************
  * Exported prototypes
  *****************************************************************************/
-int  E_(OpenIntf)  ( vlc_object_t * );
-void E_(CloseIntf) ( vlc_object_t * );
+int  OpenIntf  ( vlc_object_t * );
+void CloseIntf ( vlc_object_t * );
 
 /*****************************************************************************
  * Module descriptor.
@@ -77,7 +77,7 @@ vlc_module_begin();
 
     add_submodule();
         set_capability( "interface", 0 );
-        set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+        set_callbacks( OpenIntf, CloseIntf );
 vlc_module_end();
 
 /*****************************************************************************
index 2f25362..6ca85e0 100644 (file)
@@ -79,8 +79,8 @@ struct navigation_history_t
  * Local prototypes.
  *****************************************************************************/
 
-int          E_(OpenIntf)               ( vlc_object_t * );
-void         E_(CloseIntf)              ( vlc_object_t * );
+int          OpenIntf               ( vlc_object_t * );
+void         CloseIntf              ( vlc_object_t * );
 
 static int   InitThread                 ( intf_thread_t * );
 static int   MouseEvent                 ( vlc_object_t *, char const *,
@@ -114,7 +114,7 @@ static void RunIntf        ( intf_thread_t *p_intf );
 /*****************************************************************************
  * OpenIntf: initialize CMML interface
  *****************************************************************************/
-int E_(OpenIntf) ( vlc_object_t *p_this )
+int OpenIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 
@@ -146,7 +146,7 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseIntf: destroy dummy interface
  *****************************************************************************/
-void E_(CloseIntf) ( vlc_object_t *p_this )
+void CloseIntf ( vlc_object_t *p_this )
 {
     intf_thread_t * p_intf = (intf_thread_t *)p_this;
     vout_thread_t * p_vout;
index ef48be5..4065c29 100644 (file)
@@ -91,7 +91,7 @@ struct decoder_sys_t
  *****************************************************************************
  * The ffmpeg codec will be opened, some memory allocated.
  *****************************************************************************/
-int E_(InitAudioDec)( decoder_t *p_dec, AVCodecContext *p_context,
+int InitAudioDec( decoder_t *p_dec, AVCodecContext *p_context,
                       AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
 {
     decoder_sys_t *p_sys;
@@ -221,7 +221,7 @@ static aout_buffer_t *SplitBuffer( decoder_t *p_dec )
 /*****************************************************************************
  * DecodeAudio: Called to decode one frame
  *****************************************************************************/
-aout_buffer_t *E_( DecodeAudio )( decoder_t *p_dec, block_t **pp_block )
+aout_buffer_t * DecodeAudio ( decoder_t *p_dec, block_t **pp_block )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
     int i_used, i_output;
@@ -352,7 +352,7 @@ aout_buffer_t *E_( DecodeAudio )( decoder_t *p_dec, block_t **pp_block )
 /*****************************************************************************
  * EndAudioDec: audio decoder destruction
  *****************************************************************************/
-void E_(EndAudioDec)( decoder_t *p_dec )
+void EndAudioDec( decoder_t *p_dec )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
 
index 7bdfb25..daaf4a0 100644 (file)
@@ -48,7 +48,7 @@
 #include "ffmpeg.h"
 
 #if !defined(HAVE_LIBSWSCALE_SWSCALE_H)  && !defined(HAVE_FFMPEG_SWSCALE_H) && !defined(HAVE_LIBSWSCALE_TREE)
-void E_(InitLibavcodec) ( vlc_object_t *p_object );
+void InitLibavcodec ( vlc_object_t *p_object );
 static void ChromaConversion( vout_thread_t *, picture_t *, picture_t * );
 
 /*****************************************************************************
@@ -72,7 +72,7 @@ struct chroma_sys_t
  *****************************************************************************
  * This function allocates and initializes a chroma function
  *****************************************************************************/
-int E_(OpenChroma)( vlc_object_t *p_this )
+int OpenChroma( vlc_object_t *p_this )
 {
     vout_thread_t *p_vout = (vout_thread_t *)p_this;
     int i_ffmpeg_chroma[2], i_vlc_chroma[2], i;
@@ -84,7 +84,7 @@ int E_(OpenChroma)( vlc_object_t *p_this )
     i_vlc_chroma[1] = p_vout->output.i_chroma;
     for( i = 0; i < 2; i++ )
     {
-        i_ffmpeg_chroma[i] = E_(GetFfmpegChroma)( i_vlc_chroma[i] );
+        i_ffmpeg_chroma[i] = GetFfmpegChroma( i_vlc_chroma[i] );
         if( i_ffmpeg_chroma[i] < 0 ) return VLC_EGENERIC;
     }
 
@@ -121,7 +121,7 @@ int E_(OpenChroma)( vlc_object_t *p_this )
     }
 
     /* libavcodec needs to be initialized for some chroma conversions */
-    E_(InitLibavcodec)(p_this);
+    InitLibavcodec(p_this);
 
     return VLC_SUCCESS;
 }
@@ -189,7 +189,7 @@ static void ChromaConversion( vout_thread_t *p_vout,
  *****************************************************************************
  * This function frees the previously allocated chroma function
  *****************************************************************************/
-void E_(CloseChroma)( vlc_object_t *p_this )
+void CloseChroma( vlc_object_t *p_this )
 {
     vout_thread_t *p_vout = (vout_thread_t *)p_this;
     if( p_vout->chroma.p_sys->p_rsc )
@@ -262,7 +262,7 @@ static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
  *****************************************************************************
  * This function allocates and initializes a chroma function
  *****************************************************************************/
-int E_(OpenChroma)( vlc_object_t *p_this )
+int OpenChroma( vlc_object_t *p_this )
 {
     vout_thread_t *p_vout = (vout_thread_t *)p_this;
     chroma_sys_t  *p_sys = p_vout->chroma.p_sys;
@@ -348,7 +348,7 @@ static void ChromaConversion( vout_thread_t *p_vout,
  *****************************************************************************
  * This function frees the previously allocated chroma function
  *****************************************************************************/
-void E_(CloseChroma)( vlc_object_t *p_this )
+void CloseChroma( vlc_object_t *p_this )
 {
     vout_thread_t *p_vout = (vout_thread_t *)p_this;
     chroma_sys_t  *p_sys  = (chroma_sys_t *)p_vout->chroma.p_sys;
index 765fb72..bb842c2 100644 (file)
@@ -68,13 +68,13 @@ struct filter_sys_t
 /*****************************************************************************
  * OpenDeinterlace: probe the filter and return score
  *****************************************************************************/
-int E_(OpenDeinterlace)( vlc_object_t *p_this )
+int OpenDeinterlace( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t*)p_this;
     filter_sys_t *p_sys;
 
     /* Check if we can handle that formats */
-    if( E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma ) < 0 )
+    if( GetFfmpegChroma( p_filter->fmt_in.video.i_chroma ) < 0 )
     {
         return VLC_EGENERIC;
     }
@@ -89,13 +89,13 @@ int E_(OpenDeinterlace)( vlc_object_t *p_this )
 
     /* Misc init */
     p_sys->i_src_ffmpeg_chroma =
-        E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma );
+        GetFfmpegChroma( p_filter->fmt_in.video.i_chroma );
     p_filter->pf_video_filter = Deinterlace;
 
     msg_Dbg( p_filter, "deinterlacing" );
 
     /* libavcodec needs to be initialized for some chroma conversions */
-    E_(InitLibavcodec)(p_this);
+    InitLibavcodec(p_this);
 
     return VLC_SUCCESS;
 }
@@ -103,7 +103,7 @@ int E_(OpenDeinterlace)( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseDeinterlace: clean up the filter
  *****************************************************************************/
-void E_(CloseDeinterlace)( vlc_object_t *p_this )
+void CloseDeinterlace( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t*)p_this;
     filter_sys_t *p_sys = p_filter->p_sys;
index 29957c8..141b660 100644 (file)
@@ -85,7 +85,7 @@ static offset_t IOSeek( void *opaque, offset_t offset, int whence );
 /*****************************************************************************
  * Open
  *****************************************************************************/
-int E_(OpenDemux)( vlc_object_t *p_this )
+int OpenDemux( vlc_object_t *p_this )
 {
     demux_t       *p_demux = (demux_t*)p_this;
     demux_sys_t   *p_sys;
@@ -181,7 +181,7 @@ int E_(OpenDemux)( vlc_object_t *p_this )
     {
         msg_Err( p_demux, "av_open_input_stream failed" );
         if( !b_avfmt_nofile ) p_sys->fmt->flags ^= AVFMT_NOFILE;
-        E_(CloseDemux)( p_this );
+        CloseDemux( p_this );
         return VLC_EGENERIC;
     }
 
@@ -189,7 +189,7 @@ int E_(OpenDemux)( vlc_object_t *p_this )
     {
         msg_Err( p_demux, "av_find_stream_info failed" );
         if( !b_avfmt_nofile ) p_sys->fmt->flags ^= AVFMT_NOFILE;
-        E_(CloseDemux)( p_this );
+        CloseDemux( p_this );
         return VLC_EGENERIC;
     }
     if( !b_avfmt_nofile ) p_sys->fmt->flags ^= AVFMT_NOFILE;
@@ -201,7 +201,7 @@ int E_(OpenDemux)( vlc_object_t *p_this )
         es_format_t  fmt;
         vlc_fourcc_t fcc;
 
-        if( !E_(GetVlcFourcc)( cc->codec_id, NULL, &fcc, NULL ) )
+        if( !GetVlcFourcc( cc->codec_id, NULL, &fcc, NULL ) )
         {
             fcc = VLC_FOURCC( 'u', 'n', 'd', 'f' );
 
@@ -209,7 +209,7 @@ int E_(OpenDemux)( vlc_object_t *p_this )
             if( cc->codec_id == CODEC_ID_RAWVIDEO )
             {
                 msg_Dbg( p_demux, "raw video, pixel format: %i", cc->pix_fmt );
-                fcc = E_(GetVlcChroma)( cc->pix_fmt );
+                fcc = GetVlcChroma( cc->pix_fmt );
             }
         }
 
@@ -267,7 +267,7 @@ int E_(OpenDemux)( vlc_object_t *p_this )
 /*****************************************************************************
  * Close
  *****************************************************************************/
-void E_(CloseDemux)( vlc_object_t *p_this )
+void CloseDemux( vlc_object_t *p_this )
 {
     demux_t     *p_demux = (demux_t*)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index da4d52f..b3b3ed7 100644 (file)
@@ -60,8 +60,8 @@
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int  E_(OpenEncoder) ( vlc_object_t * );
-void E_(CloseEncoder)( vlc_object_t * );
+int  OpenEncoder ( vlc_object_t * );
+void CloseEncoder( vlc_object_t * );
 
 static block_t *EncodeVideo( encoder_t *, picture_t * );
 static block_t *EncodeAudio( encoder_t *, aout_buffer_t * );
@@ -197,7 +197,7 @@ static const uint16_t mpeg4_default_non_intra_matrix[64] = {
  * OpenEncoder: probe the encoder
  *****************************************************************************/
 
-int E_(OpenEncoder)( vlc_object_t *p_this )
+int OpenEncoder( vlc_object_t *p_this )
 {
     encoder_t *p_enc = (encoder_t *)p_this;
     encoder_sys_t *p_sys = p_enc->p_sys;
@@ -207,10 +207,10 @@ int E_(OpenEncoder)( vlc_object_t *p_this )
     const char *psz_namecodec;
     vlc_value_t val;
 
-    if( !E_(GetFfmpegCodec)( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
+    if( !GetFfmpegCodec( p_enc->fmt_out.i_codec, &i_cat, &i_codec_id,
                              &psz_namecodec ) )
     {
-        if( E_(GetFfmpegChroma)( p_enc->fmt_out.i_codec ) < 0 )
+        if( GetFfmpegChroma( p_enc->fmt_out.i_codec ) < 0 )
         {
             /* handed chroma output */
             return VLC_EGENERIC;
@@ -237,7 +237,7 @@ int E_(OpenEncoder)( vlc_object_t *p_this )
     }
 
     /* Initialization must be done before avcodec_find_encoder() */
-    E_(InitLibavcodec)(p_this);
+    InitLibavcodec(p_this);
 
     p_codec = avcodec_find_encoder( i_codec_id );
     if( !p_codec )
@@ -459,7 +459,7 @@ int E_(OpenEncoder)( vlc_object_t *p_this )
         p_sys->p_buffer_out = malloc( p_context->height * p_context->width * 3 );
 
         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
-        p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
+        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
         if( p_codec->pix_fmts )
         {
             const enum PixelFormat *p = p_codec->pix_fmts;
@@ -468,7 +468,7 @@ int E_(OpenEncoder)( vlc_object_t *p_this )
                 if( *p == p_context->pix_fmt ) break;
             }
             if( *p == -1 ) p_context->pix_fmt = p_codec->pix_fmts[0];
-            p_enc->fmt_in.i_codec = E_(GetVlcChroma)( p_context->pix_fmt );
+            p_enc->fmt_in.i_codec = GetVlcChroma( p_context->pix_fmt );
         }
 
         if ( p_sys->b_strict_rc )
@@ -588,7 +588,7 @@ int E_(OpenEncoder)( vlc_object_t *p_this )
     {
         /* XXX: hack: Force same codec (will be handled by transcode) */
         p_enc->fmt_in.i_codec = p_enc->fmt_out.i_codec;
-        p_context->pix_fmt = E_(GetFfmpegChroma)( p_enc->fmt_in.i_codec );
+        p_context->pix_fmt = GetFfmpegChroma( p_enc->fmt_in.i_codec );
     }
 
     /* Make sure we get extradata filled by the encoder */
@@ -1064,7 +1064,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_aout_buf )
 /*****************************************************************************
  * CloseEncoder: ffmpeg encoder destruction
  *****************************************************************************/
-void E_(CloseEncoder)( vlc_object_t *p_this )
+void CloseEncoder( vlc_object_t *p_this )
 {
     encoder_t *p_enc = (encoder_t *)p_this;
     encoder_sys_t *p_sys = p_enc->p_sys;
index 9244d78..02f91d1 100644 (file)
@@ -148,7 +148,7 @@ vlc_module_begin();
     set_section( N_("Encoding") , NULL );
     set_description( _("FFmpeg audio/video encoder") );
     set_capability( "encoder", 100 );
-    set_callbacks( E_(OpenEncoder), E_(CloseEncoder) );
+    set_callbacks( OpenEncoder, CloseEncoder );
 
     add_string( ENC_CFG_PREFIX "hq", "simple", NULL, ENC_HQ_TEXT,
                 ENC_HQ_LONGTEXT, false );
@@ -215,7 +215,7 @@ vlc_module_begin();
     add_submodule();
     set_description( _("FFmpeg demuxer" ) );
     set_capability( "demux", 2 );
-    set_callbacks( E_(OpenDemux), E_(CloseDemux) );
+    set_callbacks( OpenDemux, CloseDemux );
 
 #ifdef ENABLE_SOUT
     /* mux submodule */
@@ -224,7 +224,7 @@ vlc_module_begin();
     set_capability( "sout mux", 2 );
     add_string( "ffmpeg-mux", NULL, NULL, MUX_TEXT,
                 MUX_LONGTEXT, true );
-    set_callbacks( E_(OpenMux), E_(CloseMux) );
+    set_callbacks( OpenMux, CloseMux );
 #endif
 #endif
 
@@ -235,7 +235,7 @@ vlc_module_begin();
     set_capability( "video filter2", 1000 );
     set_category( CAT_VIDEO );
     set_subcategory( SUBCAT_VIDEO_VFILTER );
-    set_callbacks( E_(OpenScaler), E_(CloseScaler) );
+    set_callbacks( OpenScaler, CloseScaler );
     add_integer( "swscale-mode", 0, NULL, SCALEMODE_TEXT, SCALEMODE_LONGTEXT, true );
         change_integer_list( pi_mode_values, ppsz_mode_descriptions, 0 );
 
@@ -243,26 +243,26 @@ vlc_module_begin();
     /* video filter submodule */
     add_submodule();
     set_capability( "video filter2", 50 );
-    set_callbacks( E_(OpenFilter), E_(CloseFilter) );
+    set_callbacks( OpenFilter, CloseFilter );
     set_description( _("FFmpeg video filter") );
 
     /* crop/padd submodule */
     add_submodule();
     set_capability( "crop padd", 10 );
-    set_callbacks( E_(OpenCropPadd), E_(CloseFilter) );
+    set_callbacks( OpenCropPadd, CloseFilter );
     set_description( _("FFmpeg crop padd filter") );
 #endif
 
     /* chroma conversion submodule */
     add_submodule();
     set_capability( "chroma", 50 );
-    set_callbacks( E_(OpenChroma), E_(CloseChroma) );
+    set_callbacks( OpenChroma, CloseChroma );
     set_description( _("FFmpeg chroma conversion") );
 
     /* video filter submodule */
     add_submodule();
     set_capability( "video filter2", 0 );
-    set_callbacks( E_(OpenDeinterlace), E_(CloseDeinterlace) );
+    set_callbacks( OpenDeinterlace, CloseDeinterlace );
     set_description( _("FFmpeg deinterlace video filter") );
     add_shortcut( "ffmpeg-deinterlace" );
 
@@ -281,7 +281,7 @@ static int OpenDecoder( vlc_object_t *p_this )
     AVCodec        *p_codec = NULL;
 
     /* *** determine codec type *** */
-    if( !E_(GetFfmpegCodec)( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id,
+    if( !GetFfmpegCodec( p_dec->fmt_in.i_codec, &i_cat, &i_codec_id,
                              &psz_namecodec ) )
     {
         return VLC_EGENERIC;
@@ -296,7 +296,7 @@ static int OpenDecoder( vlc_object_t *p_this )
     }
 
     /* Initialization must be done before avcodec_find_decoder() */
-    E_(InitLibavcodec)(p_this);
+    InitLibavcodec(p_this);
 
     /* *** ask ffmpeg for a decoder *** */
     p_codec = avcodec_find_decoder( i_codec_id );
@@ -341,13 +341,13 @@ static int OpenDecoder( vlc_object_t *p_this )
     switch( i_cat )
     {
     case VIDEO_ES:
-        p_dec->pf_decode_video = E_(DecodeVideo);
-        i_result = E_( InitVideoDec )( p_dec, p_context, p_codec,
+        p_dec->pf_decode_video = DecodeVideo;
+        i_result =  InitVideoDec ( p_dec, p_context, p_codec,
                                        i_codec_id, psz_namecodec );
         break;
     case AUDIO_ES:
-        p_dec->pf_decode_audio = E_(DecodeAudio);
-        i_result = E_( InitAudioDec )( p_dec, p_context, p_codec,
+        p_dec->pf_decode_audio = DecodeAudio;
+        i_result =  InitAudioDec ( p_dec, p_context, p_codec,
                                        i_codec_id, psz_namecodec );
         break;
     default:
@@ -370,10 +370,10 @@ static void CloseDecoder( vlc_object_t *p_this )
     switch( p_sys->i_cat )
     {
     case AUDIO_ES:
-        E_( EndAudioDec )( p_dec );
+         EndAudioDec ( p_dec );
         break;
     case VIDEO_ES:
-        E_( EndVideoDec )( p_dec );
+         EndVideoDec ( p_dec );
         break;
     }
 
@@ -398,7 +398,7 @@ static void CloseDecoder( vlc_object_t *p_this )
 /*****************************************************************************
  *
  *****************************************************************************/
-void E_(LibavcodecCallback)( void *p_opaque, int i_level,
+void LibavcodecCallback( void *p_opaque, int i_level,
                              const char *psz_format, va_list va )
 {
     int i_vlc_level;
@@ -452,7 +452,7 @@ void E_(LibavcodecCallback)( void *p_opaque, int i_level,
     free( psz_new_format );
 }
 
-void E_(InitLibavcodec)( vlc_object_t *p_object )
+void InitLibavcodec( vlc_object_t *p_object )
 {
     static int b_ffmpeginit = 0;
     vlc_mutex_t *lock = var_AcquireMutex( "avcodec" );
@@ -462,7 +462,7 @@ void E_(InitLibavcodec)( vlc_object_t *p_object )
     {
         avcodec_init();
         avcodec_register_all();
-        av_log_set_callback( E_(LibavcodecCallback) );
+        av_log_set_callback( LibavcodecCallback );
         b_ffmpeginit = 1;
 
         msg_Dbg( p_object, "libavcodec initialized (interface %d )",
@@ -528,7 +528,7 @@ static struct
     { 0, 0 }
 };
 
-int E_(GetFfmpegChroma)( vlc_fourcc_t i_chroma )
+int GetFfmpegChroma( vlc_fourcc_t i_chroma )
 {
     int i;
 
@@ -540,7 +540,7 @@ int E_(GetFfmpegChroma)( vlc_fourcc_t i_chroma )
     return -1;
 }
 
-vlc_fourcc_t E_(GetVlcChroma)( int i_ffmpeg_chroma )
+vlc_fourcc_t GetVlcChroma( int i_ffmpeg_chroma )
 {
     int i;
 
@@ -1541,7 +1541,7 @@ static struct
     { 0, 0, 0, 0 }
 };
 
-int E_(GetFfmpegCodec)( vlc_fourcc_t i_fourcc, int *pi_cat,
+int GetFfmpegCodec( vlc_fourcc_t i_fourcc, int *pi_cat,
                         int *pi_ffmpeg_codec, const char **ppsz_name )
 {
     int i;
@@ -1560,7 +1560,7 @@ int E_(GetFfmpegCodec)( vlc_fourcc_t i_fourcc, int *pi_cat,
     return false;
 }
 
-int E_(GetVlcFourcc)( int i_ffmpeg_codec, int *pi_cat,
+int GetVlcFourcc( int i_ffmpeg_codec, int *pi_cat,
                       vlc_fourcc_t *pi_fourcc, const char **ppsz_name )
 {
     int i;
index c9677e9..0f5ed00 100644 (file)
@@ -28,60 +28,60 @@ struct AVFrame;
 struct AVCodecContext;
 struct AVCodec;
 
-void E_(InitLibavcodec)( vlc_object_t * );
-void E_(LibavcodecCallback)( void *p_opaque, int i_level,
+void InitLibavcodec( vlc_object_t * );
+void LibavcodecCallback( void *p_opaque, int i_level,
                              const char *psz_format, va_list va );
-int E_(GetFfmpegCodec) ( vlc_fourcc_t, int *, int *, const char ** );
-int E_(GetVlcFourcc)   ( int, int *, vlc_fourcc_t *, const char ** );
-int E_(GetFfmpegChroma)( vlc_fourcc_t );
-vlc_fourcc_t E_(GetVlcChroma)( int );
+int GetFfmpegCodec ( vlc_fourcc_t, int *, int *, const char ** );
+int GetVlcFourcc   ( int, int *, vlc_fourcc_t *, const char ** );
+int GetFfmpegChroma( vlc_fourcc_t );
+vlc_fourcc_t GetVlcChroma( int );
 
 /* Video decoder module */
-int  E_( InitVideoDec )( decoder_t *, struct AVCodecContext *, struct AVCodec *,
+int   InitVideoDec ( decoder_t *, struct AVCodecContext *, struct AVCodec *,
                          int, const char * );
-void E_( EndVideoDec ) ( decoder_t * );
-picture_t *E_( DecodeVideo ) ( decoder_t *, block_t ** );
+void  EndVideoDec  ( decoder_t * );
+picture_t * DecodeVideo  ( decoder_t *, block_t ** );
 
 /* Audio decoder module */
-int  E_( InitAudioDec )( decoder_t *, struct AVCodecContext *, struct AVCodec *,
+int   InitAudioDec ( decoder_t *, struct AVCodecContext *, struct AVCodec *,
                          int, const char * );
-void E_( EndAudioDec ) ( decoder_t * );
-aout_buffer_t *E_( DecodeAudio ) ( decoder_t *, block_t ** );
+void  EndAudioDec  ( decoder_t * );
+aout_buffer_t * DecodeAudio  ( decoder_t *, block_t ** );
 
 /* Chroma conversion module */
-int  E_(OpenChroma)( vlc_object_t * );
-void E_(CloseChroma)( vlc_object_t * );
+int  OpenChroma( vlc_object_t * );
+void CloseChroma( vlc_object_t * );
 
 /* Video encoder module */
-int  E_(OpenEncoder) ( vlc_object_t * );
-void E_(CloseEncoder)( vlc_object_t * );
+int  OpenEncoder ( vlc_object_t * );
+void CloseEncoder( vlc_object_t * );
 
 /* Audio encoder module */
-int  E_(OpenAudioEncoder) ( vlc_object_t * );
-void E_(CloseAudioEncoder)( vlc_object_t * );
+int  OpenAudioEncoder ( vlc_object_t * );
+void CloseAudioEncoder( vlc_object_t * );
 
 /* Demux module */
-int  E_(OpenDemux) ( vlc_object_t * );
-void E_(CloseDemux)( vlc_object_t * );
+int  OpenDemux ( vlc_object_t * );
+void CloseDemux( vlc_object_t * );
 
 /* Mux module */
-int  E_(OpenMux) ( vlc_object_t * );
-void E_(CloseMux)( vlc_object_t * );
+int  OpenMux ( vlc_object_t * );
+void CloseMux( vlc_object_t * );
 
 /* Video filter module */
-int  E_(OpenFilter)( vlc_object_t * );
-int  E_(OpenCropPadd)( vlc_object_t * );
-void E_(CloseFilter)( vlc_object_t * );
-int  E_(OpenDeinterlace)( vlc_object_t * );
-void E_(CloseDeinterlace)( vlc_object_t * );
-int  E_(OpenScaler)( vlc_object_t * );
-void E_(CloseScaler)( vlc_object_t * );
+int  OpenFilter( vlc_object_t * );
+int  OpenCropPadd( vlc_object_t * );
+void CloseFilter( vlc_object_t * );
+int  OpenDeinterlace( vlc_object_t * );
+void CloseDeinterlace( vlc_object_t * );
+int  OpenScaler( vlc_object_t * );
+void CloseScaler( vlc_object_t * );
 
 /* Postprocessing module */
-void *E_(OpenPostproc)( decoder_t *, bool * );
-int E_(InitPostproc)( void *, int, int, int );
-int E_(PostprocPict)( void *, picture_t *, struct AVFrame * );
-void E_(ClosePostproc)( decoder_t *, void * );
+void *OpenPostproc( decoder_t *, bool * );
+int InitPostproc( void *, int, int, int );
+int PostprocPict( void *, picture_t *, struct AVFrame * );
+void ClosePostproc( decoder_t *, void * );
 
 /*****************************************************************************
  * Module descriptor help strings
index 6882402..7ba7229 100644 (file)
@@ -86,7 +86,7 @@ static offset_t IOSeek( void *opaque, offset_t offset, int whence );
 /*****************************************************************************
  * Open
  *****************************************************************************/
-int E_(OpenMux)( vlc_object_t *p_this )
+int OpenMux( vlc_object_t *p_this )
 {
     AVOutputFormat *file_oformat;
     sout_mux_t *p_mux = (sout_mux_t*)p_this;
@@ -96,7 +96,7 @@ int E_(OpenMux)( vlc_object_t *p_this )
 
     /* Should we call it only once ? */
     av_register_all();
-    av_log_set_callback( E_(LibavcodecCallback) );
+    av_log_set_callback( LibavcodecCallback );
 
     config_ChainParse( p_mux, "ffmpeg-", ppsz_mux_options, p_mux->p_cfg );
 
@@ -171,7 +171,7 @@ int E_(OpenMux)( vlc_object_t *p_this )
 /*****************************************************************************
  * Close
  *****************************************************************************/
-void E_(CloseMux)( vlc_object_t *p_this )
+void CloseMux( vlc_object_t *p_this )
 {
     sout_mux_t *p_mux = (sout_mux_t*)p_this;
     sout_mux_sys_t *p_sys = p_mux->p_sys;
@@ -207,7 +207,7 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
 
     msg_Dbg( p_mux, "adding input" );
 
-    if( !E_(GetFfmpegCodec)( p_input->p_fmt->i_codec, 0, &i_codec_id, 0 ) )
+    if( !GetFfmpegCodec( p_input->p_fmt->i_codec, 0, &i_codec_id, 0 ) )
     {
         msg_Dbg( p_mux, "couldn't find codec for fourcc '%4.4s'",
                  (char *)&p_input->p_fmt->i_codec );
index 8d994ee..832b78a 100644 (file)
@@ -72,7 +72,7 @@ static int PPQCallback( vlc_object_t *p_this, char const *psz_cmd,
 /*****************************************************************************
  * OpenPostproc: probe and open the postproc
  *****************************************************************************/
-void *E_(OpenPostproc)( decoder_t *p_dec, bool *pb_pp )
+void *OpenPostproc( decoder_t *p_dec, bool *pb_pp )
 {
     video_postproc_sys_t *p_sys;
     vlc_value_t val, val_orig, text;
@@ -124,7 +124,7 @@ void *E_(OpenPostproc)( decoder_t *p_dec, bool *pb_pp )
 /*****************************************************************************
  * InitPostproc:
  *****************************************************************************/
-int E_(InitPostproc)( void *p_data, int i_width, int i_height, int pix_fmt )
+int InitPostproc( void *p_data, int i_width, int i_height, int pix_fmt )
 {
     video_postproc_sys_t *p_sys = (video_postproc_sys_t *)p_data;
     unsigned i_cpu = vlc_CPU();
@@ -174,7 +174,7 @@ int E_(InitPostproc)( void *p_data, int i_width, int i_height, int pix_fmt )
 /*****************************************************************************
  * PostprocPict:
  *****************************************************************************/
-int E_(PostprocPict)( void *p_data, picture_t *p_pic, AVFrame *p_ff_pic )
+int PostprocPict( void *p_data, picture_t *p_pic, AVFrame *p_ff_pic )
 {
     video_postproc_sys_t *p_sys = (video_postproc_sys_t *)p_data;
 
@@ -202,7 +202,7 @@ int E_(PostprocPict)( void *p_data, picture_t *p_pic, AVFrame *p_ff_pic )
 /*****************************************************************************
  * ClosePostproc:
  *****************************************************************************/
-void E_(ClosePostproc)( decoder_t *p_dec, void *p_data )
+void ClosePostproc( decoder_t *p_dec, void *p_data )
 {
     video_postproc_sys_t *p_sys = (video_postproc_sys_t *)p_data;
 
index 343a979..3fe061e 100644 (file)
@@ -85,7 +85,7 @@ static const char *ppsz_mode_descriptions[] =
 /*****************************************************************************
  * OpenScaler: probe the filter and return score
  *****************************************************************************/
-int E_(OpenScaler)( vlc_object_t *p_this )
+int OpenScaler( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t*)p_this;
     filter_sys_t *p_sys;
@@ -101,10 +101,10 @@ int E_(OpenScaler)( vlc_object_t *p_this )
 
     /* Supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR24,
      * BGR16, BGR15, RGB32, RGB24, Y8/Y800, YVU9/IF09 */
-    i_fmt_in = E_(GetFfmpegChroma)(p_filter->fmt_in.video.i_chroma);
+    i_fmt_in = GetFfmpegChroma(p_filter->fmt_in.video.i_chroma);
     /* Supported output formats: YV12, I420/IYUV, YUY2, UYVY,
      * {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09 */
-    i_fmt_out = E_(GetFfmpegChroma)(p_filter->fmt_out.video.i_chroma);
+    i_fmt_out = GetFfmpegChroma(p_filter->fmt_out.video.i_chroma);
     if( ( i_fmt_in < 0 ) || ( i_fmt_out < 0 ) )
     {
         return VLC_EGENERIC;
@@ -201,7 +201,7 @@ int E_(OpenScaler)( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseFilter: clean up the filter
  *****************************************************************************/
-void E_(CloseScaler)( vlc_object_t *p_this )
+void CloseScaler( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t*)p_this;
     filter_sys_t *p_sys = p_filter->p_sys;
@@ -225,8 +225,8 @@ static int CheckInit( filter_t *p_filter )
     {
         int i_fmt_in, i_fmt_out;
 
-        i_fmt_in = E_(GetFfmpegChroma)(p_filter->fmt_in.video.i_chroma);
-        i_fmt_out = E_(GetFfmpegChroma)(p_filter->fmt_out.video.i_chroma);
+        i_fmt_in = GetFfmpegChroma(p_filter->fmt_in.video.i_chroma);
+        i_fmt_out = GetFfmpegChroma(p_filter->fmt_out.video.i_chroma);
         if( (i_fmt_in < 0) || (i_fmt_out < 0) )
         {
             msg_Err( p_filter, "format not supported" );
@@ -320,12 +320,12 @@ static picture_t *Filter( filter_t *p_filter, picture_t *p_pic )
 
 #else /* LIBSWSCALE_VERSION_INT >= ((0<<16)+(5<<8)+0) */
 
-int E_(OpenScaler)( vlc_object_t *p_this )
+int OpenScaler( vlc_object_t *p_this )
 {
     return VLC_EGENERIC;
 }
 
-void E_(CloseScaler)( vlc_object_t *p_this )
+void CloseScaler( vlc_object_t *p_this )
 {
 }
 
index d8fd65a..23e2c9d 100644 (file)
@@ -221,7 +221,7 @@ static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
 
     if( p_sys->p_pp && p_sys->b_pp && !p_sys->b_pp_init )
     {
-        E_(InitPostproc)( p_sys->p_pp, p_context->width,
+        InitPostproc( p_sys->p_pp, p_context->width,
                           p_context->height, p_context->pix_fmt );
         p_sys->b_pp_init = true;
     }
@@ -235,7 +235,7 @@ static inline picture_t *ffmpeg_NewPictBuf( decoder_t *p_dec,
  * the ffmpeg codec will be opened, some memory allocated. The vout is not yet
  * opened (done after the first decoded frame).
  *****************************************************************************/
-int E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context,
+int InitVideoDec( decoder_t *p_dec, AVCodecContext *p_context,
                       AVCodec *p_codec, int i_codec_id, const char *psz_namecodec )
 {
     decoder_sys_t *p_sys;
@@ -361,7 +361,7 @@ int E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context,
 
     p_sys->p_pp = NULL;
     p_sys->b_pp = p_sys->b_pp_async = p_sys->b_pp_init = false;
-    p_sys->p_pp = E_(OpenPostproc)( p_dec, &p_sys->b_pp_async );
+    p_sys->p_pp = OpenPostproc( p_dec, &p_sys->b_pp_async );
 
     /* ffmpeg doesn't properly release old pictures when frames are skipped */
     //if( p_sys->b_hurry_up ) p_sys->b_direct_rendering = 0;
@@ -426,7 +426,7 @@ int E_(InitVideoDec)( decoder_t *p_dec, AVCodecContext *p_context,
 /*****************************************************************************
  * DecodeVideo: Called to decode one or more frames
  *****************************************************************************/
-picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
+picture_t *DecodeVideo( decoder_t *p_dec, block_t **pp_block )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
     int b_drawpicture;
@@ -719,12 +719,12 @@ picture_t *E_(DecodeVideo)( decoder_t *p_dec, block_t **pp_block )
  * This function is called when the thread ends after a successful
  * initialization.
  *****************************************************************************/
-void E_(EndVideoDec)( decoder_t *p_dec )
+void EndVideoDec( decoder_t *p_dec )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
 
     if( p_sys->p_ff_pic ) av_free( p_sys->p_ff_pic );
-    E_(ClosePostproc)( p_dec, p_sys->p_pp );
+    ClosePostproc( p_dec, p_sys->p_pp );
     free( p_sys->p_buffer_orig );
 }
 
@@ -820,7 +820,7 @@ static void ffmpeg_CopyPicture( decoder_t *p_dec,
         int i_src_stride, i_dst_stride;
 
         if( p_sys->p_pp && p_sys->b_pp )
-            E_(PostprocPict)( p_sys->p_pp, p_pic, p_ff_pic );
+            PostprocPict( p_sys->p_pp, p_pic, p_ff_pic );
         else
         {
             for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
index 60dc67a..955c285 100644 (file)
@@ -46,7 +46,7 @@
 #include "ffmpeg.h"
 
 #if !defined(HAVE_LIBSWSCALE_SWSCALE_H)  && !defined(HAVE_FFMPEG_SWSCALE_H) && !defined(HAVE_LIBSWSCALE_TREE)
-void E_(InitLibavcodec) ( vlc_object_t *p_object );
+void InitLibavcodec ( vlc_object_t *p_object );
 static int CheckInit( filter_t *p_filter );
 static picture_t *Process( filter_t *p_filter, picture_t *p_pic );
 
@@ -80,8 +80,8 @@ static int OpenFilterEx( vlc_object_t *p_this, bool b_enable_croppadd )
     bool b_convert, b_resize;
 
     /* Check if we can handle that formats */
-    if( E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma ) < 0 ||
-        E_(GetFfmpegChroma)( p_filter->fmt_out.video.i_chroma ) < 0 )
+    if( GetFfmpegChroma( p_filter->fmt_in.video.i_chroma ) < 0 ||
+        GetFfmpegChroma( p_filter->fmt_out.video.i_chroma ) < 0 )
     {
         return VLC_EGENERIC;
     }
@@ -124,9 +124,9 @@ static int OpenFilterEx( vlc_object_t *p_this, bool b_enable_croppadd )
     p_sys->p_rsc = NULL;
     p_sys->b_enable_croppadd = b_enable_croppadd;
     p_sys->i_src_ffmpeg_chroma =
-        E_(GetFfmpegChroma)( p_filter->fmt_in.video.i_chroma );
+        GetFfmpegChroma( p_filter->fmt_in.video.i_chroma );
     p_sys->i_dst_ffmpeg_chroma =
-        E_(GetFfmpegChroma)( p_filter->fmt_out.video.i_chroma );
+        GetFfmpegChroma( p_filter->fmt_out.video.i_chroma );
     p_filter->pf_video_filter = Process;
     es_format_Init( &p_sys->fmt_in, 0, 0 );
     es_format_Init( &p_sys->fmt_out, 0, 0 );
@@ -151,7 +151,7 @@ static int OpenFilterEx( vlc_object_t *p_this, bool b_enable_croppadd )
              (char *)&p_filter->fmt_out.video.i_chroma );
 
     /* libavcodec needs to be initialized for some chroma conversions */
-    E_(InitLibavcodec)(p_this);
+    InitLibavcodec(p_this);
 
     return VLC_SUCCESS;
 }
@@ -159,7 +159,7 @@ static int OpenFilterEx( vlc_object_t *p_this, bool b_enable_croppadd )
 /*****************************************************************************
  * OpenFilter: probe the filter and return score
  *****************************************************************************/
-int E_(OpenFilter)( vlc_object_t *p_this )
+int OpenFilter( vlc_object_t *p_this )
 {
     return OpenFilterEx( p_this, false );
 }
@@ -167,7 +167,7 @@ int E_(OpenFilter)( vlc_object_t *p_this )
 /*****************************************************************************
  * OpenCropPadd: probe the filter and return score
  *****************************************************************************/
-int E_(OpenCropPadd)( vlc_object_t *p_this )
+int OpenCropPadd( vlc_object_t *p_this )
 {
     return OpenFilterEx( p_this, true );
 }
@@ -176,7 +176,7 @@ int E_(OpenCropPadd)( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseFilter: clean up the filter
  *****************************************************************************/
-void E_(CloseFilter)( vlc_object_t *p_this )
+void CloseFilter( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t*)p_this;
     filter_sys_t *p_sys = p_filter->p_sys;
index e10dc57..ee7f4b7 100644 (file)
@@ -65,7 +65,7 @@ static inline unsigned int AddNibble( unsigned int i_code,
  * This function parses the SPU packet and, if valid, sends it to the
  * video output.
  *****************************************************************************/
-subpicture_t * E_(ParsePacket)( decoder_t *p_dec )
+subpicture_t * ParsePacket( decoder_t *p_dec )
 {
     decoder_sys_t *p_sys = p_dec->p_sys;
     subpicture_data_t *p_spu_data;
index 6ee36a5..01bdddb 100644 (file)
@@ -154,7 +154,7 @@ static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
     block_ChainRelease( p_spu_block );
 
     /* Parse and decode */
-    p_spu = E_(ParsePacket)( p_dec );
+    p_spu = ParsePacket( p_dec );
 
     /* reinit context */
     p_sys->i_spu_size = 0;
index 3d01e76..da5789e 100644 (file)
@@ -77,4 +77,4 @@ typedef struct subpicture_data_t
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-subpicture_t * E_(ParsePacket)( decoder_t * );
+subpicture_t * ParsePacket( decoder_t * );
index ec46547..9da67f3 100644 (file)
@@ -66,8 +66,8 @@ struct intf_sys_t
 #define NONE 0
 #define GESTURE( a, b, c, d ) (a | ( b << 4 ) | ( c << 8 ) | ( d << 12 ))
 
-int  E_(Open)   ( vlc_object_t * );
-void E_(Close)  ( vlc_object_t * );
+int  Open   ( vlc_object_t * );
+void Close  ( vlc_object_t * );
 static int  InitThread     ( intf_thread_t *p_intf );
 static void EndThread      ( intf_thread_t *p_intf );
 static int  MouseEvent     ( vlc_object_t *, char const *,
@@ -103,13 +103,13 @@ vlc_module_begin();
     set_description( _("Mouse gestures control interface") );
 
     set_capability( "interface", 0 );
-    set_callbacks( E_(Open), E_(Close) );
+    set_callbacks( Open, Close );
 vlc_module_end();
 
 /*****************************************************************************
  * OpenIntf: initialize interface
  *****************************************************************************/
-int E_(Open) ( vlc_object_t *p_this )
+int Open ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 
@@ -153,7 +153,7 @@ static input_thread_t * input_from_playlist ( playlist_t *p_playlist )
 /*****************************************************************************
  * CloseIntf: destroy dummy interface
  *****************************************************************************/
-void E_(Close) ( vlc_object_t *p_this )
+void Close ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 
index bf65904..1737722 100644 (file)
@@ -87,7 +87,7 @@ vlc_module_end();
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int  E_(ArtCallback)( httpd_handler_sys_t *p_args,
+int  ArtCallback( httpd_handler_sys_t *p_args,
                           httpd_handler_t *p_handler, char *_p_url,
                           uint8_t *_p_request, int i_type,
                           uint8_t *_p_in, int i_in,
@@ -185,14 +185,14 @@ static int Open( vlc_object_t *p_this )
 
             p_handler = malloc( sizeof( http_association_t ) );
             p_handler->psz_ext = strdup( psz_ext );
-            psz_options = E_(FirstWord)( psz_program, psz_program );
+            psz_options = FirstWord( psz_program, psz_program );
             p_handler->i_argc = 0;
             p_handler->ppsz_argv = NULL;
             TAB_APPEND( p_handler->i_argc, p_handler->ppsz_argv,
                         strdup( psz_program ) );
             while( psz_options != NULL && *psz_options )
             {
-                char *psz_next = E_(FirstWord)( psz_options, psz_options );
+                char *psz_next = FirstWord( psz_options, psz_options );
                 TAB_APPEND( p_handler->i_argc, p_handler->ppsz_argv,
                             strdup( psz_options ) );
                 psz_options = psz_next;
@@ -300,7 +300,7 @@ static int Open( vlc_object_t *p_this )
         psz_src[strlen( psz_src ) - 1] = '\0';
     }
 
-    E_(ParseDirectory)( p_intf, psz_src, psz_src );
+    ParseDirectory( p_intf, psz_src, psz_src );
     if( p_sys->i_files <= 0 )
     {
         msg_Err( p_intf, "cannot find any file in directory %s", psz_src );
@@ -324,7 +324,7 @@ static int Open( vlc_object_t *p_this )
         /* TODO: use ACL and login/password stuff here too */
         h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
                                          "/art", NULL, NULL, NULL,
-                                         E_(ArtCallback), h );
+                                         ArtCallback, h );
         p_sys->p_art_handler = h->p_handler;
     }
 
@@ -480,25 +480,25 @@ static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer,
     aout_VolumeGet( p_args->p_intf, &i_volume );
     sprintf( volume, "%d", (int)i_volume );
 
-    p_args->vars = E_(mvar_New)( "variables", "" );
-    E_(mvar_AppendNewVar)( p_args->vars, "url_param",
+    p_args->vars = mvar_New( "variables", "" );
+    mvar_AppendNewVar( p_args->vars, "url_param",
                            i_request > 0 ? "1" : "0" );
-    E_(mvar_AppendNewVar)( p_args->vars, "url_value", p_request );
-    E_(mvar_AppendNewVar)( p_args->vars, "version", VLC_Version() );
-    E_(mvar_AppendNewVar)( p_args->vars, "copyright", COPYRIGHT_MESSAGE );
-    E_(mvar_AppendNewVar)( p_args->vars, "vlc_compile_by", VLC_CompileBy() );
-    E_(mvar_AppendNewVar)( p_args->vars, "vlc_compile_host",
+    mvar_AppendNewVar( p_args->vars, "url_value", p_request );
+    mvar_AppendNewVar( p_args->vars, "version", VLC_Version() );
+    mvar_AppendNewVar( p_args->vars, "copyright", COPYRIGHT_MESSAGE );
+    mvar_AppendNewVar( p_args->vars, "vlc_compile_by", VLC_CompileBy() );
+    mvar_AppendNewVar( p_args->vars, "vlc_compile_host",
                            VLC_CompileHost() );
-    E_(mvar_AppendNewVar)( p_args->vars, "vlc_compile_domain",
+    mvar_AppendNewVar( p_args->vars, "vlc_compile_domain",
                            VLC_CompileDomain() );
-    E_(mvar_AppendNewVar)( p_args->vars, "vlc_compiler", VLC_Compiler() );
-    E_(mvar_AppendNewVar)( p_args->vars, "vlc_changeset", VLC_Changeset() );
-    E_(mvar_AppendNewVar)( p_args->vars, "stream_position", position );
-    E_(mvar_AppendNewVar)( p_args->vars, "stream_time", time );
-    E_(mvar_AppendNewVar)( p_args->vars, "stream_length", length );
-    E_(mvar_AppendNewVar)( p_args->vars, "volume", volume );
-    E_(mvar_AppendNewVar)( p_args->vars, "stream_state", state );
-    E_(mvar_AppendNewVar)( p_args->vars, "charset", "UTF-8" );
+    mvar_AppendNewVar( p_args->vars, "vlc_compiler", VLC_Compiler() );
+    mvar_AppendNewVar( p_args->vars, "vlc_changeset", VLC_Changeset() );
+    mvar_AppendNewVar( p_args->vars, "stream_position", position );
+    mvar_AppendNewVar( p_args->vars, "stream_time", time );
+    mvar_AppendNewVar( p_args->vars, "stream_length", length );
+    mvar_AppendNewVar( p_args->vars, "volume", volume );
+    mvar_AppendNewVar( p_args->vars, "stream_state", state );
+    mvar_AppendNewVar( p_args->vars, "charset", "UTF-8" );
 
     /* Stats */
     if( p_sys->p_input )
@@ -512,9 +512,9 @@ static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer,
         {
             vlc_mutex_lock( &p_item->p_stats->lock );
 #define STATS_INT( n ) sprintf( stats, "%d", p_item->p_stats->i_ ## n ); \
-                       E_(mvar_AppendNewVar)( p_args->vars, #n, stats );
+                       mvar_AppendNewVar( p_args->vars, #n, stats );
 #define STATS_FLOAT( n ) sprintf( stats, "%f", p_item->p_stats->f_ ## n ); \
-                       E_(mvar_AppendNewVar)( p_args->vars, #n, stats );
+                       mvar_AppendNewVar( p_args->vars, #n, stats );
             STATS_INT( read_bytes )
             STATS_FLOAT( input_bitrate )
             STATS_INT( demux_read_bytes )
@@ -534,14 +534,14 @@ static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer,
         }
     }
 
-    E_(SSInit)( &p_args->stack );
+    SSInit( &p_args->stack );
 
     /* allocate output */
     *pi_data = i_buffer + 1000;
     dst = *pp_data = malloc( *pi_data );
 
     /* we parse executing all  <vlc /> macros */
-    E_(Execute)( p_args, p_request, i_request, pp_data, pi_data, &dst,
+    Execute( p_args, p_request, i_request, pp_data, pi_data, &dst,
                  &p_buffer[0], &p_buffer[i_buffer] );
 
     *dst     = '\0';
@@ -552,11 +552,11 @@ static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer,
         vlc_object_release( p_sys->p_input );
         p_sys->p_input = NULL;
     }
-    E_(SSClean)( &p_args->stack );
-    E_(mvar_Delete)( p_args->vars );
+    SSClean( &p_args->stack );
+    mvar_Delete( p_args->vars );
 }
 
-int  E_(HttpCallback)( httpd_file_sys_t *p_args,
+int  HttpCallback( httpd_file_sys_t *p_args,
                        httpd_file_t *p_file,
                        uint8_t *_p_request,
                        uint8_t **_pp_data, int *pi_data )
@@ -574,7 +574,7 @@ int  E_(HttpCallback)( httpd_file_sys_t *p_args,
 
     if( !p_args->b_html )
     {
-        E_(FileLoad)( f, pp_data, pi_data );
+        FileLoad( f, pp_data, pi_data );
     }
     else
     {
@@ -582,7 +582,7 @@ int  E_(HttpCallback)( httpd_file_sys_t *p_args,
         char *p_buffer;
 
         /* first we load in a temporary buffer */
-        E_(FileLoad)( f, &p_buffer, &i_buffer );
+        FileLoad( f, &p_buffer, &i_buffer );
 
         ParseExecute( p_args, p_buffer, i_buffer, p_request, pp_data, pi_data );
 
@@ -599,7 +599,7 @@ int  E_(HttpCallback)( httpd_file_sys_t *p_args,
  ****************************************************************************
  * call the external handler and parse vlc macros if Content-Type is HTML
  ****************************************************************************/
-int  E_(HandlerCallback)( httpd_handler_sys_t *p_args,
+int  HandlerCallback( httpd_handler_sys_t *p_args,
                           httpd_handler_t *p_handler, char *_p_url,
                           uint8_t *_p_request, int i_type,
                           uint8_t *_p_in, int i_in,
@@ -826,7 +826,7 @@ int  E_(HandlerCallback)( httpd_handler_sys_t *p_args,
     return VLC_SUCCESS;
 }
 
-int  E_(ArtCallback)( httpd_handler_sys_t *p_args,
+int  ArtCallback( httpd_handler_sys_t *p_args,
                           httpd_handler_t *p_handler, char *_p_url,
                           uint8_t *p_request, int i_type,
                           uint8_t *p_in, int i_in,
@@ -846,7 +846,7 @@ int  E_(ArtCallback)( httpd_handler_sys_t *p_args,
 
     psz_id[0] = '\0';
     if( p_request )
-        E_(ExtractURIValue)( (char *)p_request, "id", psz_id, 15 );
+        ExtractURIValue( (char *)p_request, "id", psz_id, 15 );
     i_id = atoi( psz_id );
     if( i_id )
     {
@@ -884,7 +884,7 @@ int  E_(ArtCallback)( httpd_handler_sys_t *p_args,
             return VLC_SUCCESS;
         }
 
-        E_(FileLoad)( f, &p_data, &i_data );
+        FileLoad( f, &p_data, &i_data );
 
         fclose( f );
 
index 5d3d9a6..6a3badb 100644 (file)
 /* File and directory functions */
 
 /** This function recursively parses a directory and adds all files */
-int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
+int ParseDirectory( intf_thread_t *p_intf, char *psz_root,
                         char *psz_dir );
 /** This function loads a file into a buffer */
-int E_(FileLoad)( FILE *f, char **pp_data, int *pi_data );
+int FileLoad( FILE *f, char **pp_data, int *pi_data );
 /** This function creates a suitable URL for a filename */
-char *E_(FileToUrl)( char *name, bool *pb_index );
+char *FileToUrl( char *name, bool *pb_index );
 /** This function returns the real path of a file or directory */
-char *E_(RealPath)( intf_thread_t *p_intf, const char *psz_src );
+char *RealPath( intf_thread_t *p_intf, const char *psz_src );
 
 /** This command parses the "seek" command for the HTTP interface
  * and performs the requested action */
-void E_(HandleSeek)( intf_thread_t *p_intf, char *p_value );
+void HandleSeek( intf_thread_t *p_intf, char *p_value );
 
 /* URI Handling functions */
 
 /** This function extracts the value for a given argument name
  * from an HTTP request */
-char *E_(ExtractURIValue)( char *restrict psz_uri,
+char *ExtractURIValue( char *restrict psz_uri,
                            const char *restrict psz_name,
                            char *restrict psz_value, size_t i_value_max );
-char *E_(ExtractURIString)( char *restrict psz_uri,
+char *ExtractURIString( char *restrict psz_uri,
                             const char *restrict psz_name );
 /** \todo Describe this function */
-int E_(TestURIParam)( char *psz_uri, const char *psz_name );
+int TestURIParam( char *psz_uri, const char *psz_name );
 
 /** This function parses a MRL */
-input_item_t *E_(MRLParse)( intf_thread_t *, char *psz, char *psz_name );
+input_item_t *MRLParse( intf_thread_t *, char *psz, char *psz_name );
 
 /** Return the first word from a string (works in-place) */
-char *E_(FirstWord)( char *psz, char *new );
+char *FirstWord( char *psz, char *new );
 
 /**@}*/
 
@@ -163,28 +163,28 @@ typedef struct mvar_s
 
 
 /** This function creates a new variable */
-mvar_t  *E_(mvar_New)( const char *name, const char *value );
+mvar_t  *mvar_New( const char *name, const char *value );
 /** This function deletes a variable */
-void     E_(mvar_Delete)( mvar_t *v );
+void     mvar_Delete( mvar_t *v );
 /** This function adds f to the children variables of v, at last position */
-void     E_(mvar_AppendVar)( mvar_t *v, mvar_t *f );
+void     mvar_AppendVar( mvar_t *v, mvar_t *f );
 /** This function duplicates a variable */
-mvar_t  *E_(mvar_Duplicate)( const mvar_t *v );
+mvar_t  *mvar_Duplicate( const mvar_t *v );
 /** This function adds f to the children variables of v, at fist position */
-void     E_(mvar_PushVar)( mvar_t *v, mvar_t *f );
+void     mvar_PushVar( mvar_t *v, mvar_t *f );
 /** This function removes f from the children variables of v */
-void     E_(mvar_RemoveVar)( mvar_t *v, mvar_t *f );
+void     mvar_RemoveVar( mvar_t *v, mvar_t *f );
 /** This function retrieves the child variable named "name" */
-mvar_t  *E_(mvar_GetVar)( mvar_t *s, const char *name );
+mvar_t  *mvar_GetVar( mvar_t *s, const char *name );
 /** This function retrieves the value of the child variable named "field" */
-char    *E_(mvar_GetValue)( mvar_t *v, char *field );
+char    *mvar_GetValue( mvar_t *v, char *field );
 /** This function creates a variable with the given name and value and
  * adds it as first child of vars */
-void     E_(mvar_PushNewVar)( mvar_t *vars, const char *name,
+void     mvar_PushNewVar( mvar_t *vars, const char *name,
                               const char *value );
 /** This function creates a variable with the given name and value and
  * adds it as last child of vars */
-void     E_(mvar_AppendNewVar)( mvar_t *vars, const char *name,
+void     mvar_AppendNewVar( mvar_t *vars, const char *name,
                                 const char *value );
 /** @} */
 
@@ -198,30 +198,30 @@ void     E_(mvar_AppendNewVar)( mvar_t *vars, const char *name,
 
 /** This function creates a set variable which represents a series of integer
  * The arg parameter must be of the form "start[:stop[:step]]"  */
-mvar_t *E_(mvar_IntegerSetNew)( const char *name, const char *arg );
+mvar_t *mvar_IntegerSetNew( const char *name, const char *arg );
 
 /** This function creates a set variable with a list of VLC objects */
-mvar_t *E_(mvar_ObjectSetNew)( intf_thread_t *p_intf, char *name, const char *arg );
+mvar_t *mvar_ObjectSetNew( intf_thread_t *p_intf, char *name, const char *arg );
 
 /** This function creates a set variable with the contents of the playlist */
-mvar_t *E_(mvar_PlaylistSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_PlaylistSetNew( intf_thread_t *p_intf, char *name,
                                  playlist_t *p_pl );
 /** This function creates a set variable with the contents of the Stream
  * and media info box */
-mvar_t *E_(mvar_InfoSetNew)( char *name, input_thread_t *p_input );
+mvar_t *mvar_InfoSetNew( char *name, input_thread_t *p_input );
 /** This function creates a set variable with the input parameters */
-mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_InputVarSetNew( intf_thread_t *p_intf, char *name,
                                  input_thread_t *p_input,
                                  const char *psz_variable );
 /** This function creates a set variable representing the files of the psz_dir
  * directory */
-mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_FileSetNew( intf_thread_t *p_intf, char *name,
                              char *psz_dir );
 /** This function creates a set variable representing the VLM streams */
-mvar_t *E_(mvar_VlmSetNew)( char *name, vlm_t *vlm );
+mvar_t *mvar_VlmSetNew( char *name, vlm_t *vlm );
 
 /** This function converts the listing of a playlist node into a mvar set */
-void E_(PlaylistListNode)( intf_thread_t *p_intf, playlist_t *p_pl,
+void PlaylistListNode( intf_thread_t *p_intf, playlist_t *p_pl,
                            playlist_item_t *p_node, char *name, mvar_t *s,
                            int i_depth );
 
@@ -248,21 +248,21 @@ typedef struct
 } rpn_stack_t;
 
 /** This function creates the RPN evaluator stack */
-void E_(SSInit)( rpn_stack_t * );
+void SSInit( rpn_stack_t * );
 /** This function cleans the evaluator stack */
-void E_(SSClean)( rpn_stack_t * );
+void SSClean( rpn_stack_t * );
 /* Evaluate and execute the RPN Stack */
-void  E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
+void  EvaluateRPN( intf_thread_t *p_intf, mvar_t  *vars,
                        rpn_stack_t *st, char *exp );
 
 /* Push an operand on top of the RPN stack */
-void E_(SSPush)  ( rpn_stack_t *, const char * );
+void SSPush  ( rpn_stack_t *, const char * );
 /* Remove the first operand from the RPN Stack */
-char *E_(SSPop)  ( rpn_stack_t * );
+char *SSPop  ( rpn_stack_t * );
 /* Pushes an operand at a given position in the stack */
-void E_(SSPushN) ( rpn_stack_t *, int );
+void SSPushN ( rpn_stack_t *, int );
 /* Removes an operand at the given position in the stack */
-int  E_(SSPopN)  ( rpn_stack_t *, mvar_t  * );
+int  SSPopN  ( rpn_stack_t *, mvar_t  * );
 
 /**@}*/
 
@@ -292,7 +292,7 @@ typedef struct
 } macro_t;
 
 /** This function parses a file for macros */
-void E_(Execute)( httpd_file_sys_t *p_args,
+void Execute( httpd_file_sys_t *p_args,
                   char *p_request, int i_request,
                   char **pp_data, int *pi_data,
                   char **pp_dst,
@@ -369,12 +369,12 @@ struct intf_sys_t
 };
 
 /** This function is the main HTTPD Callback used by the HTTP Interface */
-int E_(HttpCallback)( httpd_file_sys_t *p_args,
+int HttpCallback( httpd_file_sys_t *p_args,
                       httpd_file_t *,
                       uint8_t *p_request,
                       uint8_t **pp_data, int *pi_data );
 /** This function is the HTTPD Callback used for CGIs */
-int  E_(HandlerCallback)( httpd_handler_sys_t *p_args,
+int  HandlerCallback( httpd_handler_sys_t *p_args,
                           httpd_handler_t *p_handler, char *_p_url,
                           uint8_t *_p_request, int i_type,
                           uint8_t *_p_in, int i_in,
index e8b0b30..964f414 100644 (file)
@@ -177,7 +177,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
             {
                 break;
             }
-            E_(ExtractURIValue)( p_request, "control", control, 512 );
+            ExtractURIValue( p_request, "control", control, 512 );
             if( *m->param1 && !strstr( m->param1, control ) )
             {
                 msg_Warn( p_intf, "unauthorized control=%s", control );
@@ -190,7 +190,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     int i_item;
                     char item[512];
 
-                    E_(ExtractURIValue)( p_request, "item", item, 512 );
+                    ExtractURIValue( p_request, "item", item, 512 );
                     i_item = atoi( item );
                     /* id = 0 : simply ask playlist to play */
                     if( i_item == 0 )
@@ -244,9 +244,9 @@ static void MacroDo( httpd_file_sys_t *p_args,
                 case MVLC_SEEK:
                 {
                     char value[30];
-                    E_(ExtractURIValue)( p_request, "seek_value", value, 30 );
+                    ExtractURIValue( p_request, "seek_value", value, 30 );
                     decode_URI( value );
-                    E_(HandleSeek)( p_intf, value );
+                    HandleSeek( p_intf, value );
                     break;
                 }
                 case MVLC_VOLUME:
@@ -255,7 +255,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     audio_volume_t i_volume;
                     int i_value;
 
-                    E_(ExtractURIValue)( p_request, "value", vol, 8 );
+                    ExtractURIValue( p_request, "value", vol, 8 );
                     aout_VolumeGet( p_intf, &i_volume );
                     decode_URI( vol );
 
@@ -314,9 +314,9 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     char *p, *str;
                     input_item_t *p_input;
 
-                    E_(ExtractURIValue)( p_request, "mrl", tmp, 1024 );
+                    ExtractURIValue( p_request, "mrl", tmp, 1024 );
                     decode_URI( tmp );
-                    E_(ExtractURIValue)( p_request, "name", psz_name, 1024 );
+                    ExtractURIValue( p_request, "name", psz_name, 1024 );
                     decode_URI( psz_name );
                     if( !*psz_name )
                     {
@@ -336,7 +336,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     }
                     *p = '\0';
 
-                    p_input = E_(MRLParse)( p_intf, mrl, psz_name );
+                    p_input = MRLParse( p_intf, mrl, psz_name );
 
                     char *psz_uri = input_item_GetURI( p_input );
                     if( !p_input || !psz_uri || !*psz_uri )
@@ -366,7 +366,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     /* Get the list of items to delete */
                     while( (p_parser =
-                            E_(ExtractURIValue)( p_parser, "item", item, 512 )) )
+                            ExtractURIValue( p_parser, "item", item, 512 )) )
                     {
                         if( !*item ) continue;
 
@@ -401,7 +401,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     /* Get the list of items to keep */
                     while( (p_parser =
-                       E_(ExtractURIValue)( p_parser, "item", item, 512 )) )
+                       ExtractURIValue( p_parser, "item", item, 512 )) )
                     {
                         if( !*item ) continue;
 
@@ -449,9 +449,9 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     int i_order;
                     int i_item;
 
-                    E_(ExtractURIValue)( p_request, "type", type, 12 );
-                    E_(ExtractURIValue)( p_request, "order", order, 2 );
-                    E_(ExtractURIValue)( p_request, "item", item, 512 );
+                    ExtractURIValue( p_request, "type", type, 12 );
+                    ExtractURIValue( p_request, "order", order, 2 );
+                    ExtractURIValue( p_request, "item", item, 512 );
                     i_item = atoi( item );
 
                     if( order[0] == '0' ) i_order = ORDER_NORMAL;
@@ -491,8 +491,8 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     char psz_newpos[6];
                     int i_pos;
                     int i_newpos;
-                    E_(ExtractURIValue)( p_request, "psz_pos", psz_pos, 6 );
-                    E_(ExtractURIValue)( p_request, "psz_newpos", psz_newpos, 6 );
+                    ExtractURIValue( p_request, "psz_pos", psz_pos, 6 );
+                    ExtractURIValue( p_request, "psz_newpos", psz_newpos, 6 );
                     i_pos = atoi( psz_pos );
                     i_newpos = atoi( psz_newpos );
                     /* FIXME FIXME TODO TODO XXX XXX
@@ -514,7 +514,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                 case MVLC_CLOSE:
                 {
                     char id[512];
-                    E_(ExtractURIValue)( p_request, "id", id, 512 );
+                    ExtractURIValue( p_request, "id", id, 512 );
                     msg_Dbg( p_intf, "requested close id=%s", id );
 #if 0
                     if( p_sys->p_httpd->pf_control( p_sys->p_httpd, HTTPD_SET_CLOSE, id, NULL ) )
@@ -553,11 +553,11 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     if( p_intf->p_sys->p_vlm == NULL ) break;
 
-                    E_(ExtractURIValue)( p_request, "name", name, 512 );
+                    ExtractURIValue( p_request, "name", name, 512 );
                     if( StrToMacroType( control ) == MVLC_VLM_NEW )
                     {
                         char type[20];
-                        E_(ExtractURIValue)( p_request, "type", type, 20 );
+                        ExtractURIValue( p_request, "type", type, 20 );
                         p += sprintf( psz, "new %s %s", name, type );
                     }
                     else
@@ -568,14 +568,14 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     for( i = 0; i < 11; i++ )
                     {
                         char val[512];
-                        E_(ExtractURIValue)( p_request,
+                        ExtractURIValue( p_request,
                                                vlm_properties[i], val, 512 );
                         decode_URI( val );
                         if( strlen( val ) > 0 && i >= 4 )
                         {
                             p += sprintf( p, " %s %s", vlm_properties[i], val );
                         }
-                        else if( E_(TestURIParam)( p_request, vlm_properties[i] ) && i < 4 )
+                        else if( TestURIParam( p_request, vlm_properties[i] ) && i < 4 )
                         {
                             p += sprintf( p, " %s", vlm_properties[i] );
                         }
@@ -594,7 +594,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                                                          vlm_answer->psz_value );
                     }
 
-                    E_(mvar_AppendNewVar)( p_args->vars, "vlm_error", vlm_error );
+                    mvar_AppendNewVar( p_args->vars, "vlm_error", vlm_error );
 
                     vlm_MessageDelete( vlm_answer );
                     free( vlm_error );
@@ -612,7 +612,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     if( p_intf->p_sys->p_vlm == NULL ) break;
 
-                    E_(ExtractURIValue)( p_request, "name", name, 512 );
+                    ExtractURIValue( p_request, "name", name, 512 );
                     sprintf( psz, "del %s", name );
 
                     vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz, &vlm_answer );
@@ -634,7 +634,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     if( p_intf->p_sys->p_vlm == NULL ) break;
 
-                    E_(ExtractURIValue)( p_request, "name", name, 512 );
+                    ExtractURIValue( p_request, "name", name, 512 );
                     if( StrToMacroType( control ) == MVLC_VLM_PLAY )
                         sprintf( psz, "control %s play", name );
                     else if( StrToMacroType( control ) == MVLC_VLM_PAUSE )
@@ -644,7 +644,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
                     else if( StrToMacroType( control ) == MVLC_VLM_SEEK )
                     {
                         char percent[20];
-                        E_(ExtractURIValue)( p_request, "percent", percent, 512 );
+                        ExtractURIValue( p_request, "percent", percent, 512 );
                         sprintf( psz, "control %s seek %s", name, percent );
                     }
 
@@ -665,7 +665,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
                     if( p_intf->p_sys->p_vlm == NULL ) break;
 
-                    E_(ExtractURIValue)( p_request, "file", file, 512 );
+                    ExtractURIValue( p_request, "file", file, 512 );
                     decode_URI( file );
 
                     if( StrToMacroType( control ) == MVLC_VLM_LOAD )
@@ -700,7 +700,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
             {
                 break;
             }
-            E_(ExtractURIValue)( p_request, m->param1,  value, 512 );
+            ExtractURIValue( p_request, m->param1,  value, 512 );
             decode_URI( value );
 
             switch( StrToMacroType( m->param2 ) )
@@ -771,13 +771,13 @@ static void MacroDo( httpd_file_sys_t *p_args,
 
             if( m->param1 )
             {
-                E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m->param1 );
-                s = E_(SSPop)( &p_args->stack );
-                v = E_(mvar_GetValue)( p_args->vars, s );
+                EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m->param1 );
+                s = SSPop( &p_args->stack );
+                v = mvar_GetValue( p_args->vars, s );
             }
             else
             {
-                v = s = E_(SSPop)( &p_args->stack );
+                v = s = SSPop( &p_args->stack );
             }
 
             PRINTS( "%s", v );
@@ -785,7 +785,7 @@ static void MacroDo( httpd_file_sys_t *p_args,
             break;
         }
         case MVLC_RPN:
-            E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m->param1 );
+            EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m->param1 );
             break;
 
         /* Useful to learn stack management */
@@ -862,7 +862,7 @@ char *MacroSearch( char *src, char *end, int i_mvlc, bool b_after )
     return NULL;
 }
 
-void E_(Execute)( httpd_file_sys_t *p_args,
+void Execute( httpd_file_sys_t *p_args,
                      char *p_request, int i_request,
                      char **pp_data, int *pi_data,
                      char **pp_dst,
@@ -936,10 +936,10 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                     }
 
                     /* first we load in a temporary buffer */
-                    E_(FileLoad)( f, &p_buffer, &i_buffer );
+                    FileLoad( f, &p_buffer, &i_buffer );
 
                     /* we parse executing all  <vlc /> macros */
-                    E_(Execute)( p_args, p_request, i_request, pp_data, pi_data,
+                    Execute( p_args, p_request, i_request, pp_data, pi_data,
                              &dst, &p_buffer[0], &p_buffer[i_buffer] );
                     free( p_buffer );
                     fclose(f);
@@ -950,8 +950,8 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                     bool i_test;
                     char    *endif;
 
-                    E_(EvaluateRPN)( p_intf, p_args->vars, &p_args->stack, m.param1 );
-                    if( E_(SSPopN)( &p_args->stack, p_args->vars ) )
+                    EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m.param1 );
+                    if( SSPopN( &p_args->stack, p_args->vars ) )
                     {
                         i_test = 1;
                     }
@@ -970,7 +970,7 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                             char *stop  = MacroSearch( start, endif, MVLC_END, false );
                             if( stop )
                             {
-                                E_(Execute)( p_args, p_request, i_request,
+                                Execute( p_args, p_request, i_request,
                                          pp_data, pi_data, &dst, start, stop );
                             }
                         }
@@ -984,7 +984,7 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                         }
                         if( stop )
                         {
-                            E_(Execute)( p_args, p_request, i_request,
+                            Execute( p_args, p_request, i_request,
                                      pp_data, pi_data, &dst, src, stop );
                         }
                     }
@@ -1005,30 +1005,30 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                         mvar_t *v;
                         if( !strcmp( m.param2, "integer" ) )
                         {
-                            char *arg = E_(SSPop)( &p_args->stack );
-                            index = E_(mvar_IntegerSetNew)( m.param1, arg );
+                            char *arg = SSPop( &p_args->stack );
+                            index = mvar_IntegerSetNew( m.param1, arg );
                             free( arg );
                         }
                         else if( !strcmp( m.param2, "directory" ) )
                         {
-                            char *arg = E_(SSPop)( &p_args->stack );
-                            index = E_(mvar_FileSetNew)( p_intf, m.param1, arg );
+                            char *arg = SSPop( &p_args->stack );
+                            index = mvar_FileSetNew( p_intf, m.param1, arg );
                             free( arg );
                         }
                         else if( !strcmp( m.param2, "object" ) )
                         {
-                            char *arg = E_(SSPop)( &p_args->stack );
-                            index = E_(mvar_ObjectSetNew)( p_intf, m.param1, arg );
+                            char *arg = SSPop( &p_args->stack );
+                            index = mvar_ObjectSetNew( p_intf, m.param1, arg );
                             free( arg );
                         }
                         else if( !strcmp( m.param2, "playlist" ) )
                         {
-                            index = E_(mvar_PlaylistSetNew)( p_intf, m.param1,
+                            index = mvar_PlaylistSetNew( p_intf, m.param1,
                                                     p_intf->p_sys->p_playlist );
                         }
                         else if( !strcmp( m.param2, "information" ) )
                         {
-                            index = E_(mvar_InfoSetNew)( m.param1,
+                            index = mvar_InfoSetNew( m.param1,
                                                      p_intf->p_sys->p_input );
                         }
                         else if( !strcmp( m.param2, "program" )
@@ -1038,7 +1038,7 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                                   || !strcmp( m.param2, "video-es" )
                                   || !strcmp( m.param2, "spu-es" ) )
                         {
-                            index = E_(mvar_InputVarSetNew)( p_intf, m.param1,
+                            index = mvar_InputVarSetNew( p_intf, m.param1,
                                                          p_intf->p_sys->p_input,
                                                          m.param2 );
                         }
@@ -1046,25 +1046,25 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                         {
                             if( p_intf->p_sys->p_vlm == NULL )
                                 p_intf->p_sys->p_vlm = vlm_New( p_intf );
-                            index = E_(mvar_VlmSetNew)( m.param1, p_intf->p_sys->p_vlm );
+                            index = mvar_VlmSetNew( m.param1, p_intf->p_sys->p_vlm );
                         }
 #if 0
                         else if( !strcmp( m.param2, "hosts" ) )
                         {
-                            index = E_(mvar_HttpdInfoSetNew)( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_HOSTS );
+                            index = mvar_HttpdInfoSetNew( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_HOSTS );
                         }
                         else if( !strcmp( m.param2, "urls" ) )
                         {
-                            index = E_(mvar_HttpdInfoSetNew)( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_URLS );
+                            index = mvar_HttpdInfoSetNew( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_URLS );
                         }
                         else if( !strcmp( m.param2, "connections" ) )
                         {
-                            index = E_(mvar_HttpdInfoSetNew)(m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_CONNECTIONS);
+                            index = mvar_HttpdInfoSetNew(m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_CONNECTIONS);
                         }
 #endif
-                        else if( ( v = E_(mvar_GetVar)( p_args->vars, m.param2 ) ) )
+                        else if( ( v = mvar_GetVar( p_args->vars, m.param2 ) ) )
                         {
-                            index = E_(mvar_Duplicate)( v );
+                            index = mvar_Duplicate( v );
                         }
                         else
                         {
@@ -1075,7 +1075,7 @@ void E_(Execute)( httpd_file_sys_t *p_args,
 
                         for( i_idx = 0; i_idx < index->i_field; i_idx++ )
                         {
-                            mvar_t *f = E_(mvar_Duplicate)( index->field[i_idx] );
+                            mvar_t *f = mvar_Duplicate( index->field[i_idx] );
 
                             //msg_Dbg( p_intf, "foreach field[%d] name=%s value=%s", i_idx, f->name, f->value );
 
@@ -1083,14 +1083,14 @@ void E_(Execute)( httpd_file_sys_t *p_args,
                             f->name = strdup( m.param1 );
 
 
-                            E_(mvar_PushVar)( p_args->vars, f );
-                            E_(Execute)( p_args, p_request, i_request,
+                            mvar_PushVar( p_args->vars, f );
+                            Execute( p_args, p_request, i_request,
                                      pp_data, pi_data, &dst, start, stop );
-                            E_(mvar_RemoveVar)( p_args->vars, f );
+                            mvar_RemoveVar( p_args->vars, f );
 
-                            E_(mvar_Delete)( f );
+                            mvar_Delete( f );
                         }
-                        E_(mvar_Delete)( index );
+                        mvar_Delete( index );
 
                         src = endfor;
                     }
index 4fe22ea..15d6770 100644 (file)
@@ -43,7 +43,7 @@ static int InsensitiveAlphasort( const char **foo1,
 
 
 
-mvar_t *E_(mvar_New)( const char *name, const char *value )
+mvar_t *mvar_New( const char *name, const char *value )
 {
     mvar_t *v = malloc( sizeof( mvar_t ) );
 
@@ -58,7 +58,7 @@ mvar_t *E_(mvar_New)( const char *name, const char *value )
     return v;
 }
 
-void E_(mvar_Delete)( mvar_t *v )
+void mvar_Delete( mvar_t *v )
 {
     int i;
 
@@ -67,34 +67,34 @@ void E_(mvar_Delete)( mvar_t *v )
 
     for( i = 0; i < v->i_field; i++ )
     {
-        E_(mvar_Delete)( v->field[i] );
+        mvar_Delete( v->field[i] );
     }
     free( v->field );
     free( v );
 }
 
-void E_(mvar_AppendVar)( mvar_t *v, mvar_t *f )
+void mvar_AppendVar( mvar_t *v, mvar_t *f )
 {
     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
     v->field[v->i_field] = f;
     v->i_field++;
 }
 
-mvar_t *E_(mvar_Duplicate)( const mvar_t *v )
+mvar_t *mvar_Duplicate( const mvar_t *v )
 {
     int i;
     mvar_t *n;
 
-    n = E_(mvar_New)( v->name, v->value );
+    n = mvar_New( v->name, v->value );
     for( i = 0; i < v->i_field; i++ )
     {
-        E_(mvar_AppendVar)( n, E_(mvar_Duplicate)( v->field[i] ) );
+        mvar_AppendVar( n, mvar_Duplicate( v->field[i] ) );
     }
 
     return n;
 }
 
-void E_(mvar_PushVar)( mvar_t *v, mvar_t *f )
+void mvar_PushVar( mvar_t *v, mvar_t *f )
 {
     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
     if( v->i_field > 0 )
@@ -105,7 +105,7 @@ void E_(mvar_PushVar)( mvar_t *v, mvar_t *f )
     v->i_field++;
 }
 
-void E_(mvar_RemoveVar)( mvar_t *v, mvar_t *f )
+void mvar_RemoveVar( mvar_t *v, mvar_t *f )
 {
     int i;
     for( i = 0; i < v->i_field; i++ )
@@ -128,7 +128,7 @@ void E_(mvar_RemoveVar)( mvar_t *v, mvar_t *f )
     /* FIXME should do a realloc */
 }
 
-mvar_t *E_(mvar_GetVar)( mvar_t *s, const char *name )
+mvar_t *mvar_GetVar( mvar_t *s, const char *name )
 {
     /* format: name[index].field */
     const char *field = strchr( name, '.' );
@@ -168,7 +168,7 @@ mvar_t *E_(mvar_GetVar)( mvar_t *s, const char *name )
             {
                 if( field )
                 {
-                    return E_(mvar_GetVar)( s->field[i], field );
+                    return mvar_GetVar( s->field[i], field );
                 }
                 else
                 {
@@ -180,7 +180,7 @@ mvar_t *E_(mvar_GetVar)( mvar_t *s, const char *name )
     return NULL;
 }
 
-char *E_(mvar_GetValue)( mvar_t *v, char *field )
+char *mvar_GetValue( mvar_t *v, char *field )
 {
     if( *field == '\0' )
     {
@@ -188,7 +188,7 @@ char *E_(mvar_GetValue)( mvar_t *v, char *field )
     }
     else
     {
-        mvar_t *f = E_(mvar_GetVar)( v, field );
+        mvar_t *f = mvar_GetVar( v, field );
         if( f )
         {
             return f->value;
@@ -200,27 +200,27 @@ char *E_(mvar_GetValue)( mvar_t *v, char *field )
     }
 }
 
-void E_(mvar_PushNewVar)( mvar_t *vars, const char *name,
+void mvar_PushNewVar( mvar_t *vars, const char *name,
                           const char *value )
 {
-    mvar_t *f = E_(mvar_New)( name, value );
-    E_(mvar_PushVar)( vars, f );
+    mvar_t *f = mvar_New( name, value );
+    mvar_PushVar( vars, f );
 }
 
-void E_(mvar_AppendNewVar)( mvar_t *vars, const char *name,
+void mvar_AppendNewVar( mvar_t *vars, const char *name,
                             const char *value )
 {
-    mvar_t *f = E_(mvar_New)( name, value );
-    E_(mvar_AppendVar)( vars, f );
+    mvar_t *f = mvar_New( name, value );
+    mvar_AppendVar( vars, f );
 }
 
 
 /* arg= start[:stop[:step]],.. */
-mvar_t *E_(mvar_IntegerSetNew)( const char *name, const char *arg )
+mvar_t *mvar_IntegerSetNew( const char *name, const char *arg )
 {
     char *dup = strdup( arg );
     char *str = dup;
-    mvar_t *s = E_(mvar_New)( name, "set" );
+    mvar_t *s = mvar_New( name, "set" );
 
     while( str )
     {
@@ -266,7 +266,7 @@ mvar_t *E_(mvar_IntegerSetNew)( const char *name, const char *arg )
 
                     sprintf( value, "%d", i );
 
-                    E_(mvar_PushNewVar)( s, name, value );
+                    mvar_PushNewVar( s, name, value );
                 }
             }
         }
@@ -281,19 +281,19 @@ mvar_t *E_(mvar_IntegerSetNew)( const char *name, const char *arg )
  * Special sets handling
  ********************************************************************/
 
-mvar_t *E_(mvar_PlaylistSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_PlaylistSetNew( intf_thread_t *p_intf, char *name,
                                  playlist_t *p_pl )
 {
-    mvar_t *s = E_(mvar_New)( name, "set" );
+    mvar_t *s = mvar_New( name, "set" );
     vlc_mutex_lock( &p_pl->object_lock );
-    E_(PlaylistListNode)( p_intf, p_pl, p_pl->p_root_category , name, s, 0 );
+    PlaylistListNode( p_intf, p_pl, p_pl->p_root_category , name, s, 0 );
     vlc_mutex_unlock( &p_pl->object_lock );
     return s;
 }
 
-mvar_t *E_(mvar_InfoSetNew)( char *name, input_thread_t *p_input )
+mvar_t *mvar_InfoSetNew( char *name, input_thread_t *p_input )
 {
-    mvar_t *s = E_(mvar_New)( name, "set" );
+    mvar_t *s = mvar_New( name, "set" );
     int i, j;
 
     if( p_input == NULL || p_input->p == NULL /* workarround assert in input_GetItem */ )
@@ -306,34 +306,34 @@ mvar_t *E_(mvar_InfoSetNew)( char *name, input_thread_t *p_input )
     {
         info_category_t *p_category = input_GetItem(p_input)->pp_categories[i];
 
-        mvar_t *cat  = E_(mvar_New)( name, "set" );
-        mvar_t *iset = E_(mvar_New)( "info", "set" );
+        mvar_t *cat  = mvar_New( name, "set" );
+        mvar_t *iset = mvar_New( "info", "set" );
 
-        E_(mvar_AppendNewVar)( cat, "name", p_category->psz_name );
-        E_(mvar_AppendVar)( cat, iset );
+        mvar_AppendNewVar( cat, "name", p_category->psz_name );
+        mvar_AppendVar( cat, iset );
 
         for ( j = 0; j < p_category->i_infos; j++ )
         {
             info_t *p_info = p_category->pp_infos[j];
-            mvar_t *info = E_(mvar_New)( "info", "" );
+            mvar_t *info = mvar_New( "info", "" );
 
             /* msg_Dbg( p_input, "adding info name=%s value=%s",
                      psz_name, psz_value ); */
-            E_(mvar_AppendNewVar)( info, "name",  p_info->psz_name );
-            E_(mvar_AppendNewVar)( info, "value", p_info->psz_value );
-            E_(mvar_AppendVar)( iset, info );
+            mvar_AppendNewVar( info, "name",  p_info->psz_name );
+            mvar_AppendNewVar( info, "value", p_info->psz_value );
+            mvar_AppendVar( iset, info );
         }
-        E_(mvar_AppendVar)( s, cat );
+        mvar_AppendVar( s, cat );
     }
     vlc_mutex_unlock( &input_GetItem(p_input)->lock );
 
     return s;
 }
 
-mvar_t *E_(mvar_ObjectSetNew)( intf_thread_t *p_intf, char *psz_name,
+mvar_t *mvar_ObjectSetNew( intf_thread_t *p_intf, char *psz_name,
                                const char *psz_capability )
 {
-    mvar_t *s = E_(mvar_New)( psz_name, "set" );
+    mvar_t *s = mvar_New( psz_name, "set" );
     int i;
 
     vlc_list_t *p_list = vlc_list_find( p_intf, VLC_OBJECT_MODULE,
@@ -344,10 +344,10 @@ mvar_t *E_(mvar_ObjectSetNew)( intf_thread_t *p_intf, char *psz_name,
         module_t *p_parser = (module_t *)p_list->p_values[i].p_object;
         if( module_IsCapable( p_parser, psz_capability ) )
         {
-            mvar_t *sd = E_(mvar_New)( "sd", module_GetObjName( p_parser ) );
-            E_(mvar_AppendNewVar)( sd, "name",
+            mvar_t *sd = mvar_New( "sd", module_GetObjName( p_parser ) );
+            mvar_AppendNewVar( sd, "name",
                                    module_GetName( p_parser, true ) );
-            E_(mvar_AppendVar)( s, sd );
+            mvar_AppendVar( s, sd );
         }
     }
 
@@ -356,12 +356,12 @@ mvar_t *E_(mvar_ObjectSetNew)( intf_thread_t *p_intf, char *psz_name,
     return s;
 }
 
-mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_InputVarSetNew( intf_thread_t *p_intf, char *name,
                                  input_thread_t *p_input,
                                  const char *psz_variable )
 {
     intf_sys_t     *p_sys = p_intf->p_sys;
-    mvar_t *s = E_(mvar_New)( name, "set" );
+    mvar_t *s = mvar_New( name, "set" );
     vlc_value_t val, val_list, text_list;
     int i_type, i;
 
@@ -419,31 +419,31 @@ mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
         switch( i_type & VLC_VAR_TYPE )
         {
         case VLC_VAR_STRING:
-            itm = E_(mvar_New)( name, "set" );
+            itm = mvar_New( name, "set" );
             /* FIXME: Memory leak here?? (remove strdup?) */
             psz = strdup( text_list.p_list->p_values[i].psz_string );
-            E_(mvar_AppendNewVar)( itm, "name", psz );
-            E_(mvar_AppendNewVar)( itm, "id", val_list.p_list->p_values[i].psz_string );
+            mvar_AppendNewVar( itm, "name", psz );
+            mvar_AppendNewVar( itm, "id", val_list.p_list->p_values[i].psz_string );
             snprintf( psz_int, sizeof(psz_int), "%d",
                       ( !strcmp( val.psz_string,
                                    val_list.p_list->p_values[i].psz_string )
                            && !( i_type & VLC_VAR_ISCOMMAND ) ) );
-            E_(mvar_AppendNewVar)( itm, "selected", psz_int );
-            E_(mvar_AppendVar)( s, itm );
+            mvar_AppendNewVar( itm, "selected", psz_int );
+            mvar_AppendVar( s, itm );
             break;
 
         case VLC_VAR_INTEGER:
-            itm = E_(mvar_New)( name, "set" );
+            itm = mvar_New( name, "set" );
             psz = strdup( text_list.p_list->p_values[i].psz_string );
-            E_(mvar_AppendNewVar)( itm, "name", psz );
+            mvar_AppendNewVar( itm, "name", psz );
             snprintf( psz_int, sizeof(psz_int), "%d",
                       val_list.p_list->p_values[i].i_int );
-            E_(mvar_AppendNewVar)( itm, "id", psz_int );
+            mvar_AppendNewVar( itm, "id", psz_int );
             snprintf( psz_int, sizeof(psz_int), "%d",
                       ( val.i_int == val_list.p_list->p_values[i].i_int )
                          && !( i_type & VLC_VAR_ISCOMMAND ) );
-            E_(mvar_AppendNewVar)( itm, "selected", psz_int );
-            E_(mvar_AppendVar)( s, itm );
+            mvar_AppendNewVar( itm, "selected", psz_int );
+            mvar_AppendVar( s, itm );
             break;
 
         default:
@@ -458,9 +458,9 @@ mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
 }
 
 #if 0
-mvar_t *E_(mvar_HttpdInfoSetNew)( char *name, httpd_t *p_httpd, int i_type )
+mvar_t *mvar_HttpdInfoSetNew( char *name, httpd_t *p_httpd, int i_type )
 {
-    mvar_t       *s = E_(mvar_New)( name, "set" );
+    mvar_t       *s = mvar_New( name, "set" );
     httpd_info_t info;
     int          i;
 
@@ -470,17 +470,17 @@ mvar_t *E_(mvar_HttpdInfoSetNew)( char *name, httpd_t *p_httpd, int i_type )
         {
             mvar_t *inf;
 
-            inf = E_(mvar_New)( name, "set" );
+            inf = mvar_New( name, "set" );
             do
             {
                 /* fprintf( stderr," mvar_HttpdInfoSetNew: append name=`%s' value=`%s'\n",
                             info.info[i].psz_name, info.info[i].psz_value ); */
-                E_(mvar_AppendNewVar)( inf,
+                mvar_AppendNewVar( inf,
                                    info.info[i].psz_name,
                                    info.info[i].psz_value );
                 i++;
             } while( i < info.i_count && strcmp( info.info[i].psz_name, "id" ) );
-            E_(mvar_AppendVar)( s, inf );
+            mvar_AppendVar( s, inf );
         }
     }
 
@@ -499,16 +499,16 @@ mvar_t *E_(mvar_HttpdInfoSetNew)( char *name, httpd_t *p_httpd, int i_type )
 }
 #endif
 
-mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
+mvar_t *mvar_FileSetNew( intf_thread_t *p_intf, char *name,
                              char *psz_dir )
 {
-    mvar_t *s = E_(mvar_New)( name, "set" );
+    mvar_t *s = mvar_New( name, "set" );
 #ifdef HAVE_SYS_STAT_H
     struct stat   stat_info;
 #endif
     char        **ppsz_dir_content;
     int           i_dir_content, i;
-    psz_dir = E_(RealPath)( p_intf, psz_dir );
+    psz_dir = RealPath( p_intf, psz_dir );
 
 #ifdef HAVE_SYS_STAT_H
     if( (utf8_stat( psz_dir, &stat_info ) == -1 )
@@ -556,7 +556,7 @@ mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
             }
 #endif
         }
-        f = E_(mvar_New)( name, "set" );
+        f = mvar_New( name, "set" );
 
         /* put lower-case file extension in 'ext' */
         psz_ext = strrchr( psz_name, '.' );
@@ -564,7 +564,7 @@ mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
         for( psz_dummy = psz_ext; *psz_dummy != '\0'; psz_dummy++ )
             *psz_dummy = tolower( *psz_dummy );
 
-        E_(mvar_AppendNewVar)( f, "ext", psz_ext );
+        mvar_AppendNewVar( f, "ext", psz_ext );
         free( psz_ext );
 
 #if defined( WIN32 )
@@ -572,11 +572,11 @@ mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
         {
             char psz_tmp[3];
             sprintf( psz_tmp, "%c:", psz_name[0] );
-            E_(mvar_AppendNewVar)( f, "name", psz_name );
-            E_(mvar_AppendNewVar)( f, "basename", psz_tmp );
-            E_(mvar_AppendNewVar)( f, "type", "directory" );
-            E_(mvar_AppendNewVar)( f, "size", "unknown" );
-            E_(mvar_AppendNewVar)( f, "date", "unknown" );
+            mvar_AppendNewVar( f, "name", psz_name );
+            mvar_AppendNewVar( f, "basename", psz_tmp );
+            mvar_AppendNewVar( f, "type", "directory" );
+            mvar_AppendNewVar( f, "size", "unknown" );
+            mvar_AppendNewVar( f, "date", "unknown" );
         }
         else
 #endif
@@ -585,42 +585,42 @@ mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
             char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];
 
             sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
-            E_(mvar_AppendNewVar)( f, "name", psz_tmp );
-            E_(mvar_AppendNewVar)( f, "basename", psz_name );
+            mvar_AppendNewVar( f, "name", psz_tmp );
+            mvar_AppendNewVar( f, "basename", psz_name );
 
 #ifdef HAVE_SYS_STAT_H
             if( S_ISDIR( stat_info.st_mode ) )
             {
-                E_(mvar_AppendNewVar)( f, "type", "directory" );
+                mvar_AppendNewVar( f, "type", "directory" );
             }
             else if( S_ISREG( stat_info.st_mode ) )
             {
-                E_(mvar_AppendNewVar)( f, "type", "file" );
+                mvar_AppendNewVar( f, "type", "file" );
             }
             else
             {
-                E_(mvar_AppendNewVar)( f, "type", "unknown" );
+                mvar_AppendNewVar( f, "type", "unknown" );
             }
 
             sprintf( psz_ctime, "%"PRId64, (int64_t)stat_info.st_size );
-            E_(mvar_AppendNewVar)( f, "size", psz_ctime );
+            mvar_AppendNewVar( f, "size", psz_ctime );
 
             /* FIXME memory leak FIXME */
 #   ifdef HAVE_CTIME_R
             ctime_r( &stat_info.st_mtime, psz_ctime );
-            E_(mvar_AppendNewVar)( f, "date", psz_ctime );
+            mvar_AppendNewVar( f, "date", psz_ctime );
 #   else
-            E_(mvar_AppendNewVar)( f, "date", ctime( &stat_info.st_mtime ) );
+            mvar_AppendNewVar( f, "date", ctime( &stat_info.st_mtime ) );
 #   endif
 
 #else
-            E_(mvar_AppendNewVar)( f, "type", "unknown" );
-            E_(mvar_AppendNewVar)( f, "size", "unknown" );
-            E_(mvar_AppendNewVar)( f, "date", "unknown" );
+            mvar_AppendNewVar( f, "type", "unknown" );
+            mvar_AppendNewVar( f, "size", "unknown" );
+            mvar_AppendNewVar( f, "date", "unknown" );
 #endif
         }
 
-        E_(mvar_AppendVar)( s, f );
+        mvar_AppendVar( s, f );
 
         free( psz_name );
     }
@@ -630,18 +630,18 @@ mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
     return s;
 }
 
-void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, bool b_name );
-void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, bool b_name )
+void mvar_VlmSetNewLoop( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, bool b_name );
+void mvar_VlmSetNewLoop( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, bool b_name )
 {
     /* Over name */
     mvar_t        *set;
     int k;
 
     /* Add a node with name and info */
-    set = E_(mvar_New)( name, "set" );
+    set = mvar_New( name, "set" );
     if( b_name == true )
     {
-        E_(mvar_AppendNewVar)( set, "name", el->psz_name );
+        mvar_AppendNewVar( set, "name", el->psz_name );
     }
 
     for( k = 0; k < el->i_child; k++ )
@@ -649,27 +649,27 @@ void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *e
         vlm_message_t *ch = el->child[k];
         if( ch->i_child > 0 )
         {
-            E_(mvar_VlmSetNewLoop)( ch->psz_name, vlm, set, ch, false );
+            mvar_VlmSetNewLoop( ch->psz_name, vlm, set, ch, false );
         }
         else
         {
             if( ch->psz_value )
             {
-                E_(mvar_AppendNewVar)( set, ch->psz_name, ch->psz_value );
+                mvar_AppendNewVar( set, ch->psz_name, ch->psz_value );
             }
             else
             {
-                E_(mvar_AppendNewVar)( set, el->psz_name, ch->psz_name );
+                mvar_AppendNewVar( set, el->psz_name, ch->psz_name );
             }
         }
     }
 
-    E_(mvar_AppendVar)( s, set );
+    mvar_AppendVar( s, set );
 }
 
-mvar_t *E_(mvar_VlmSetNew)( char *name, vlm_t *vlm )
+mvar_t *mvar_VlmSetNew( char *name, vlm_t *vlm )
 {
-    mvar_t        *s = E_(mvar_New)( name, "set" );
+    mvar_t        *s = mvar_New( name, "set" );
     vlm_message_t *msg;
     int    i;
 
@@ -698,7 +698,7 @@ mvar_t *E_(mvar_VlmSetNew)( char *name, vlm_t *vlm )
                 continue;
             desc = inf->child[0];
 
-            E_(mvar_VlmSetNewLoop)( el->psz_name, vlm, s, desc, true );
+            mvar_VlmSetNewLoop( el->psz_name, vlm, s, desc, true );
 
             vlm_MessageDelete( inf );
         }
index 275d017..757c26c 100644 (file)
@@ -66,12 +66,12 @@ static vlc_object_t *GetVLCObject( intf_thread_t *p_intf,
     return p_object;
 }
 
-void E_(SSInit)( rpn_stack_t *st )
+void SSInit( rpn_stack_t *st )
 {
     st->i_stack = 0;
 }
 
-void E_(SSClean)( rpn_stack_t *st )
+void SSClean( rpn_stack_t *st )
 {
     while( st->i_stack > 0 )
     {
@@ -79,7 +79,7 @@ void E_(SSClean)( rpn_stack_t *st )
     }
 }
 
-void E_(SSPush)( rpn_stack_t *st, const char *s )
+void SSPush( rpn_stack_t *st, const char *s )
 {
     if( st->i_stack < STACK_MAX )
     {
@@ -87,7 +87,7 @@ void E_(SSPush)( rpn_stack_t *st, const char *s )
     }
 }
 
-char *E_(SSPop)( rpn_stack_t *st )
+char *SSPop( rpn_stack_t *st )
 {
     if( st->i_stack <= 0 )
     {
@@ -99,7 +99,7 @@ char *E_(SSPop)( rpn_stack_t *st )
     }
 }
 
-int E_(SSPopN)( rpn_stack_t *st, mvar_t  *vars )
+int SSPopN( rpn_stack_t *st, mvar_t  *vars )
 {
     char *name;
     char *value;
@@ -107,11 +107,11 @@ int E_(SSPopN)( rpn_stack_t *st, mvar_t  *vars )
     char *end;
     int  i;
 
-    name = E_(SSPop)( st );
+    name = SSPop( st );
     i = strtol( name, &end, 0 );
     if( end == name )
     {
-        value = E_(mvar_GetValue)( vars, name );
+        value = mvar_GetValue( vars, name );
         i = atoi( value );
     }
     free( name );
@@ -119,15 +119,15 @@ int E_(SSPopN)( rpn_stack_t *st, mvar_t  *vars )
     return( i );
 }
 
-void E_(SSPushN)( rpn_stack_t *st, int i )
+void SSPushN( rpn_stack_t *st, int i )
 {
     char v[12];
 
     snprintf( v, sizeof (v), "%d", i );
-    E_(SSPush)( st, v );
+    SSPush( st, v );
 }
 
-void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
+void EvaluateRPN( intf_thread_t *p_intf, mvar_t  *vars,
                       rpn_stack_t *st, char *exp )
 {
     intf_sys_t    *p_sys = p_intf->p_sys;
@@ -145,14 +145,14 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         if( *exp == '\'' )
         {
             /* extract string */
-            p = E_(FirstWord)( exp, exp );
-            E_(SSPush)( st, exp );
+            p = FirstWord( exp, exp );
+            SSPush( st, exp );
             exp = p;
             continue;
         }
 
         /* extract token */
-        p = E_(FirstWord)( exp, exp );
+        p = FirstWord( exp, exp );
         s = exp;
         if( p == NULL )
         {
@@ -171,129 +171,129 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         /* 1. Integer function */
         if( !strcmp( s, "!" ) )
         {
-            E_(SSPushN)( st, ~E_(SSPopN)( st, vars ) );
+            SSPushN( st, ~SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "^" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) ^ E_(SSPopN)( st, vars ) );
+            SSPushN( st, SSPopN( st, vars ) ^ SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "&" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) & E_(SSPopN)( st, vars ) );
+            SSPushN( st, SSPopN( st, vars ) & SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "|" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) | E_(SSPopN)( st, vars ) );
+            SSPushN( st, SSPopN( st, vars ) | SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "+" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) + E_(SSPopN)( st, vars ) );
+            SSPushN( st, SSPopN( st, vars ) + SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "-" ) )
         {
-            int j = E_(SSPopN)( st, vars );
-            int i = E_(SSPopN)( st, vars );
-            E_(SSPushN)( st, i - j );
+            int j = SSPopN( st, vars );
+            int i = SSPopN( st, vars );
+            SSPushN( st, i - j );
         }
         else if( !strcmp( s, "*" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) * E_(SSPopN)( st, vars ) );
+            SSPushN( st, SSPopN( st, vars ) * SSPopN( st, vars ) );
         }
         else if( !strcmp( s, "/" ) )
         {
             int i, j;
 
-            j = E_(SSPopN)( st, vars );
-            i = E_(SSPopN)( st, vars );
+            j = SSPopN( st, vars );
+            i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, j != 0 ? i / j : 0 );
+            SSPushN( st, j != 0 ? i / j : 0 );
         }
         else if( !strcmp( s, "%" ) )
         {
             int i, j;
 
-            j = E_(SSPopN)( st, vars );
-            i = E_(SSPopN)( st, vars );
+            j = SSPopN( st, vars );
+            i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, j != 0 ? i % j : 0 );
+            SSPushN( st, j != 0 ? i % j : 0 );
         }
         /* 2. integer tests */
         else if( !strcmp( s, "=" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) == E_(SSPopN)( st, vars ) ? -1 : 0 );
+            SSPushN( st, SSPopN( st, vars ) == SSPopN( st, vars ) ? -1 : 0 );
         }
         else if( !strcmp( s, "!=" ) )
         {
-            E_(SSPushN)( st, E_(SSPopN)( st, vars ) != E_(SSPopN)( st, vars ) ? -1 : 0 );
+            SSPushN( st, SSPopN( st, vars ) != SSPopN( st, vars ) ? -1 : 0 );
         }
         else if( !strcmp( s, "<" ) )
         {
-            int j = E_(SSPopN)( st, vars );
-            int i = E_(SSPopN)( st, vars );
+            int j = SSPopN( st, vars );
+            int i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, i < j ? -1 : 0 );
+            SSPushN( st, i < j ? -1 : 0 );
         }
         else if( !strcmp( s, ">" ) )
         {
-            int j = E_(SSPopN)( st, vars );
-            int i = E_(SSPopN)( st, vars );
+            int j = SSPopN( st, vars );
+            int i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, i > j ? -1 : 0 );
+            SSPushN( st, i > j ? -1 : 0 );
         }
         else if( !strcmp( s, "<=" ) )
         {
-            int j = E_(SSPopN)( st, vars );
-            int i = E_(SSPopN)( st, vars );
+            int j = SSPopN( st, vars );
+            int i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, i <= j ? -1 : 0 );
+            SSPushN( st, i <= j ? -1 : 0 );
         }
         else if( !strcmp( s, ">=" ) )
         {
-            int j = E_(SSPopN)( st, vars );
-            int i = E_(SSPopN)( st, vars );
+            int j = SSPopN( st, vars );
+            int i = SSPopN( st, vars );
 
-            E_(SSPushN)( st, i >= j ? -1 : 0 );
+            SSPushN( st, i >= j ? -1 : 0 );
         }
         /* 3. string functions */
         else if( !strcmp( s, "strcat" ) )
         {
-            char *s2 = E_(SSPop)( st );
-            char *s1 = E_(SSPop)( st );
+            char *s2 = SSPop( st );
+            char *s1 = SSPop( st );
             char *str = malloc( strlen( s1 ) + strlen( s2 ) + 1 );
 
             strcpy( str, s1 );
             strcat( str, s2 );
 
-            E_(SSPush)( st, str );
+            SSPush( st, str );
             free( s1 );
             free( s2 );
             free( str );
         }
         else if( !strcmp( s, "strcmp" ) )
         {
-            char *s2 = E_(SSPop)( st );
-            char *s1 = E_(SSPop)( st );
+            char *s2 = SSPop( st );
+            char *s1 = SSPop( st );
 
-            E_(SSPushN)( st, strcmp( s1, s2 ) );
+            SSPushN( st, strcmp( s1, s2 ) );
             free( s1 );
             free( s2 );
         }
         else if( !strcmp( s, "strncmp" ) )
         {
-            int n = E_(SSPopN)( st, vars );
-            char *s2 = E_(SSPop)( st );
-            char *s1 = E_(SSPop)( st );
+            int n = SSPopN( st, vars );
+            char *s2 = SSPop( st );
+            char *s1 = SSPop( st );
 
-            E_(SSPushN)( st, strncmp( s1, s2 , n ) );
+            SSPushN( st, strncmp( s1, s2 , n ) );
             free( s1 );
             free( s2 );
         }
         else if( !strcmp( s, "strsub" ) )
         {
-            int n = E_(SSPopN)( st, vars );
-            int m = E_(SSPopN)( st, vars );
+            int n = SSPopN( st, vars );
+            int m = SSPopN( st, vars );
             int i_len;
-            char *s = E_(SSPop)( st );
+            char *s = SSPop( st );
             char *str;
 
             if( n >= m )
@@ -310,22 +310,22 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             memcpy( str, s + m - 1, i_len );
             str[ i_len ] = '\0';
 
-            E_(SSPush)( st, str );
+            SSPush( st, str );
             free( s );
             free( str );
         }
         else if( !strcmp( s, "strlen" ) )
         {
-            char *str = E_(SSPop)( st );
+            char *str = SSPop( st );
 
-            E_(SSPushN)( st, strlen( str ) );
+            SSPushN( st, strlen( str ) );
             free( str );
         }
         else if( !strcmp( s, "str_replace" ) )
         {
-            char *psz_to = E_(SSPop)( st );
-            char *psz_from = E_(SSPop)( st );
-            char *psz_in = E_(SSPop)( st );
+            char *psz_to = SSPop( st );
+            char *psz_from = SSPop( st );
+            char *psz_in = SSPop( st );
             char *psz_in_current = psz_in;
             char *psz_out = malloc( strlen(psz_in) * strlen(psz_to) + 1 );
             char *psz_out_current = psz_out;
@@ -342,7 +342,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             psz_out_current += strlen(psz_in_current);
             *psz_out_current = '\0';
 
-            E_(SSPush)( st, psz_out );
+            SSPush( st, psz_out );
             free( psz_to );
             free( psz_from );
             free( psz_in );
@@ -350,31 +350,31 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "url_extract" ) )
         {
-            char *url = E_(mvar_GetValue)( vars, "url_value" );
-            char *name = E_(SSPop)( st );
-            char *value = E_(ExtractURIString)( url, name );
+            char *url = mvar_GetValue( vars, "url_value" );
+            char *name = SSPop( st );
+            char *value = ExtractURIString( url, name );
             if( value != NULL )
             {
                 decode_URI( value );
-                E_(SSPush)( st, value );
+                SSPush( st, value );
                 free( value );
             }
             else
-                E_(SSPush)( st, "" );
+                SSPush( st, "" );
 
             free( name );
         }
         else if( !strcmp( s, "url_encode" ) )
         {
-            char *url = E_(SSPop)( st );
+            char *url = SSPop( st );
             char *value = vlc_UrlEncode( url );
             free( url );
-            E_(SSPush)( st, value );
+            SSPush( st, value );
             free( value );
         }
         else if( !strcmp( s, "addslashes" ) )
         {
-            char *psz_src = E_(SSPop)( st );
+            char *psz_src = SSPop( st );
             char *psz_dest;
             char *str = psz_src;
 
@@ -391,13 +391,13 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             }
             *p = '\0';
 
-            E_(SSPush)( st, psz_dest );
+            SSPush( st, psz_dest );
             free( psz_src );
             free( psz_dest );
         }
         else if( !strcmp( s, "stripslashes" ) )
         {
-            char *psz_src = E_(SSPop)( st );
+            char *psz_src = SSPop( st );
             char *psz_dest;
             char *str = psz_src;
 
@@ -413,80 +413,80 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             }
             *p = '\0';
 
-            E_(SSPush)( st, psz_dest );
+            SSPush( st, psz_dest );
             free( psz_src );
             free( psz_dest );
         }
         else if( !strcmp( s, "htmlspecialchars" ) )
         {
-            char *psz_src = E_(SSPop)( st );
+            char *psz_src = SSPop( st );
             char *psz_dest;
 
             psz_dest = convert_xml_special_chars( psz_src );
 
-            E_(SSPush)( st, psz_dest );
+            SSPush( st, psz_dest );
             free( psz_src );
             free( psz_dest );
         }
         else if( !strcmp( s, "realpath" ) )
         {
-            char *psz_src = E_(SSPop)( st );
-            char *psz_dir = E_(RealPath)( p_intf, psz_src );
+            char *psz_src = SSPop( st );
+            char *psz_dir = RealPath( p_intf, psz_src );
 
-            E_(SSPush)( st, psz_dir );
+            SSPush( st, psz_dir );
             free( psz_src );
             free( psz_dir );
         }
         /* 4. stack functions */
         else if( !strcmp( s, "dup" ) )
         {
-            char *str = E_(SSPop)( st );
-            E_(SSPush)( st, str );
-            E_(SSPush)( st, str );
+            char *str = SSPop( st );
+            SSPush( st, str );
+            SSPush( st, str );
             free( str );
         }
         else if( !strcmp( s, "drop" ) )
         {
-            char *str = E_(SSPop)( st );
+            char *str = SSPop( st );
             free( str );
         }
         else if( !strcmp( s, "swap" ) )
         {
-            char *s1 = E_(SSPop)( st );
-            char *s2 = E_(SSPop)( st );
+            char *s1 = SSPop( st );
+            char *s2 = SSPop( st );
 
-            E_(SSPush)( st, s1 );
-            E_(SSPush)( st, s2 );
+            SSPush( st, s1 );
+            SSPush( st, s2 );
             free( s1 );
             free( s2 );
         }
         else if( !strcmp( s, "flush" ) )
         {
-            E_(SSClean)( st );
-            E_(SSInit)( st );
+            SSClean( st );
+            SSInit( st );
         }
         else if( !strcmp( s, "store" ) )
         {
-            char *value = E_(SSPop)( st );
-            char *name  = E_(SSPop)( st );
+            char *value = SSPop( st );
+            char *name  = SSPop( st );
 
-            E_(mvar_PushNewVar)( vars, name, value );
+            mvar_PushNewVar( vars, name, value );
             free( name );
             free( value );
         }
         else if( !strcmp( s, "value" ) )
         {
-            char *name  = E_(SSPop)( st );
-            char *value = E_(mvar_GetValue)( vars, name );
+            char *name  = SSPop( st );
+            char *value = mvar_GetValue( vars, name );
 
-            E_(SSPush)( st, value );
+            SSPush( st, value );
 
             free( name );
         }
         /* 5. player control */
         else if( !strcmp( s, "vlc_play" ) )
         {
-            int i_id = E_(SSPopN)( st, vars );
+            int i_id = SSPopN( st, vars );
             int i_ret;
 
             i_ret = playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
@@ -494,7 +494,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                                       playlist_ItemGetById( p_sys->p_playlist,
                                       i_id, true ) );
             msg_Dbg( p_intf, "requested playlist item: %i", i_id );
-            E_(SSPushN)( st, i_ret );
+            SSPushN( st, i_ret );
         }
         else if( !strcmp( s, "vlc_stop" ) )
         {
@@ -518,8 +518,8 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "vlc_seek" ) )
         {
-            char *psz_value = E_(SSPop)( st );
-            E_(HandleSeek)( p_intf, psz_value );
+            char *psz_value = SSPop( st );
+            HandleSeek( p_intf, psz_value );
             msg_Dbg( p_intf, "requested playlist seek: %s", psz_value );
             free( psz_value );
         }
@@ -532,8 +532,8 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
 
             if( !strcmp( s, "vlc_var_type" ) )
             {
-                char *psz_object = E_(SSPop)( st );
-                char *psz_variable = E_(SSPop)( st );
+                char *psz_object = SSPop( st );
+                char *psz_variable = SSPop( st );
                 bool b_need_release;
 
                 p_object = GetVLCObject( p_intf, psz_object, &b_need_release );
@@ -547,7 +547,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             }
             else
             {
-                char *psz_variable = E_(SSPop)( st );
+                char *psz_variable = SSPop( st );
                 p_object = VLC_OBJECT(p_intf);
                 i_type = config_GetType( p_object, psz_variable );
                 free( psz_variable );
@@ -591,12 +591,12 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             else
                 psz_type = "INVALID";
 
-            E_(SSPush)( st, psz_type );
+            SSPush( st, psz_type );
         }
         else if( !strcmp( s, "vlc_var_set" ) )
         {
-            char *psz_object = E_(SSPop)( st );
-            char *psz_variable = E_(SSPop)( st );
+            char *psz_object = SSPop( st );
+            char *psz_variable = SSPop( st );
             bool b_need_release;
 
             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
@@ -614,13 +614,13 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                 switch( i_type & VLC_VAR_TYPE )
                 {
                 case VLC_VAR_BOOL:
-                    val.b_bool = E_(SSPopN)( st, vars );
+                    val.b_bool = SSPopN( st, vars );
                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
                              psz_object, psz_variable, val.b_bool );
                     break;
                 case VLC_VAR_INTEGER:
                 case VLC_VAR_HOTKEY:
-                    val.i_int = E_(SSPopN)( st, vars );
+                    val.i_int = SSPopN( st, vars );
                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
                              psz_object, psz_variable, val.i_int );
                     break;
@@ -629,18 +629,18 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                 case VLC_VAR_FILE:
                 case VLC_VAR_DIRECTORY:
                 case VLC_VAR_VARIABLE:
-                    val.psz_string = psz_value = E_(SSPop)( st );
+                    val.psz_string = psz_value = SSPop( st );
                     msg_Dbg( p_intf, "requested %s var change: %s->%s",
                              psz_object, psz_variable, psz_value );
                     break;
                 case VLC_VAR_FLOAT:
-                    psz_value = E_(SSPop)( st );
+                    psz_value = SSPop( st );
                     val.f_float = atof( psz_value );
                     msg_Dbg( p_intf, "requested %s var change: %s->%f",
                              psz_object, psz_variable, val.f_float );
                     break;
                 default:
-                    E_(SSPopN)( st, vars );
+                    SSPopN( st, vars );
                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
                     b_error = true;
@@ -661,8 +661,8 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "vlc_var_get" ) )
         {
-            char *psz_object = E_(SSPop)( st );
-            char *psz_variable = E_(SSPop)( st );
+            char *psz_object = SSPop( st );
+            char *psz_variable = SSPop( st );
             bool b_need_release;
 
             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
@@ -679,18 +679,18 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                 switch( i_type & VLC_VAR_TYPE )
                 {
                 case VLC_VAR_BOOL:
-                    E_(SSPushN)( st, val.b_bool );
+                    SSPushN( st, val.b_bool );
                     break;
                 case VLC_VAR_INTEGER:
                 case VLC_VAR_HOTKEY:
-                    E_(SSPushN)( st, val.i_int );
+                    SSPushN( st, val.i_int );
                     break;
                 case VLC_VAR_STRING:
                 case VLC_VAR_MODULE:
                 case VLC_VAR_FILE:
                 case VLC_VAR_DIRECTORY:
                 case VLC_VAR_VARIABLE:
-                    E_(SSPush)( st, val.psz_string );
+                    SSPush( st, val.psz_string );
                     free( val.psz_string );
                     break;
                 case VLC_VAR_FLOAT:
@@ -699,19 +699,19 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                     lldiv_t value = lldiv( val.f_float * 1000000, 1000000 );
                     snprintf( psz_value, sizeof(psz_value), "%lld.%06u",
                                     value.quot, (unsigned int)value.rem );
-                    E_(SSPush)( st, psz_value );
+                    SSPush( st, psz_value );
                     break;
                 }
                 default:
                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
-                    E_(SSPush)( st, "" );
+                    SSPush( st, "" );
                 }
             }
             else
             {
                 msg_Warn( p_intf, "vlc_var_get called without an object" );
-                E_(SSPush)( st, "" );
+                SSPush( st, "" );
             }
             free( psz_variable );
             free( psz_object );
@@ -721,7 +721,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "vlc_object_exists" ) )
         {
-            char *psz_object = E_(SSPop)( st );
+            char *psz_object = SSPop( st );
             bool b_need_release;
 
             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
@@ -730,34 +730,34 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                 vlc_object_release( p_object );
 
             if( p_object != NULL )
-                E_(SSPush)( st, "1" );
+                SSPush( st, "1" );
             else
-                E_(SSPush)( st, "0" );
+                SSPush( st, "0" );
         }
         else if( !strcmp( s, "vlc_config_set" ) )
         {
-            char *psz_variable = E_(SSPop)( st );
+            char *psz_variable = SSPop( st );
             int i_type = config_GetType( p_intf, psz_variable );
 
             switch( i_type & VLC_VAR_TYPE )
             {
             case VLC_VAR_BOOL:
             case VLC_VAR_INTEGER:
-                config_PutInt( p_intf, psz_variable, E_(SSPopN)( st, vars ) );
+                config_PutInt( p_intf, psz_variable, SSPopN( st, vars ) );
                 break;
             case VLC_VAR_STRING:
             case VLC_VAR_MODULE:
             case VLC_VAR_FILE:
             case VLC_VAR_DIRECTORY:
             {
-                char *psz_string = E_(SSPop)( st );
+                char *psz_string = SSPop( st );
                 config_PutPsz( p_intf, psz_variable, psz_string );
                 free( psz_string );
                 break;
             }
             case VLC_VAR_FLOAT:
             {
-                char *psz_string = E_(SSPop)( st );
+                char *psz_string = SSPop( st );
                 config_PutFloat( p_intf, psz_variable, atof(psz_string) );
                 free( psz_string );
                 break;
@@ -770,14 +770,14 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "vlc_config_get" ) )
         {
-            char *psz_variable = E_(SSPop)( st );
+            char *psz_variable = SSPop( st );
             int i_type = config_GetType( p_intf, psz_variable );
 
             switch( i_type & VLC_VAR_TYPE )
             {
             case VLC_VAR_BOOL:
             case VLC_VAR_INTEGER:
-                E_(SSPushN)( st, config_GetInt( p_intf, psz_variable ) );
+                SSPushN( st, config_GetInt( p_intf, psz_variable ) );
                 break;
             case VLC_VAR_STRING:
             case VLC_VAR_MODULE:
@@ -785,7 +785,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
             case VLC_VAR_DIRECTORY:
             {
                 char *psz_string = config_GetPsz( p_intf, psz_variable );
-                E_(SSPush)( st, psz_string );
+                SSPush( st, psz_string );
                 free( psz_string );
                 break;
             }
@@ -796,19 +796,19 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                                        * 1000000, 1000000 );
                 snprintf( psz_string, sizeof(psz_string), "%lld.%06u",
                           value.quot, (unsigned int)value.rem );
-                E_(SSPush)( st, psz_string );
+                SSPush( st, psz_string );
                 break;
             }
             default:
                 msg_Warn( p_intf, "vlc_config_get called on unknown var (%s)",
                           psz_variable );
-                E_(SSPush)( st, "" );
+                SSPush( st, "" );
             }
             free( psz_variable );
         }
         else if( !strcmp( s, "vlc_config_save" ) )
         {
-            char *psz_module = E_(SSPop)( st );
+            char *psz_module = SSPop( st );
             int i_result;
 
             if( !*psz_module )
@@ -820,7 +820,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
 
             if( psz_module != NULL )
                 free( psz_module );
-            E_(SSPushN)( st, i_result );
+            SSPushN( st, i_result );
         }
         else if( !strcmp( s, "vlc_config_reset" ) )
         {
@@ -829,12 +829,12 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         /* 6. playlist functions */
         else if( !strcmp( s, "playlist_add" ) )
         {
-            char *psz_name = E_(SSPop)( st );
-            char *mrl = E_(SSPop)( st );
+            char *psz_name = SSPop( st );
+            char *mrl = SSPop( st );
             input_item_t *p_input;
             int i_ret;
 
-            p_input = E_(MRLParse)( p_intf, mrl, psz_name );
+            p_input = MRLParse( p_intf, mrl, psz_name );
 
             char *psz_uri = input_item_GetURI( p_input );
             if( !p_input || !psz_uri || !*psz_uri )
@@ -854,7 +854,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                     msg_Warn( p_intf, "adding mrl %s failed", mrl );
             }
             free( psz_uri );
-            E_(SSPushN)( st, i_ret );
+            SSPushN( st, i_ret );
 
             free( mrl );
             free( psz_name );
@@ -866,7 +866,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "playlist_delete" ) )
         {
-            int i_id = E_(SSPopN)( st, vars );
+            int i_id = SSPopN( st, vars );
             playlist_item_t *p_item = playlist_ItemGetById( p_sys->p_playlist,
                                                             i_id, false );
             if( p_item )
@@ -883,8 +883,8 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "playlist_move" ) )
         {
-            /*int i_newpos =*/ E_(SSPopN)( st, vars );
-            /*int i_pos =*/ E_(SSPopN)( st, vars );
+            /*int i_newpos =*/ SSPopN( st, vars );
+            /*int i_pos =*/ SSPopN( st, vars );
             /* FIXME FIXME TODO TODO XXX XXX
             do not release before fixing this
             if ( i_pos < i_newpos )
@@ -902,8 +902,8 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "playlist_sort" ) )
         {
-            int i_order = E_(SSPopN)( st, vars );
-            int i_sort = E_(SSPopN)( st, vars );
+            int i_order = SSPopN( st, vars );
+            int i_sort = SSPopN( st, vars );
             i_order = i_order % 2;
             i_sort = i_sort % 9;
             /* FIXME FIXME TODO TODO XXX XXX
@@ -918,26 +918,26 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "services_discovery_add" ) )
         {
-            char *psz_sd = E_(SSPop)( st );
+            char *psz_sd = SSPop( st );
             playlist_ServicesDiscoveryAdd( p_sys->p_playlist, psz_sd );
             free( psz_sd );
         }
         else if( !strcmp( s, "services_discovery_remove" ) )
         {
-            char *psz_sd = E_(SSPop)( st );
+            char *psz_sd = SSPop( st );
             playlist_ServicesDiscoveryRemove( p_sys->p_playlist, psz_sd );
             free( psz_sd );
         }
         else if( !strcmp( s, "services_discovery_is_loaded" ) )
         {
-            char *psz_sd = E_(SSPop)( st );
-            E_(SSPushN)( st,
+            char *psz_sd = SSPop( st );
+            SSPushN( st,
             playlist_IsServicesDiscoveryLoaded( p_sys->p_playlist, psz_sd ) );
             free( psz_sd );
         }
         else if( !strcmp( s, "vlc_volume_set" ) )
         {
-            char *psz_vol = E_(SSPop)( st );
+            char *psz_vol = SSPop( st );
             int i_value;
             audio_volume_t i_volume;
             aout_VolumeGet( p_intf, &i_volume );
@@ -976,7 +976,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else if( !strcmp( s, "vlc_get_meta" ) )
         {
-            char *psz_meta = E_(SSPop)( st );
+            char *psz_meta = SSPop( st );
             char *psz_val = NULL;
             if( p_sys->p_input && input_GetItem(p_sys->p_input) )
             {
@@ -1002,7 +1002,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
 #undef p_item
             }
             if( psz_val == NULL ) psz_val = strdup( "" );
-            E_(SSPush)( st, psz_val );
+            SSPush( st, psz_val );
             free( psz_meta );
             free( psz_val );
         }
@@ -1020,7 +1020,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
 
             /* vlm command uses the ';' delimiter
              * (else we can't know when to stop) */
-            while( strcmp( psz_elt = E_(SSPop)( st ), "" )
+            while( strcmp( psz_elt = SSPop( st ), "" )
                    && strcmp( psz_elt, ";" ) )
             {
                 char *psz_buf =
@@ -1047,10 +1047,10 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
                                                  vlm_answer->psz_value );
             }
 
-            E_(mvar_AppendNewVar)( vars, "vlm_error", psz_error );
+            mvar_AppendNewVar( vars, "vlm_error", psz_error );
             /* this is kind of a duplicate but we need to have the message
              * without the command name for the "export" command */
-            E_(mvar_AppendNewVar)( vars, "vlm_value", vlm_answer->psz_value );
+            mvar_AppendNewVar( vars, "vlm_value", vlm_answer->psz_value );
             vlm_MessageDelete( vlm_answer );
 
             free( psz_cmd );
@@ -1076,7 +1076,7 @@ void E_(EvaluateRPN)( intf_thread_t *p_intf, mvar_t  *vars,
         }
         else
         {
-            E_(SSPush)( st, s );
+            SSPush( st, s );
         }
     }
 }
index ad8b997..b85857a 100644 (file)
@@ -36,7 +36,7 @@
  ****************************************************************************/
 
 /* ToUrl: create a good name for an url from filename */
-char *E_(FileToUrl)( char *name, bool *pb_index )
+char *FileToUrl( char *name, bool *pb_index )
 {
     char *url, *p;
 
@@ -84,7 +84,7 @@ char *E_(FileToUrl)( char *name, bool *pb_index )
 }
 
 /* Load a file */
-int E_(FileLoad)( FILE *f, char **pp_data, int *pi_data )
+int FileLoad( FILE *f, char **pp_data, int *pi_data )
 {
     int i_read;
 
@@ -106,7 +106,7 @@ int E_(FileLoad)( FILE *f, char **pp_data, int *pi_data )
 }
 
 /* Parse a directory and recursively add files */
-int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
+int ParseDirectory( intf_thread_t *p_intf, char *psz_root,
                         char *psz_dir )
 {
     intf_sys_t     *p_sys = p_intf->p_sys;
@@ -214,14 +214,14 @@ int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
         snprintf( dir, sizeof( dir ), "%s%c%s", psz_dir, sep, psz_filename );
         free( psz_filename );
 
-        if( E_(ParseDirectory)( p_intf, psz_root, dir ) )
+        if( ParseDirectory( p_intf, psz_root, dir ) )
         {
             httpd_file_sys_t *f = NULL;
             httpd_handler_sys_t *h = NULL;
             bool b_index;
             char *psz_name, *psz_ext;
 
-            psz_name = E_(FileToUrl)( &dir[strlen( psz_root )], &b_index );
+            psz_name = FileToUrl( &dir[strlen( psz_root )], &b_index );
             psz_ext = strrchr( dir, '.' );
             if( psz_ext != NULL )
             {
@@ -281,7 +281,7 @@ int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
                                            f->name,
                                            f->b_html ? psz_type : NULL,
                                            user, password, p_acl,
-                                           E_(HttpCallback), f );
+                                           HttpCallback, f );
                 free( psz_type );
                 if( f->p_file != NULL )
                 {
@@ -293,7 +293,7 @@ int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
                 h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
                                                  f->name,
                                                  user, password, p_acl,
-                                                 E_(HandlerCallback), h );
+                                                 HandlerCallback, h );
                 if( h->p_handler != NULL )
                 {
                     TAB_APPEND( p_sys->i_files, p_sys->pp_files,
@@ -341,7 +341,7 @@ int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
 /*************************************************************************
  * Playlist stuff
  *************************************************************************/
-void E_(PlaylistListNode)( intf_thread_t *p_intf, playlist_t *p_pl,
+void PlaylistListNode( intf_thread_t *p_intf, playlist_t *p_pl,
                            playlist_item_t *p_node, char *name, mvar_t *s,
                            int i_depth )
 {
@@ -351,85 +351,85 @@ void E_(PlaylistListNode)( intf_thread_t *p_intf, playlist_t *p_pl,
         {
             char value[512];
             char *psz;
-            mvar_t *itm = E_(mvar_New)( name, "set" );
+            mvar_t *itm = mvar_New( name, "set" );
 
             if( p_pl->status.p_item && p_node &&
                 p_pl->status.p_item->p_input && p_node->p_input &&
                 p_pl->status.p_item->p_input->i_id == p_node->p_input->i_id )
             {
-                E_(mvar_AppendNewVar)( itm, "current", "1" );
+                mvar_AppendNewVar( itm, "current", "1" );
             }
             else
             {
-                E_(mvar_AppendNewVar)( itm, "current", "0" );
+                mvar_AppendNewVar( itm, "current", "0" );
             }
 
             sprintf( value, "%d", p_node->i_id );
-            E_(mvar_AppendNewVar)( itm, "index", value );
+            mvar_AppendNewVar( itm, "index", value );
 
             psz = input_item_GetName( p_node->p_input );
-            E_(mvar_AppendNewVar)( itm, "name", psz );
+            mvar_AppendNewVar( itm, "name", psz );
             free( psz );
 
             psz = input_item_GetURI( p_node->p_input );
-            E_(mvar_AppendNewVar)( itm, "uri", psz );
+            mvar_AppendNewVar( itm, "uri", psz );
             free( psz );
 
             sprintf( value, "Item");
-            E_(mvar_AppendNewVar)( itm, "type", value );
+            mvar_AppendNewVar( itm, "type", value );
 
             sprintf( value, "%d", i_depth );
-            E_(mvar_AppendNewVar)( itm, "depth", value );
+            mvar_AppendNewVar( itm, "depth", value );
 
             if( p_node->i_flags & PLAYLIST_RO_FLAG )
             {
-                E_(mvar_AppendNewVar)( itm, "ro", "ro" );
+                mvar_AppendNewVar( itm, "ro", "ro" );
             }
             else
             {
-                E_(mvar_AppendNewVar)( itm, "ro", "rw" );
+                mvar_AppendNewVar( itm, "ro", "rw" );
             }
 
             sprintf( value, "%ld",
                     (long) input_item_GetDuration( p_node->p_input ) );
-            E_(mvar_AppendNewVar)( itm, "duration", value );
+            mvar_AppendNewVar( itm, "duration", value );
 
-            E_(mvar_AppendVar)( s, itm );
+            mvar_AppendVar( s, itm );
         }
         else
         {
             char value[512];
             int i_child;
-            mvar_t *itm = E_(mvar_New)( name, "set" );
+            mvar_t *itm = mvar_New( name, "set" );
 
-            E_(mvar_AppendNewVar)( itm, "name", p_node->p_input->psz_name );
-            E_(mvar_AppendNewVar)( itm, "uri", p_node->p_input->psz_name );
+            mvar_AppendNewVar( itm, "name", p_node->p_input->psz_name );
+            mvar_AppendNewVar( itm, "uri", p_node->p_input->psz_name );
 
             sprintf( value, "Node" );
-            E_(mvar_AppendNewVar)( itm, "type", value );
+            mvar_AppendNewVar( itm, "type", value );
 
             sprintf( value, "%d", p_node->i_id );
-            E_(mvar_AppendNewVar)( itm, "index", value );
+            mvar_AppendNewVar( itm, "index", value );
 
             sprintf( value, "%d", p_node->i_children);
-            E_(mvar_AppendNewVar)( itm, "i_children", value );
+            mvar_AppendNewVar( itm, "i_children", value );
 
             sprintf( value, "%d", i_depth );
-            E_(mvar_AppendNewVar)( itm, "depth", value );
+            mvar_AppendNewVar( itm, "depth", value );
 
             if( p_node->i_flags & PLAYLIST_RO_FLAG )
             {
-                E_(mvar_AppendNewVar)( itm, "ro", "ro" );
+                mvar_AppendNewVar( itm, "ro", "ro" );
             }
             else
             {
-                E_(mvar_AppendNewVar)( itm, "ro", "rw" );
+                mvar_AppendNewVar( itm, "ro", "rw" );
             }
 
-            E_(mvar_AppendVar)( s, itm );
+            mvar_AppendVar( s, itm );
 
             for (i_child = 0 ; i_child < p_node->i_children ; i_child++)
-                E_(PlaylistListNode)( p_intf, p_pl,
+                PlaylistListNode( p_intf, p_pl,
                                       p_node->pp_children[i_child],
                                       name, s, i_depth + 1);
 
@@ -440,7 +440,7 @@ void E_(PlaylistListNode)( intf_thread_t *p_intf, playlist_t *p_pl,
 /****************************************************************************
  * Seek command parsing handling
  ****************************************************************************/
-void E_(HandleSeek)( intf_thread_t *p_intf, char *p_value )
+void HandleSeek( intf_thread_t *p_intf, char *p_value )
 {
     intf_sys_t     *p_sys = p_intf->p_sys;
     vlc_value_t val;
@@ -632,7 +632,7 @@ void E_(HandleSeek)( intf_thread_t *p_intf, char *p_value )
 /****************************************************************************
  * URI Parsing functions
  ****************************************************************************/
-int E_(TestURIParam)( char *psz_uri, const char *psz_name )
+int TestURIParam( char *psz_uri, const char *psz_name )
 {
     char *p = psz_uri;
 
@@ -695,7 +695,7 @@ static char *FindURIValue( char *psz_uri, const char *restrict psz_name,
     return p;
 }
 
-char *E_(ExtractURIValue)( char *restrict psz_uri,
+char *ExtractURIValue( char *restrict psz_uri,
                            const char *restrict psz_name,
                            char *restrict psz_buf, size_t bufsize )
 {
@@ -723,7 +723,7 @@ char *E_(ExtractURIValue)( char *restrict psz_uri,
     return psz_next;
 }
 
-char *E_(ExtractURIString)( char *restrict psz_uri,
+char *ExtractURIString( char *restrict psz_uri,
                             const char *restrict psz_name )
 {
     size_t len;
@@ -745,7 +745,7 @@ char *E_(ExtractURIString)( char *restrict psz_uri,
 /* Since the resulting string is smaller we can work in place, so it is
  * permitted to have psz == new. new points to the first word of the
  * string, the function returns the remaining string. */
-char *E_(FirstWord)( char *psz, char *new )
+char *FirstWord( char *psz, char *new )
 {
     bool b_end;
 
@@ -833,7 +833,7 @@ static char *FirstOption( char *psz, char *new )
         return NULL;
 }
 
-input_item_t *E_(MRLParse)( intf_thread_t *p_intf, char *_psz,
+input_item_t *MRLParse( intf_thread_t *p_intf, char *_psz,
                                    char *psz_name )
 {
     char *psz = strdup( _psz );
@@ -872,7 +872,7 @@ input_item_t *E_(MRLParse)( intf_thread_t *p_intf, char *_psz,
 /**********************************************************************
  * RealPath: parse ../, ~ and path stuff
  **********************************************************************/
-char *E_(RealPath)( intf_thread_t *p_intf, const char *psz_src )
+char *RealPath( intf_thread_t *p_intf, const char *psz_src )
 {
     char *psz_dir;
     char *p;
index 8e66b12..ab482b5 100644 (file)
@@ -53,8 +53,8 @@ struct intf_sys_t
 /*****************************************************************************
  * Local prototypes.
  *****************************************************************************/
-int  E_(Open) ( vlc_object_t * );
-void E_(Close)( vlc_object_t * );
+int  Open ( vlc_object_t * );
+void Close( vlc_object_t * );
 static void RunIntf( intf_thread_t *p_intf );
 static int  InitThread( intf_thread_t *p_intf );
 static int  MouseEvent( vlc_object_t *, char const *,
@@ -72,13 +72,13 @@ vlc_module_begin();
     set_description( _("Show interface with mouse") );
 
     set_capability( "interface", 0 );
-    set_callbacks( E_(Open), E_(Close) );
+    set_callbacks( Open, Close );
 vlc_module_end();
 
 /*****************************************************************************
  * Open: initialize interface
  *****************************************************************************/
-int E_(Open)( vlc_object_t *p_this )
+int Open( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 
@@ -97,7 +97,7 @@ int E_(Open)( vlc_object_t *p_this )
 /*****************************************************************************
  * Close: destroy interface
  *****************************************************************************/
-void E_(Close)( vlc_object_t *p_this )
+void Close( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 
index e87f4f1..0bde6e4 100644 (file)
@@ -1851,7 +1851,7 @@ static int ParseASF( demux_t *p_demux )
     }
 
     /* Parse it to get packet size */
-    E_(asf_HeaderParse)( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
+    asf_HeaderParse( &p_sys->asfh, p_header->p_buffer, p_header->i_buffer );
 
     /* Send it to demuxer */
     stream_DemuxSend( p_sys->p_out_asf, p_header );
index 9b487b8..30d056e 100644 (file)
@@ -185,7 +185,7 @@ static int ParseTime(char *s, size_t i_strlen)
 /*****************************************************************************
  * Import_ASX: main import function
  *****************************************************************************/
-int E_(Import_ASX)( vlc_object_t *p_this )
+int Import_ASX( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     const uint8_t *p_peek;
@@ -204,7 +204,7 @@ int E_(Import_ASX)( vlc_object_t *p_this )
         return VLC_EGENERIC;
 
     STANDARD_DEMUX_INIT_MSG( "found valid ASX playlist" );
-    p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux );
+    p_demux->p_sys->psz_prefix = FindPrefix( p_demux );
     p_demux->p_sys->psz_data = NULL;
     p_demux->p_sys->i_data_len = -1;
     p_demux->p_sys->b_utf8 = false;
@@ -216,7 +216,7 @@ int E_(Import_ASX)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_ASX)( vlc_object_t *p_this )
+void Close_ASX( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index c5ffeae..a465071 100644 (file)
@@ -54,11 +54,11 @@ static int IsWhitespace( char *psz_string );
 /*****************************************************************************
  * Import_B4S: main import function
  *****************************************************************************/
-int E_(Import_B4S)( vlc_object_t *p_this )
+int Import_B4S( vlc_object_t *p_this )
 {
     DEMUX_BY_EXTENSION_OR_FORCED_MSG( ".b4s", "b4s-open",
                                       "using B4S playlist reader" );
-    p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux );
+    p_demux->p_sys->psz_prefix = FindPrefix( p_demux );
     p_demux->p_sys->p_xml = NULL;
     p_demux->p_sys->p_xml_reader = NULL;
     return VLC_SUCCESS;
@@ -67,7 +67,7 @@ int E_(Import_B4S)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_B4S)( vlc_object_t *p_this )
+void Close_B4S( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index 34a1b27..098ea55 100644 (file)
@@ -51,7 +51,7 @@ static int ParseLine( char *, char **, char ***, int *);
 /*****************************************************************************
  * Import_DVB: main import function
  *****************************************************************************/
-int E_(Import_DVB)( vlc_object_t *p_this )
+int Import_DVB( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     const uint8_t *p_peek;
@@ -89,7 +89,7 @@ int E_(Import_DVB)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_DVB)( vlc_object_t *p_this )
+void Close_DVB( vlc_object_t *p_this )
 {
     VLC_UNUSED(p_this);
 }
index b5457c2..83c9825 100644 (file)
@@ -74,7 +74,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Import_GVP: main import function
  *****************************************************************************/
-int E_(Import_GVP)( vlc_object_t *p_this )
+int Import_GVP( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     int i_peek, i, b_found = false;
@@ -106,7 +106,7 @@ int E_(Import_GVP)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_GVP)( vlc_object_t *p_this )
+void Close_GVP( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index 5c959d6..c9108d9 100644 (file)
@@ -42,7 +42,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Import_IFO: main import function
  *****************************************************************************/
-int E_(Import_IFO)( vlc_object_t *p_this )
+int Import_IFO( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
 
@@ -77,7 +77,7 @@ int E_(Import_IFO)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_IFO)( vlc_object_t *p_this )
+void Close_IFO( vlc_object_t *p_this )
 {
     VLC_UNUSED(p_this);
 }
index a67f838..3924c2a 100644 (file)
@@ -49,14 +49,14 @@ static int Demux( demux_t * );
 /**
  * \brief iTML submodule initialization function
  */
-int E_(Import_iTML)( vlc_object_t *p_this )
+int Import_iTML( vlc_object_t *p_this )
 {
     DEMUX_BY_EXTENSION_OR_FORCED_MSG( ".xml", "itml",
                                       "using iTunes Media Library reader" );
     return VLC_SUCCESS;
 }
 
-void E_(Close_iTML)( vlc_object_t *p_this )
+void Close_iTML( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     free( p_demux->p_sys );
index b184606..40b862a 100644 (file)
@@ -51,7 +51,7 @@ static void parseEXTINF( char *psz_string, char **ppsz_artist, char **ppsz_name,
 /*****************************************************************************
  * Import_M3U: main import function
  *****************************************************************************/
-int E_(Import_M3U)( vlc_object_t *p_this )
+int Import_M3U( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     const uint8_t *p_peek;
@@ -65,7 +65,7 @@ int E_(Import_M3U)( vlc_object_t *p_this )
         return VLC_EGENERIC;
 
     STANDARD_DEMUX_INIT_MSG( "found valid M3U playlist" );
-    p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux );
+    p_demux->p_sys->psz_prefix = FindPrefix( p_demux );
 
     return VLC_SUCCESS;
 }
@@ -73,7 +73,7 @@ int E_(Import_M3U)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_M3U)( vlc_object_t *p_this )
+void Close_M3U( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     free( p_demux->p_sys->psz_prefix );
@@ -176,7 +176,7 @@ static int Demux( demux_t *p_demux )
                 psz_name = MaybeFromLocaleDup( psz_parse );
             }
 
-            psz_mrl = E_(ProcessMRL)( psz_parse, p_demux->p_sys->psz_prefix );
+            psz_mrl = ProcessMRL( psz_parse, p_demux->p_sys->psz_prefix );
             MaybeFromLocaleRep( &psz_mrl );
 
             b_cleanup = true;
index 0ecceb8..02637e8 100644 (file)
@@ -70,69 +70,69 @@ vlc_module_begin();
         set_description( _("M3U playlist import") );
         add_shortcut( "m3u-open" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_M3U), E_(Close_M3U) );
+        set_callbacks( Import_M3U, Close_M3U );
     add_submodule();
         set_description( _("PLS playlist import") );
         add_shortcut( "pls-open" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_PLS), E_(Close_PLS) );
+        set_callbacks( Import_PLS, Close_PLS );
     add_submodule();
         set_description( _("B4S playlist import") );
         add_shortcut( "b4s-open" );
         add_shortcut( "shout-b4s" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_B4S), E_(Close_B4S) );
+        set_callbacks( Import_B4S, Close_B4S );
     add_submodule();
         set_description( _("DVB playlist import") );
         add_shortcut( "dvb-open" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_DVB), E_(Close_DVB) );
+        set_callbacks( Import_DVB, Close_DVB );
     add_submodule();
         set_description( _("Podcast parser") );
         add_shortcut( "podcast" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_podcast), E_(Close_podcast) );
+        set_callbacks( Import_podcast, Close_podcast );
     add_submodule();
         set_description( _("XSPF playlist import") );
         add_shortcut( "xspf-open" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_xspf),E_(Close_xspf) );
+        set_callbacks( Import_xspf, Close_xspf );
     add_submodule();
         set_description( _("New winamp 5.2 shoutcast import") );
         add_shortcut( "shout-winamp" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_Shoutcast), E_(Close_Shoutcast) );
+        set_callbacks( Import_Shoutcast, Close_Shoutcast );
         add_bool( "shoutcast-show-adult", false, NULL,
                    SHOW_ADULT_TEXT, SHOW_ADULT_LONGTEXT, false );
     add_submodule();
         set_description( _("ASX playlist import") );
         add_shortcut( "asx-open" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_ASX), E_(Close_ASX) );
+        set_callbacks( Import_ASX, Close_ASX );
     add_submodule();
         set_description( _("Kasenna MediaBase parser") );
         add_shortcut( "sgimb" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_SGIMB), E_(Close_SGIMB) );
+        set_callbacks( Import_SGIMB, Close_SGIMB );
     add_submodule();
         set_description( _("QuickTime Media Link importer") );
         add_shortcut( "qtl" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_QTL), E_(Close_QTL) );
+        set_callbacks( Import_QTL, Close_QTL );
     add_submodule();
         set_description( _("Google Video Playlist importer") );
         add_shortcut( "gvp" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_GVP), E_(Close_GVP) );
+        set_callbacks( Import_GVP, Close_GVP );
     add_submodule();
         set_description( _("Dummy ifo demux") );
         set_capability( "demux", 12 );
-        set_callbacks( E_(Import_IFO), E_(Close_IFO) );
+        set_callbacks( Import_IFO, Close_IFO );
     add_submodule();
         set_description( _("iTunes Music Library importer") );
         add_shortcut( "itml" );
         set_capability( "demux", 10 );
-        set_callbacks( E_(Import_iTML), E_(Close_iTML) );
+        set_callbacks( Import_iTML, Close_iTML );
 vlc_module_end();
 
 
@@ -140,7 +140,7 @@ vlc_module_end();
  * Find directory part of the path to the playlist file, in case of
  * relative paths inside
  */
-char *E_(FindPrefix)( demux_t *p_demux )
+char *FindPrefix( demux_t *p_demux )
 {
     char *psz_name;
     char *psz_path = strdup( p_demux->psz_path );
@@ -161,7 +161,7 @@ char *E_(FindPrefix)( demux_t *p_demux )
  * Add the directory part of the playlist file to the start of the
  * mrl, if the mrl is a relative file path
  */
-char *E_(ProcessMRL)( char *psz_mrl, char *psz_prefix )
+char *ProcessMRL( char *psz_mrl, char *psz_prefix )
 {
     /* Check for a protocol name.
      * for URL, we should look for "://"
index 0eacd5e..18c6e9f 100644 (file)
  *****************************************************************************/
 
 #include <vlc_playlist.h>
-char *E_(ProcessMRL)( char *, char * );
-char *E_(FindPrefix)( demux_t * );
+char *ProcessMRL( char *, char * );
+char *FindPrefix( demux_t * );
 
-bool E_(FindItem)( demux_t *, playlist_t *, playlist_item_t **);
+bool FindItem( demux_t *, playlist_t *, playlist_item_t **);
 
-void E_(AddToPlaylist)( demux_t *, playlist_t*,input_item_t*,playlist_item_t*,int );
+void AddToPlaylist( demux_t *, playlist_t*,input_item_t*,playlist_item_t*,int );
 
-int E_(Import_Old) ( vlc_object_t * );
+int Import_Old ( vlc_object_t * );
 
-int E_(Import_Native) ( vlc_object_t * );
-void E_(Close_Native) ( vlc_object_t * );
+int Import_Native ( vlc_object_t * );
+void Close_Native ( vlc_object_t * );
 
-int E_(Import_M3U) ( vlc_object_t * );
-void E_(Close_M3U) ( vlc_object_t * );
+int Import_M3U ( vlc_object_t * );
+void Close_M3U ( vlc_object_t * );
 
-int E_(Import_PLS) ( vlc_object_t * );
-void E_(Close_PLS) ( vlc_object_t * );
+int Import_PLS ( vlc_object_t * );
+void Close_PLS ( vlc_object_t * );
 
-int E_(Import_B4S) ( vlc_object_t * );
-void E_(Close_B4S) ( vlc_object_t * );
+int Import_B4S ( vlc_object_t * );
+void Close_B4S ( vlc_object_t * );
 
-int E_(Import_DVB) ( vlc_object_t * );
-void E_(Close_DVB) ( vlc_object_t * );
+int Import_DVB ( vlc_object_t * );
+void Close_DVB ( vlc_object_t * );
 
-int E_(Import_podcast) ( vlc_object_t * );
-void E_(Close_podcast) ( vlc_object_t * );
+int Import_podcast ( vlc_object_t * );
+void Close_podcast ( vlc_object_t * );
 
-int E_(Import_xspf) ( vlc_object_t * );
-void E_(Close_xspf) ( vlc_object_t * );
+int Import_xspf ( vlc_object_t * );
+void Close_xspf ( vlc_object_t * );
 
-int E_(Import_Shoutcast) ( vlc_object_t * );
-void E_(Close_Shoutcast) ( vlc_object_t * );
+int Import_Shoutcast ( vlc_object_t * );
+void Close_Shoutcast ( vlc_object_t * );
 
-int E_(Import_ASX) ( vlc_object_t * );
-void E_(Close_ASX) ( vlc_object_t * );
+int Import_ASX ( vlc_object_t * );
+void Close_ASX ( vlc_object_t * );
 
-int E_(Import_SGIMB) ( vlc_object_t * );
-void E_(Close_SGIMB) ( vlc_object_t * );
+int Import_SGIMB ( vlc_object_t * );
+void Close_SGIMB ( vlc_object_t * );
 
-int E_(Import_QTL) ( vlc_object_t * );
-void E_(Close_QTL) ( vlc_object_t * );
+int Import_QTL ( vlc_object_t * );
+void Close_QTL ( vlc_object_t * );
 
-int E_(Import_GVP) ( vlc_object_t * );
-void E_(Close_GVP) ( vlc_object_t * );
+int Import_GVP ( vlc_object_t * );
+void Close_GVP ( vlc_object_t * );
 
-int E_(Import_IFO) ( vlc_object_t * );
-void E_(Close_IFO) ( vlc_object_t * );
+int Import_IFO ( vlc_object_t * );
+void Close_IFO ( vlc_object_t * );
 
-int E_(Import_VideoPortal) ( vlc_object_t * );
-void E_(Close_VideoPortal) ( vlc_object_t * );
+int Import_VideoPortal ( vlc_object_t * );
+void Close_VideoPortal ( vlc_object_t * );
 
-int E_(Import_iTML) ( vlc_object_t * );
-void E_(Close_iTML) ( vlc_object_t * );
+int Import_iTML ( vlc_object_t * );
+void Close_iTML ( vlc_object_t * );
 
 #define INIT_PLAYLIST_STUFF \
     playlist_t *p_playlist = pl_Yield( p_demux ); \
index dfbdc5c..191eca7 100644 (file)
@@ -48,7 +48,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Import_PLS: main import function
  *****************************************************************************/
-int E_(Import_PLS)( vlc_object_t *p_this )
+int Import_PLS( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     const uint8_t *p_peek;
@@ -62,7 +62,7 @@ int E_(Import_PLS)( vlc_object_t *p_this )
     else return VLC_EGENERIC;
 
     STANDARD_DEMUX_INIT_MSG(  "found valid PLS playlist file");
-    p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux );
+    p_demux->p_sys->psz_prefix = FindPrefix( p_demux );
 
     return VLC_SUCCESS;
 }
@@ -70,7 +70,7 @@ int E_(Import_PLS)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_PLS)( vlc_object_t *p_this )
+void Close_PLS( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     free( p_demux->p_sys->psz_prefix );
@@ -180,7 +180,7 @@ static int Demux( demux_t *p_demux )
         {
             free( psz_mrl_orig );
             psz_mrl_orig =
-            psz_mrl = E_(ProcessMRL)( psz_value, p_demux->p_sys->psz_prefix );
+            psz_mrl = ProcessMRL( psz_value, p_demux->p_sys->psz_prefix );
 
             if( !strncasecmp( psz_key, "Ref", sizeof("Ref") -1 ) )
             {
index c35e3b3..9866d7b 100644 (file)
@@ -51,7 +51,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Import_podcast: main import function
  *****************************************************************************/
-int E_(Import_podcast)( vlc_object_t *p_this )
+int Import_podcast( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
 
@@ -59,7 +59,7 @@ int E_(Import_podcast)( vlc_object_t *p_this )
         return VLC_EGENERIC;
 
     STANDARD_DEMUX_INIT_MSG( "using podcast reader" );
-    p_demux->p_sys->psz_prefix = E_(FindPrefix)( p_demux );
+    p_demux->p_sys->psz_prefix = FindPrefix( p_demux );
     p_demux->p_sys->p_playlist = NULL;
     p_demux->p_sys->p_xml = NULL;
     p_demux->p_sys->p_xml_reader = NULL;
@@ -70,7 +70,7 @@ int E_(Import_podcast)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_podcast)( vlc_object_t *p_this )
+void Close_podcast( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index 2340ee2..3d3748e 100644 (file)
@@ -87,7 +87,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Import_QTL: main import function
  *****************************************************************************/
-int E_(Import_QTL)( vlc_object_t *p_this )
+int Import_QTL( vlc_object_t *p_this )
 {
     DEMUX_BY_EXTENSION_MSG( ".qtl", "using QuickTime Media Link reader" );
     p_demux->p_sys->p_playlist = NULL;
@@ -99,7 +99,7 @@ int E_(Import_QTL)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_QTL)( vlc_object_t *p_this )
+void Close_QTL( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index f45a0e6..f6552fe 100644 (file)
@@ -135,7 +135,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args );
 /*****************************************************************************
  * Activate: initializes m3u demux structures
  *****************************************************************************/
-int E_(Import_SGIMB)( vlc_object_t * p_this )
+int Import_SGIMB( vlc_object_t * p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     const uint8_t *p_peek;
@@ -179,7 +179,7 @@ int E_(Import_SGIMB)( vlc_object_t * p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_SGIMB)( vlc_object_t *p_this )
+void Close_SGIMB( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t*)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index b0cb0e9..2ba2217 100644 (file)
@@ -64,7 +64,7 @@ static int DemuxStation( demux_t *p_demux );
 /*****************************************************************************
  * Import_Shoutcast: main import function
  *****************************************************************************/
-int E_(Import_Shoutcast)( vlc_object_t *p_this )
+int Import_Shoutcast( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
 
@@ -87,7 +87,7 @@ int E_(Import_Shoutcast)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_Shoutcast)( vlc_object_t *p_this )
+void Close_Shoutcast( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     demux_sys_t *p_sys = p_demux->p_sys;
index b0ac7b3..e3387d0 100644 (file)
@@ -54,14 +54,14 @@ static int Demux( demux_t * );
 /**
  * \brief XSPF submodule initialization function
  */
-int E_(Import_xspf)( vlc_object_t *p_this )
+int Import_xspf( vlc_object_t *p_this )
 {
     DEMUX_BY_EXTENSION_OR_FORCED_MSG( ".xspf", "xspf-open",
                                       "using XSPF playlist reader" );
     return VLC_SUCCESS;
 }
 
-void E_(Close_xspf)( vlc_object_t *p_this )
+void Close_xspf( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     FREENULL( p_demux->p_sys->pp_tracklist );
index 67e0884..a7b3502 100644 (file)
@@ -64,7 +64,7 @@ static void DoNothing    ( aout_instance_t * p_aout );
 /*****************************************************************************
  * OpenAudio
  *****************************************************************************/
-int E_(OpenAudio) ( vlc_object_t * p_this )
+int OpenAudio ( vlc_object_t * p_this )
 {
     aout_instance_t * p_aout = (aout_instance_t*) p_this;
     p_aout->output.p_sys = (aout_sys_t*) malloc( sizeof( aout_sys_t ) );
@@ -124,7 +124,7 @@ int E_(OpenAudio) ( vlc_object_t * p_this )
 /*****************************************************************************
  * CloseAudio
  *****************************************************************************/
-void E_(CloseAudio) ( vlc_object_t * p_this )
+void CloseAudio ( vlc_object_t * p_this )
 {
     aout_instance_t * p_aout = (aout_instance_t *) p_this;
     aout_sys_t * p_sys = (aout_sys_t *) p_aout->output.p_sys;
index 0e807e5..e44444b 100644 (file)
 /*****************************************************************************
  * External prototypes
  *****************************************************************************/
-int  E_(OpenIntf)     ( vlc_object_t * );
-void E_(CloseIntf)    ( vlc_object_t * );
+int  OpenIntf     ( vlc_object_t * );
+void CloseIntf    ( vlc_object_t * );
 
-int  E_(OpenAudio)    ( vlc_object_t * );
-void E_(CloseAudio)   ( vlc_object_t * );
+int  OpenAudio    ( vlc_object_t * );
+void CloseAudio   ( vlc_object_t * );
 
-int  E_(OpenVideo)    ( vlc_object_t * );
-void E_(CloseVideo)   ( vlc_object_t * );
+int  OpenVideo    ( vlc_object_t * );
+void CloseVideo   ( vlc_object_t * );
 
 /*****************************************************************************
  * Module descriptor
@@ -56,12 +56,12 @@ vlc_module_begin();
     set_shortname( "BeOS" );
     set_description( _("BeOS standard API interface") );
     set_capability( "interface", 100 );
-    set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+    set_callbacks( OpenIntf, CloseIntf );
 
     add_submodule();
         set_capability( "video output", 100 );
-        set_callbacks( E_(OpenVideo), E_(CloseVideo) );
+        set_callbacks( OpenVideo, CloseVideo );
     add_submodule();
         set_capability( "audio output", 100 );
-        set_callbacks( E_(OpenAudio), E_(CloseAudio) );
+        set_callbacks( OpenAudio, CloseAudio );
 vlc_module_end();
index 2253d4c..6c5773c 100644 (file)
@@ -61,7 +61,7 @@ static void Run       ( intf_thread_t *p_intf );
 /*****************************************************************************
  * intf_Open: initialize interface
  *****************************************************************************/
-int E_(OpenIntf) ( vlc_object_t *p_this )
+int OpenIntf ( vlc_object_t *p_this )
 {
     intf_thread_t * p_intf = (intf_thread_t*) p_this;
 
@@ -102,7 +102,7 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
 /*****************************************************************************
  * intf_Close: destroy dummy interface
  *****************************************************************************/
-void E_(CloseIntf) ( vlc_object_t *p_this )
+void CloseIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
index 982ec15..e74369a 100644 (file)
@@ -1221,7 +1221,7 @@ static void BeosCloseDisplay( vout_thread_t *p_vout );
  *****************************************************************************
  * This function allocates and initializes a BeOS vout method.
  *****************************************************************************/
-int E_(OpenVideo) ( vlc_object_t *p_this )
+int OpenVideo ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
@@ -1344,7 +1344,7 @@ static int Manage( vout_thread_t * p_vout )
  *****************************************************************************
  * Terminate an output method created by DummyCreateOutputMethod
  *****************************************************************************/
-void E_(CloseVideo) ( vlc_object_t *p_this )
+void CloseVideo ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
index bdea568..9d36ad2 100644 (file)
@@ -92,7 +92,7 @@ static void Run ( intf_thread_t *p_intf );
 /*****************************************************************************
  * OpenIntf: initialize interface
  *****************************************************************************/
-int E_(OpenIntf) ( vlc_object_t *p_this )
+int OpenIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
@@ -118,7 +118,7 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseIntf: destroy interface
  *****************************************************************************/
-void E_(CloseIntf) ( vlc_object_t *p_this )
+void CloseIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
index 9fa7dfb..b5e18b8 100644 (file)
 /*****************************************************************************
  * External prototypes
  *****************************************************************************/
-int  E_(OpenIntf)     ( vlc_object_t * );
-void E_(CloseIntf)    ( vlc_object_t * );
+int  OpenIntf     ( vlc_object_t * );
+void CloseIntf    ( vlc_object_t * );
 
-int  E_(OpenVideoQT)  ( vlc_object_t * );
-void E_(CloseVideoQT) ( vlc_object_t * );
+int  OpenVideoQT  ( vlc_object_t * );
+void CloseVideoQT ( vlc_object_t * );
 
-int  E_(OpenVideoGL)  ( vlc_object_t * );
-void E_(CloseVideoGL) ( vlc_object_t * );
+int  OpenVideoGL  ( vlc_object_t * );
+void CloseVideoGL ( vlc_object_t * );
 
 /*****************************************************************************
  * Module descriptor
@@ -93,7 +93,7 @@ void E_(CloseVideoGL) ( vlc_object_t * );
 vlc_module_begin();
     set_description( _("Mac OS X interface") );
     set_capability( "interface", 200 );
-    set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+    set_callbacks( OpenIntf, CloseIntf );
     set_category( CAT_INTERFACE );
     set_subcategory( SUBCAT_INTERFACE_MAIN );
     add_bool( "macosx-autoplay", 1, NULL, AUTOPLAY_OSX_TEST, AUTOPLAY_OSX_LONGTEXT,
@@ -110,7 +110,7 @@ vlc_module_begin();
         set_capability( "video output", 100 );
         set_category( CAT_VIDEO);
         set_subcategory( SUBCAT_VIDEO_VOUT );
-        set_callbacks( E_(OpenVideoQT), E_(CloseVideoQT) );
+        set_callbacks( OpenVideoQT, CloseVideoQT );
 
         add_integer( "macosx-vdev", 0, NULL, VDEV_TEXT, VDEV_LONGTEXT,
                      false );
@@ -127,6 +127,6 @@ vlc_module_begin();
         set_capability( "opengl provider", 100 );
         set_category( CAT_VIDEO);
         set_subcategory( SUBCAT_VIDEO_VOUT );
-        set_callbacks( E_(OpenVideoGL), E_(CloseVideoGL) );
+        set_callbacks( OpenVideoGL, CloseVideoGL );
 vlc_module_end();
 
index c3283fc..58817be 100644 (file)
@@ -96,7 +96,7 @@ static void aglSwap   ( vout_thread_t * p_vout );
 static int  aglLock   ( vout_thread_t * p_vout );
 static void aglUnlock ( vout_thread_t * p_vout );
 
-int E_(OpenVideoGL)  ( vlc_object_t * p_this )
+int OpenVideoGL  ( vlc_object_t * p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *) p_this;
     vlc_value_t value_drawable;
@@ -197,7 +197,7 @@ int E_(OpenVideoGL)  ( vlc_object_t * p_this )
     return VLC_SUCCESS;
 }
 
-void E_(CloseVideoGL) ( vlc_object_t * p_this )
+void CloseVideoGL ( vlc_object_t * p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *) p_this;
     if( p_vout->p_sys->b_embedded )
index 05bb498..61b1d76 100644 (file)
@@ -114,7 +114,7 @@ static void QTFreePicture       ( vout_thread_t *, picture_t * );
  *****************************************************************************
  * This function allocates and initializes a MacOS X vout method.
  *****************************************************************************/
-int E_(OpenVideoQT) ( vlc_object_t *p_this )
+int OpenVideoQT ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
     OSErr err;
@@ -232,7 +232,7 @@ int E_(OpenVideoQT) ( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseVideo: destroy video thread output method
  *****************************************************************************/
-void E_(CloseVideoQT) ( vlc_object_t *p_this )
+void CloseVideoQT ( vlc_object_t *p_this )
 {
     NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
index a074e48..7ad564e 100644 (file)
@@ -50,7 +50,7 @@ static void Run ( intf_thread_t *p_intf );
 /*****************************************************************************
  * OpenIntf: initialize interface
  *****************************************************************************/
-int E_(OpenIntf) ( vlc_object_t *p_this )
+int OpenIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
@@ -71,7 +71,7 @@ int E_(OpenIntf) ( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseIntf: destroy interface
  *****************************************************************************/
-void E_(CloseIntf) ( vlc_object_t *p_this )
+void CloseIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
index 0116511..57badcc 100644 (file)
 /*****************************************************************************
  * External prototypes
  *****************************************************************************/
-int  E_(OpenIntf)     ( vlc_object_t * );
-void E_(CloseIntf)    ( vlc_object_t * );
+int  OpenIntf     ( vlc_object_t * );
+void CloseIntf    ( vlc_object_t * );
 
-int  E_(OpenVideoGL)  ( vlc_object_t * );
-void E_(CloseVideoGL) ( vlc_object_t * );
+int  OpenVideoGL  ( vlc_object_t * );
+void CloseVideoGL ( vlc_object_t * );
 
 /*****************************************************************************
  * Module descriptor
@@ -56,7 +56,7 @@ vlc_module_begin();
     add_shortcut( "minimal_macosx" );
     set_description( _("Minimal Mac OS X interface") );
     set_capability( "interface", 50 );
-    set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+    set_callbacks( OpenIntf, CloseIntf );
     set_category( CAT_INTERFACE );
     set_subcategory( SUBCAT_INTERFACE_MAIN );
 
@@ -66,6 +66,6 @@ vlc_module_begin();
         set_capability( "opengl provider", 50 );
         set_category( CAT_VIDEO);
         set_subcategory( SUBCAT_VIDEO_VOUT );
-        set_callbacks( E_(OpenVideoGL), E_(CloseVideoGL) );
+        set_callbacks( OpenVideoGL, CloseVideoGL );
 vlc_module_end();
 
index f93cb2f..7713f53 100644 (file)
@@ -33,7 +33,7 @@
 #include "intf.h"
 #include "voutgl.h"
 
-int E_(OpenVideoGL)  ( vlc_object_t * p_this )
+int OpenVideoGL  ( vlc_object_t * p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *) p_this;
     vlc_value_t value_drawable;
@@ -84,7 +84,7 @@ int E_(OpenVideoGL)  ( vlc_object_t * p_this )
     return VLC_SUCCESS;
 }
 
-void E_(CloseVideoGL) ( vlc_object_t * p_this )
+void CloseVideoGL ( vlc_object_t * p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *) p_this;
     /* Clean up */
index 7e3cd66..8929d73 100644 (file)
@@ -53,8 +53,8 @@ static void Run          ( intf_thread_t * );
 
 void GtkAutoPlayFile     ( vlc_object_t * );
 static int Manage        ( intf_thread_t *p_intf );
-void E_(GtkDisplayDate)  ( GtkAdjustment *p_adj, gpointer userdata );
-gint E_(GtkModeManage)   ( intf_thread_t * p_intf );
+void GtkDisplayDate  ( GtkAdjustment *p_adj, gpointer userdata );
+gint GtkModeManage   ( intf_thread_t * p_intf );
 
 /*****************************************************************************
  * Module descriptor
@@ -208,7 +208,7 @@ static void Run( intf_thread_t *p_intf )
     if (p_intf->p_sys->p_adj == NULL)
         msg_Err( p_intf, "Adjustment range not found." );
     g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed",
-                         G_CALLBACK( E_(GtkDisplayDate) ), p_intf );
+                         G_CALLBACK( GtkDisplayDate ), p_intf );
     p_intf->p_sys->f_adj_oldvalue = 0;
     p_intf->p_sys->i_adj_oldvalue = 0;
 
@@ -429,7 +429,7 @@ static int Manage( intf_thread_t *p_intf )
         {
             playlist_t *p_playlist;
 
-            E_(GtkModeManage)( p_intf );
+            GtkModeManage( p_intf );
             p_intf->p_sys->b_playing = 1;
 
             /* update playlist interface */
@@ -524,7 +524,7 @@ static int Manage( intf_thread_t *p_intf )
     }
     else if( p_intf->p_sys->b_playing && !intf_ShouldDie( p_intf ) )
     {
-        E_(GtkModeManage)( p_intf );
+        GtkModeManage( p_intf );
         p_intf->p_sys->b_playing = 0;
     }
 
@@ -552,7 +552,7 @@ static int Manage( intf_thread_t *p_intf )
  * the stream. It is called whenever the slider changes its value.
  * The lock has to be taken before you call the function.
  *****************************************************************************/
-void E_(GtkDisplayDate)( GtkAdjustment *p_adj, gpointer userdata )
+void GtkDisplayDate( GtkAdjustment *p_adj, gpointer userdata )
 {
     intf_thread_t *p_intf;
 
@@ -579,7 +579,7 @@ void E_(GtkDisplayDate)( GtkAdjustment *p_adj, gpointer userdata )
  *****************************************************************************
  * The lock has to be taken before you call the function.
  *****************************************************************************/
-gint E_(GtkModeManage)( intf_thread_t * p_intf )
+gint GtkModeManage( intf_thread_t * p_intf )
 {
     GtkWidget *     p_slider = NULL;
     bool      b_control;
index 1dd97f3..5aa228b 100644 (file)
@@ -63,5 +63,5 @@ struct intf_sys_t
         GTK_OBJECT( p_intf->p_sys->p_window ), nom ) )
 
  
-#define  GtkGetIntf( widget ) E_(__GtkGetIntf)( GTK_WIDGET( widget ) )
-void * E_(__GtkGetIntf)( GtkWidget * );
+#define  GtkGetIntf( widget ) __GtkGetIntf( GTK_WIDGET( widget ) )
+void * __GtkGetIntf( GtkWidget * );
index 58fa6fa..fffa048 100644 (file)
@@ -56,7 +56,7 @@ static char *get_file_perms(struct stat st);
 /*****************************************************************************
  * Useful function to retrieve p_intf
  ****************************************************************************/
-void * E_(__GtkGetIntf)( GtkWidget * widget )
+void * __GtkGetIntf( GtkWidget * widget )
 {
     void *p_data;
 
index befcbdb..2163edc 100644 (file)
@@ -55,8 +55,8 @@ struct aout_sys_t
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
-int            E_(OpenAudio)    ( vlc_object_t *p_this );
-void           E_(CloseAudio)   ( vlc_object_t *p_this );
+int            OpenAudio    ( vlc_object_t *p_this );
+void           CloseAudio   ( vlc_object_t *p_this );
 static int     GetBufInfo       ( aout_instance_t * );
 static void    Play             ( aout_instance_t * );
 static int     QNXaoutThread    ( aout_instance_t * );
@@ -66,7 +66,7 @@ static int     QNXaoutThread    ( aout_instance_t * );
  *****************************************************************************
  * This function opens an alsa device, through the alsa API
  *****************************************************************************/
-int E_(OpenAudio)( vlc_object_t *p_this )
+int OpenAudio( vlc_object_t *p_this )
 {
     aout_instance_t *p_aout = (aout_instance_t *)p_this;
     int i_ret;
@@ -101,7 +101,7 @@ int E_(OpenAudio)( vlc_object_t *p_this )
                                               PLUGIN_DISABLE_MMAP ) ) < 0 )
     {
         msg_Err( p_aout, "unable to disable mmap (%s)", snd_strerror(i_ret) );
-        E_(CloseAudio)( p_this );
+        CloseAudio( p_this );
         free( p_aout->output.p_sys );
         return -1;
     }
@@ -119,7 +119,7 @@ int E_(OpenAudio)( vlc_object_t *p_this )
     {
         msg_Err( p_aout, "unable to get plugin info (%s)",
                          snd_strerror( i_ret ) );
-        E_(CloseAudio)( p_this );
+        CloseAudio( p_this );
         free( p_aout->output.p_sys );
         return -1;
     }
@@ -158,7 +158,7 @@ int E_(OpenAudio)( vlc_object_t *p_this )
                                          &pp ) ) < 0 )
     {
         msg_Err( p_aout, "unable to set parameters (%s)", snd_strerror(i_ret) );
-        E_(CloseAudio)( p_this );
+        CloseAudio( p_this );
         free( p_aout->output.p_sys );
         return -1;
     }
@@ -169,7 +169,7 @@ int E_(OpenAudio)( vlc_object_t *p_this )
     {
         msg_Err( p_aout, "unable to prepare channel (%s)",
                          snd_strerror( i_ret ) );
-        E_(CloseAudio)( p_this );
+        CloseAudio( p_this );
         free( p_aout->output.p_sys );
         return -1;
     }
@@ -179,7 +179,7 @@ int E_(OpenAudio)( vlc_object_t *p_this )
                            VLC_THREAD_PRIORITY_OUTPUT, false ) )
     {
         msg_Err( p_aout, "cannot create QNX audio thread (%m)" );
-        E_(CloseAudio)( p_this );
+        CloseAudio( p_this );
         free( p_aout->output.p_sys );
         return -1;
     }
@@ -239,7 +239,7 @@ static void Play( aout_instance_t *p_aout )
 /*****************************************************************************
  * CloseAudio: close the audio device
  *****************************************************************************/
-void E_(CloseAudio) ( vlc_object_t *p_this )
+void CloseAudio ( vlc_object_t *p_this )
 {
     aout_instance_t *p_aout = (aout_instance_t *)p_this;
     int i_ret;
index 3a108bf..263da9f 100644 (file)
 /*****************************************************************************
  * External prototypes
  ******************************************************************************/
-int  E_(OpenAudio)    ( vlc_object_t * );
-void E_(CloseAudio)   ( vlc_object_t * );
+int  OpenAudio    ( vlc_object_t * );
+void CloseAudio   ( vlc_object_t * );
 
-int  E_(OpenVideo)    ( vlc_object_t * );
-void E_(CloseVideo)   ( vlc_object_t * );
+int  OpenVideo    ( vlc_object_t * );
+void CloseVideo   ( vlc_object_t * );
 
 /*****************************************************************************
  * Module descriptor
@@ -46,11 +46,11 @@ void E_(CloseVideo)   ( vlc_object_t * );
 vlc_module_begin();
     set_description( _("QNX RTOS video and audio output") );
     set_capability( "video output", 100 );
-    set_callbacks( E_(OpenVideo), E_(CloseVideo) );
+    set_callbacks( OpenVideo, CloseVideo );
     set_category( CAT_INTERFACE );
     set_subcategory( SUBCAT_INTERFACE_MAIN );
     add_submodule();
         set_capability( "audio output", 100 );
-        set_callbacks( E_(OpenAudio), E_(CloseAudio) );
+        set_callbacks( OpenAudio, CloseAudio );
 vlc_module_end();
 
index 7583994..58acda7 100644 (file)
@@ -130,7 +130,7 @@ static void SetPalette     ( vout_thread_t *, uint16_t *, uint16_t *, uint16_t *
  * vout properties to choose the window size, and change them according to the
  * actual properties of the display.
  *****************************************************************************/
-int E_(OpenVideo) ( vlc_object_t *p_this )
+int OpenVideo ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
@@ -278,7 +278,7 @@ static void QNXEnd( vout_thread_t *p_vout )
  *****************************************************************************
  * Terminate an output method created by QNXCreate
  *****************************************************************************/
-void E_(CloseVideo) ( vlc_object_t *p_this )
+void CloseVideo ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
index 4b333c9..28becbf 100644 (file)
@@ -45,7 +45,7 @@ static void    Play        ( aout_instance_t * );
 /*****************************************************************************
  * OpenAudio: open a dummy audio device
  *****************************************************************************/
-int E_(OpenAudio) ( vlc_object_t * p_this )
+int OpenAudio ( vlc_object_t * p_this )
 {
     aout_instance_t * p_aout = (aout_instance_t *)p_this;
 
index 881ab70..5d14596 100644 (file)
@@ -67,7 +67,7 @@ static void *DecodeBlock( decoder_t *p_dec, block_t **pp_block );
 /*****************************************************************************
  * OpenDecoder: Open the decoder
  *****************************************************************************/
-int E_(OpenDecoder) ( vlc_object_t *p_this )
+int OpenDecoder ( vlc_object_t *p_this )
 {
     decoder_t *p_dec = (decoder_t*)p_this;
     decoder_sys_t *p_sys;
@@ -145,7 +145,7 @@ static void *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
 /*****************************************************************************
  * CloseDecoder: decoder destruction
  *****************************************************************************/
-void E_(CloseDecoder) ( vlc_object_t *p_this )
+void CloseDecoder ( vlc_object_t *p_this )
 {
     decoder_t *p_dec = (decoder_t *)p_this;
     decoder_sys_t *p_sys = p_dec->p_sys;
index fdfaf9e..ba69386 100644 (file)
@@ -62,7 +62,7 @@ vlc_module_begin();
     set_description( _("Dummy interface function") );
     set_capability( "interface", 0 );
     add_shortcut( "vlc" );
-    set_callbacks( E_(OpenIntf), NULL );
+    set_callbacks( OpenIntf, NULL );
 #ifdef WIN32
     set_section( N_( "Dummy Interface" ), NULL );
     add_category_hint( N_("Interface"), NULL, false );
@@ -71,35 +71,35 @@ vlc_module_begin();
     add_submodule();
         set_description( _("Dummy access function") );
         set_capability( "access", 0 );
-        set_callbacks( E_(OpenAccess), NULL );
+        set_callbacks( OpenAccess, NULL );
     add_submodule();
         set_description( _("Dummy demux function") );
         set_capability( "demux", 0 );
-        set_callbacks( E_(OpenDemux), E_(CloseDemux) );
+        set_callbacks( OpenDemux, CloseDemux );
     add_submodule();
         set_section( N_( "Dummy decoder" ), NULL );
         set_description( _("Dummy decoder function") );
         set_capability( "decoder", 0 );
-        set_callbacks( E_(OpenDecoder), E_(CloseDecoder) );
+        set_callbacks( OpenDecoder, CloseDecoder );
         add_bool( "dummy-save-es", 0, NULL, SAVE_TEXT, SAVE_LONGTEXT, true );
     add_submodule();
         set_description( _("Dummy encoder function") );
         set_capability( "encoder", 0 );
-        set_callbacks( E_(OpenEncoder), E_(CloseEncoder) );
+        set_callbacks( OpenEncoder, CloseEncoder );
     add_submodule();
         set_description( _("Dummy audio output function") );
         set_capability( "audio output", 1 );
-        set_callbacks( E_(OpenAudio), NULL );
+        set_callbacks( OpenAudio, NULL );
     add_submodule();
         set_description( _("Dummy video output function") );
         set_section( N_( "Dummy Video output" ), NULL );
         set_capability( "video output", 1 );
-        set_callbacks( E_(OpenVideo), NULL );
+        set_callbacks( OpenVideo, NULL );
         add_category_hint( N_("Video"), NULL, false );
         add_string( "dummy-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT, true );
     add_submodule();
         set_description( _("Dummy font renderer function") );
         set_capability( "text renderer", 1 );
-        set_callbacks( E_(OpenRenderer), NULL );
+        set_callbacks( OpenRenderer, NULL );
 vlc_module_end();
 
index 5104a1d..a31c872 100644 (file)
 /*****************************************************************************
  * External prototypes
  *****************************************************************************/
-int  E_(OpenIntf)     ( vlc_object_t * );
+int  OpenIntf     ( vlc_object_t * );
 
-int  E_(OpenAccess)   ( vlc_object_t * );
+int  OpenAccess   ( vlc_object_t * );
 
-int  E_(OpenDemux)    ( vlc_object_t * );
-void E_(CloseDemux)   ( vlc_object_t * );
+int  OpenDemux    ( vlc_object_t * );
+void CloseDemux   ( vlc_object_t * );
 
-int  E_(OpenDecoder)  ( vlc_object_t * );
-void E_(CloseDecoder) ( vlc_object_t * );
+int  OpenDecoder  ( vlc_object_t * );
+void CloseDecoder ( vlc_object_t * );
 
-int  E_(OpenEncoder)  ( vlc_object_t * );
-void E_(CloseEncoder) ( vlc_object_t * );
+int  OpenEncoder  ( vlc_object_t * );
+void CloseEncoder ( vlc_object_t * );
 
-int  E_(OpenAudio)    ( vlc_object_t * );
+int  OpenAudio    ( vlc_object_t * );
 
-int  E_(OpenVideo)    ( vlc_object_t * );
+int  OpenVideo    ( vlc_object_t * );
 
-int  E_(OpenRenderer) ( vlc_object_t * );
+int  OpenRenderer ( vlc_object_t * );
index 072aac6..f387f10 100644 (file)
@@ -41,7 +41,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_buf );
 /*****************************************************************************
  * OpenDecoder: open the dummy encoder.
  *****************************************************************************/
-int E_(OpenEncoder) ( vlc_object_t *p_this )
+int OpenEncoder ( vlc_object_t *p_this )
 {
     encoder_t *p_enc = (encoder_t *)p_this;
 
@@ -72,7 +72,7 @@ static block_t *EncodeAudio( encoder_t *p_enc, aout_buffer_t *p_buf )
 /*****************************************************************************
  * CloseDecoder: decoder destruction
  *****************************************************************************/
-void E_(CloseEncoder) ( vlc_object_t *p_this )
+void CloseEncoder ( vlc_object_t *p_this )
 {
     VLC_UNUSED(p_this);
 }
index 3387b00..34ac44f 100644 (file)
@@ -89,7 +89,7 @@ static int AccessControl( access_t *p_access, int i_query, va_list args )
     return VLC_SUCCESS;
 }
 
-int E_(OpenAccess)( vlc_object_t *p_this )
+int OpenAccess( vlc_object_t *p_this )
 {
     access_t *p_access = (access_t*)p_this;
 
@@ -142,7 +142,7 @@ static int DemuxControl( demux_t *, int, va_list );
 /*****************************************************************************
  * OpenDemux: initialize the target, ie. parse the command
  *****************************************************************************/
-int E_(OpenDemux) ( vlc_object_t *p_this )
+int OpenDemux ( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t*)p_this;
     char * psz_name = p_demux->psz_path;
@@ -190,7 +190,7 @@ int E_(OpenDemux) ( vlc_object_t *p_this )
 /*****************************************************************************
  * CloseDemux: initialize the target, ie. parse the command
  *****************************************************************************/
-void E_(CloseDemux) ( vlc_object_t *p_this )
+void CloseDemux ( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t*)p_this;
 
index 514adba..05685c7 100644 (file)
@@ -37,7 +37,7 @@
 /*****************************************************************************
  * Open: initialize dummy interface
  *****************************************************************************/
-int  E_(OpenIntf) ( vlc_object_t *p_this )
+int  OpenIntf ( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*) p_this;
 
index 904d2ca..afea1fd 100644 (file)
@@ -35,7 +35,7 @@
 static int RenderText( filter_t *, subpicture_region_t *,
                        subpicture_region_t * );
 
-int E_(OpenRenderer)( vlc_object_t *p_this )
+int OpenRenderer( vlc_object_t *p_this )
 {
     filter_t *p_filter = (filter_t *)p_this;
     p_filter->pf_render_text = RenderText;
index 59aa3f1..f569908 100644 (file)
@@ -54,7 +54,7 @@ static int  Control   ( vout_thread_t *, int, va_list );
  *****************************************************************************
  * This function initializes a dummy vout method.
  *****************************************************************************/
-int E_(OpenVideo) ( vlc_object_t *p_this )
+int OpenVideo ( vlc_object_t *p_this )
 {
     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 
index 1035853..2a62c4b 100644 (file)
@@ -991,7 +991,7 @@ static const char *GetModuleName( intf_thread_t *p_intf )
     return config_GetPsz( p_intf, "lua-intf" );
 }
 
-int E_(Open_LuaIntf)( vlc_object_t *p_this )
+int Open_LuaIntf( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*)p_this;
     intf_sys_t *p_sys;
@@ -1097,12 +1097,12 @@ int E_(Open_LuaIntf)( vlc_object_t *p_this )
     p_sys->L = L;
 
     p_intf->pf_run = Run;
-    p_intf->psz_header = strdup( psz_name ); /* Do I need to clean that up myself in E_(Close_LuaIntf)? */
+    p_intf->psz_header = strdup( psz_name ); /* Do I need to clean that up myself in Close_LuaIntf? */
 
     return VLC_SUCCESS;
 }
 
-void E_(Close_LuaIntf)( vlc_object_t *p_this )
+void Close_LuaIntf( vlc_object_t *p_this )
 {
     intf_thread_t *p_intf = (intf_thread_t*)p_this;
 
index cf67a6e..5ce72f3 100644 (file)
@@ -281,7 +281,7 @@ static int fetch_meta( vlc_object_t *p_this, const char * psz_filename,
 /*****************************************************************************
  * Module entry point for art.
  *****************************************************************************/
-int E_(FindArt)( vlc_object_t *p_this )
+int FindArt( vlc_object_t *p_this )
 {
     playlist_t *p_playlist = (playlist_t *)p_this;
     input_item_t *p_item = (input_item_t *)(p_playlist->p_private);
index 5e3c4d7..62abfdc 100644 (file)
@@ -184,7 +184,7 @@ static int probe_luascript( vlc_object_t *p_this, const char * psz_filename,
 /*****************************************************************************
  * Import_LuaPlaylist: main import function
  *****************************************************************************/
-int E_(Import_LuaPlaylist)( vlc_object_t *p_this )
+int Import_LuaPlaylist( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     lua_State *L;
@@ -227,7 +227,7 @@ int E_(Import_LuaPlaylist)( vlc_object_t *p_this )
     ret = vlclua_scripts_batch_execute( p_this, "playlist",
                                         &probe_luascript, L, NULL );
     if( ret )
-        E_(Close_LuaPlaylist)( p_this );
+        Close_LuaPlaylist( p_this );
     return ret;
 }
 
@@ -235,7 +235,7 @@ int E_(Import_LuaPlaylist)( vlc_object_t *p_this )
 /*****************************************************************************
  * Deactivate: frees unused data
  *****************************************************************************/
-void E_(Close_LuaPlaylist)( vlc_object_t *p_this )
+void Close_LuaPlaylist( vlc_object_t *p_this )
 {
     demux_t *p_demux = (demux_t *)p_this;
     lua_close( p_demux->p_sys->L );
@@ -261,7 +261,7 @@ static int Demux( demux_t *p_demux )
     {
         msg_Warn( p_demux, "Error while runing script %s, "
                   "function parse() not found", psz_filename );
-        E_(Close_LuaPlaylist)( VLC_OBJECT( p_demux ) );
+        Close_LuaPlaylist( VLC_OBJECT( p_demux ) );
         return VLC_EGENERIC;
     }
 
@@ -270,7 +270,7 @@ static int Demux( demux_t *p_demux )
         msg_Warn( p_demux, "Error while runing script %s, "
                   "function parse(): %s", psz_filename,
                   lua_tostring( L, lua_gettop( L ) ) );
-        E_(Close_LuaPlaylist)( VLC_OBJECT( p_demux ) );
+        Close_LuaPlaylist( VLC_OBJECT( p_demux ) );
         return VLC_EGENERIC;
     }
 
index 20deb0c..de12892 100644 (file)
@@ -60,7 +60,7 @@ vlc_module_begin();
         set_shortname( N_( "Lua Art" ) );
         set_description( _("Fetch artwork using lua scripts") );
         set_capability( "art finder", 10 );
-        set_callbacks( E_(FindArt), NULL );
+        set_callbacks( FindArt, NULL );
     add_submodule();
         add_shortcut( "luaplaylist" );
         set_category( CAT_INPUT );
@@ -68,7 +68,7 @@ vlc_module_begin();
         set_shortname( _("Lua Playlist") );
         set_description( _("Lua Playlist Parser Interface") );
         set_capability( "demux", 2 );
-        set_callbacks( E_(Import_LuaPlaylist), E_(Close_LuaPlaylist) );
+        set_callbacks( Import_LuaPlaylist, Close_LuaPlaylist );
     add_submodule();
         add_shortcut( "luaintf" );
         add_shortcut( "luarc" );
@@ -85,7 +85,7 @@ vlc_module_begin();
                     INTF_TEXT, INTF_LONGTEXT, false );
         add_string( "lua-config", "", NULL,
                     CONFIG_TEXT, CONFIG_LONGTEXT, false );
-        set_callbacks( E_(Open_LuaIntf), E_(Close_LuaIntf) );
+        set_callbacks( Open_LuaIntf, Close_LuaIntf );
 vlc_module_end();
 
 /*****************************************************************************