/* 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
*/
#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( ) \
}
/* Getting frontend info */
- if( E_(FrontendOpen)( p_access) )
+ if( FrontendOpen( p_access) )
{
free( p_sys );
return VLC_EGENERIC;
/* 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;
}
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;
p_sys->i_read_once = DVB_READ_ONCE_START;
#ifdef ENABLE_HTTPD
- E_(HTTPOpen)( p_access );
+ HTTPOpen( p_access );
#endif
return VLC_SUCCESS;
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 );
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
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 )
p_pmt = (dvbpsi_pmt_t *)va_arg( args, dvbpsi_pmt_t * );
- E_(CAMSet)( p_access, p_pmt );
+ CAMSet( p_access, p_pmt );
break;
}
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" );
{
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;
}
}
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;
}
}
/*****************************************************************************
* 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
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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,
/*****************************************************************************
* 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;
/****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* FrontendSet : Tune !
*****************************************************************************/
-int E_(FrontendSet)( access_t *p_access )
+int FrontendSet( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
/*****************************************************************************
* 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;
{
/* The frontend was reinited. */
msg_Warn( p_access, "reiniting frontend");
- E_(FrontendSet)( p_access );
+ FrontendSet( p_access );
}
}
#undef IF_UP
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* DVRClose :
*****************************************************************************/
-void E_(DVRClose)( access_t * p_access )
+void DVRClose( access_t * p_access )
{
access_sys_t *p_sys = p_access->p_sys;
/*****************************************************************************
* 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];
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;
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;
/*****************************************************************************
* 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;
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" );
}
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" );
}
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" );
}
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
}
}
- E_(en50221_SendMMIObject)( p_access, i_slot, &mmi_object );
+ en50221_SendMMIObject( p_access, i_slot, &mmi_object );
return;
}
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" );
/*****************************************************************************
* 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;
return VLC_EGENERIC;
}
- E_(en50221_SetCAPMT)( p_access, p_pmt );
+ en50221_SetCAPMT( p_access, p_pmt );
return VLC_SUCCESS;
}
/*****************************************************************************
* 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 )
{
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;
}
}
-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;
}
}
-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 )
{
} 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 );
{
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;
}
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 );
}
}
#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
/*****************************************************************************
* 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 );
/****************************************************************************
* 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;
/*****************************************************************************
* 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;
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" ),
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;
*
* 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" ),
/*****************************************************************************
* 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 );
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;
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;
/*****************************************************************************
* 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;
}
/* *** 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 ) );
*
* 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" ),
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
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 );
/*****************************************************************************
* 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.
add_submodule();
set_capability( "interface", 0 );
- set_callbacks( E_(OpenIntf), E_(CloseIntf) );
+ set_callbacks( OpenIntf, CloseIntf );
vlc_module_end();
/*****************************************************************************
* 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 *,
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
#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 * );
/*****************************************************************************
*****************************************************************************
* 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;
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;
}
}
/* libavcodec needs to be initialized for some chroma conversions */
- E_(InitLibavcodec)(p_this);
+ InitLibavcodec(p_this);
return VLC_SUCCESS;
}
*****************************************************************************
* 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 )
*****************************************************************************
* 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;
*****************************************************************************
* 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;
/*****************************************************************************
* 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;
}
/* 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;
}
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
{
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;
}
{
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;
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' );
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 );
}
}
/*****************************************************************************
* 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;
/*****************************************************************************
* 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 * );
* 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;
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;
}
/* 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 )
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;
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 )
{
/* 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 */
/*****************************************************************************
* 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;
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 );
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 */
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
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 );
/* 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" );
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;
}
/* 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 );
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:
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;
}
/*****************************************************************************
*
*****************************************************************************/
-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;
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" );
{
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 )",
{ 0, 0 }
};
-int E_(GetFfmpegChroma)( vlc_fourcc_t i_chroma )
+int GetFfmpegChroma( vlc_fourcc_t i_chroma )
{
int i;
return -1;
}
-vlc_fourcc_t E_(GetVlcChroma)( int i_ffmpeg_chroma )
+vlc_fourcc_t GetVlcChroma( int i_ffmpeg_chroma )
{
int i;
{ 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;
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;
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
/*****************************************************************************
* 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;
/* 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 );
/*****************************************************************************
* 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;
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 );
/*****************************************************************************
* 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;
/*****************************************************************************
* 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();
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/* 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;
/*****************************************************************************
* 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;
{
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" );
#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 )
{
}
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;
}
* 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;
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;
/*****************************************************************************
* 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;
* 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 );
}
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++ )
#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 );
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;
}
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 );
(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;
}
/*****************************************************************************
* 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 );
}
/*****************************************************************************
* 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 );
}
/*****************************************************************************
* 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;
* 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;
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;
/*****************************************************************************
* Prototypes
*****************************************************************************/
-subpicture_t * E_(ParsePacket)( decoder_t * );
+subpicture_t * ParsePacket( decoder_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 *,
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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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,
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;
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 );
/* 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;
}
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 )
{
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 )
}
}
- 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';
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 )
if( !p_args->b_html )
{
- E_(FileLoad)( f, pp_data, pi_data );
+ FileLoad( f, pp_data, pi_data );
}
else
{
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 );
****************************************************************************
* 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,
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,
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 )
{
return VLC_SUCCESS;
}
- E_(FileLoad)( f, &p_data, &i_data );
+ FileLoad( f, &p_data, &i_data );
fclose( f );
/* 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 );
/**@}*/
/** 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 );
/** @} */
/** 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 );
} 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 * );
/**@}*/
} 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,
};
/** 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,
{
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 );
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 )
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:
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 );
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 )
{
}
*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 )
/* 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;
/* 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;
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;
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
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 ) )
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
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] );
}
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 );
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 );
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 )
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 );
}
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 )
{
break;
}
- E_(ExtractURIValue)( p_request, m->param1, value, 512 );
+ ExtractURIValue( p_request, m->param1, value, 512 );
decode_URI( value );
switch( StrToMacroType( m->param2 ) )
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 );
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 */
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,
}
/* 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);
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;
}
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 );
}
}
}
if( stop )
{
- E_(Execute)( p_args, p_request, i_request,
+ Execute( p_args, p_request, i_request,
pp_data, pi_data, &dst, src, stop );
}
}
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" )
|| !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 );
}
{
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
{
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 );
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;
}
-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 ) );
return v;
}
-void E_(mvar_Delete)( mvar_t *v )
+void mvar_Delete( mvar_t *v )
{
int i;
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 )
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++ )
/* 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, '.' );
{
if( field )
{
- return E_(mvar_GetVar)( s->field[i], field );
+ return mvar_GetVar( s->field[i], field );
}
else
{
return NULL;
}
-char *E_(mvar_GetValue)( mvar_t *v, char *field )
+char *mvar_GetValue( mvar_t *v, char *field )
{
if( *field == '\0' )
{
}
else
{
- mvar_t *f = E_(mvar_GetVar)( v, field );
+ mvar_t *f = mvar_GetVar( v, field );
if( f )
{
return f->value;
}
}
-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 )
{
sprintf( value, "%d", i );
- E_(mvar_PushNewVar)( s, name, value );
+ mvar_PushNewVar( s, name, value );
}
}
}
* 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 */ )
{
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,
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 );
}
}
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;
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:
}
#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;
{
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 );
}
}
}
#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 )
}
#endif
}
- f = E_(mvar_New)( name, "set" );
+ f = mvar_New( name, "set" );
/* put lower-case file extension in 'ext' */
psz_ext = strrchr( psz_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 )
{
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
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 );
}
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++ )
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;
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 );
}
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 )
{
}
}
-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 )
{
}
}
-char *E_(SSPop)( rpn_stack_t *st )
+char *SSPop( rpn_stack_t *st )
{
if( st->i_stack <= 0 )
{
}
}
-int E_(SSPopN)( rpn_stack_t *st, mvar_t *vars )
+int SSPopN( rpn_stack_t *st, mvar_t *vars )
{
char *name;
char *value;
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 );
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;
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 )
{
/* 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 )
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;
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 );
}
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;
}
*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;
}
*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,
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" ) )
{
}
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 );
}
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 );
}
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 );
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,
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;
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;
}
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,
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:
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 );
}
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,
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;
}
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:
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;
}
* 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 )
if( psz_module != NULL )
free( psz_module );
- E_(SSPushN)( st, i_result );
+ SSPushN( st, i_result );
}
else if( !strcmp( s, "vlc_config_reset" ) )
{
/* 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 )
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 );
}
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 )
}
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 )
}
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
}
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 );
}
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) )
{
#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 );
}
/* 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 =
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 );
}
else
{
- E_(SSPush)( st, s );
+ SSPush( st, s );
}
}
}
****************************************************************************/
/* 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;
}
/* 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;
}
/* 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;
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 )
{
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 )
{
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,
/*************************************************************************
* 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 )
{
{
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);
/****************************************************************************
* 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;
/****************************************************************************
* 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;
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 )
{
return psz_next;
}
-char *E_(ExtractURIString)( char *restrict psz_uri,
+char *ExtractURIString( char *restrict psz_uri,
const char *restrict psz_name )
{
size_t len;
/* 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;
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 );
/**********************************************************************
* 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;
/*****************************************************************************
* 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 *,
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;
/*****************************************************************************
* 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;
}
/* 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 );
/*****************************************************************************
* 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;
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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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);
}
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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);
}
/**
* \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 );
/*****************************************************************************
* 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;
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;
}
/*****************************************************************************
* 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 );
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;
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();
* 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 );
* 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 "://"
*****************************************************************************/
#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 ); \
/*****************************************************************************
* 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;
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;
}
/*****************************************************************************
* 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 );
{
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 ) )
{
/*****************************************************************************
* 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;
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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/**
* \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 );
/*****************************************************************************
* 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 ) );
/*****************************************************************************
* 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;
/*****************************************************************************
* 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
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();
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
*****************************************************************************
* 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;
*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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
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,
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 );
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();
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;
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 )
*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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
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 );
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();
#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;
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 */
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
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;
{
playlist_t *p_playlist;
- E_(GtkModeManage)( p_intf );
+ GtkModeManage( p_intf );
p_intf->p_sys->b_playing = 1;
/* update playlist interface */
}
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;
}
* 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;
*****************************************************************************
* 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;
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 * );
/*****************************************************************************
* Useful function to retrieve p_intf
****************************************************************************/
-void * E_(__GtkGetIntf)( GtkWidget * widget )
+void * __GtkGetIntf( GtkWidget * widget )
{
void *p_data;
/*****************************************************************************
* 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 * );
*****************************************************************************
* 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;
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;
}
{
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;
}
&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;
}
{
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;
}
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;
}
/*****************************************************************************
* 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;
/*****************************************************************************
* 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
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();
* 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;
*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
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 );
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();
/*****************************************************************************
* 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 * );
/*****************************************************************************
* 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;
/*****************************************************************************
* CloseDecoder: decoder destruction
*****************************************************************************/
-void E_(CloseEncoder) ( vlc_object_t *p_this )
+void CloseEncoder ( vlc_object_t *p_this )
{
VLC_UNUSED(p_this);
}
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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
/*****************************************************************************
* 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;
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;
*****************************************************************************
* 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;
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;
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;
/*****************************************************************************
* 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);
/*****************************************************************************
* 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;
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;
}
/*****************************************************************************
* 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 );
{
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;
}
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;
}
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 );
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" );
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();
/*****************************************************************************
/*****************************************************************************
* Module entry points
*****************************************************************************/
-int E_(FindArt)( vlc_object_t * );
+int FindArt( vlc_object_t * );
-int E_(Import_LuaPlaylist)( vlc_object_t * );
-void E_(Close_LuaPlaylist)( vlc_object_t * );
+int Import_LuaPlaylist( vlc_object_t * );
+void Close_LuaPlaylist( vlc_object_t * );
-int E_(Open_LuaIntf)( vlc_object_t * );
-void E_(Close_LuaIntf)( vlc_object_t * );
+int Open_LuaIntf( vlc_object_t * );
+void Close_LuaIntf( vlc_object_t * );
/*****************************************************************************
* Extern prototype
*****************************************************************************/
#ifndef MODULE_NAME_IS_memcpy
-# define fast_memcpy E_(fast_memcpy)
+# define fast_memcpy fast_memcpy
# include "fastmemcpy.h"
#endif
***************************************************************************/
int Export_M3U ( vlc_object_t *p_intf );
int Export_Old ( vlc_object_t *p_intf );
-int E_(xspf_export_playlist)( vlc_object_t *p_intf );
+int xspf_export_playlist( vlc_object_t *p_intf );
/*****************************************************************************
* Module descriptor
set_description( _("XSPF playlist export") );
add_shortcut( "export-xspf" );
set_capability( "playlist export" , 0);
- set_callbacks( E_(xspf_export_playlist) , NULL );
+ set_callbacks( xspf_export_playlist , NULL );
vlc_module_end();
* \param p_this the VLC playlist object
* \return VLC_SUCCESS if some memory is available, otherwise VLC_ENONMEM
*/
-int E_(xspf_export_playlist)( vlc_object_t *p_this )
+int xspf_export_playlist( vlc_object_t *p_this )
{
const playlist_t *p_playlist = (playlist_t *)p_this;
const playlist_export_t *p_export =
const char hexchars[16] = "0123456789ABCDEF";
/* prototypes */
-int E_(xspf_export_playlist)( vlc_object_t * );
+int xspf_export_playlist( vlc_object_t * );
static void xspf_export_item( playlist_item_t *, FILE *, int * );
static void xspf_extension_item( playlist_item_t *, FILE *, int * );
static char *assertUTF8URI( char * );
#define _CSA_H 1
typedef struct csa_t csa_t;
-#define csa_New E_(__csa_New)
-#define csa_Delete E_(__csa_Delete)
-#define csa_SetCW E_(__csa_SetCW)
-#define csa_Decrypt E_(__csa_decrypt)
-#define csa_Encrypt E_(__csa_encrypt)
+#define csa_New __csa_New
+#define csa_Delete __csa_Delete
+#define csa_SetCW __csa_SetCW
+#define csa_Decrypt __csa_decrypt
+#define csa_Encrypt __csa_encrypt
csa_t *csa_New( void );
void csa_Delete( csa_t * );
}
}
-int E_( EStoPES )( sout_instance_t *p_sout, block_t **pp_pes, block_t *p_es,
+int EStoPES ( sout_instance_t *p_sout, block_t **pp_pes, block_t *p_es,
es_format_t *p_fmt, int i_stream_id,
int b_mpeg2, int b_data_alignment, int i_header_size,
int i_max_pes_size )
#define PES_PAYLOAD_SIZE_MAX 65500
-int E_( EStoPES )( sout_instance_t *p_sout, block_t **pp_pes, block_t *p_es,
+int EStoPES ( sout_instance_t *p_sout, block_t **pp_pes, block_t *p_es,
es_format_t *p_fmt, int i_stream_id,
int b_mpeg2, int b_data_alignment, int i_header_size,
int i_max_pes_size );
/* Get and mux a packet */
p_data = block_FifoGet( p_input->p_fifo );
- E_( EStoPES )( p_mux->p_sout, &p_data, p_data,
+ EStoPES ( p_mux->p_sout, &p_data, p_data,
p_input->p_fmt, p_stream->i_stream_id,
p_sys->b_mpeg2, 0, 0, p_sys->i_pes_max_size );
p_spu->p_buffer[1] = 1;
p_spu->p_buffer[2] = ' ';
- E_(EStoPES)( p_mux->p_sout, &p_spu, p_spu,
+ EStoPES( p_mux->p_sout, &p_spu, p_spu,
p_input->p_fmt,
p_stream->i_stream_id, 1,
0, 0, 0 );
p_data->i_pts = p_data->i_dts;
}
- E_( EStoPES )( p_mux->p_sout, &p_data, p_data,
+ EStoPES ( p_mux->p_sout, &p_data, p_data,
p_input->p_fmt, p_stream->i_stream_id,
1, b_data_alignment, i_header_size, 0 );
{
#if defined (MODULE_NAME_IS_i420_rgb)
case VLC_FOURCC('R','G','B','2'):
- p_vout->chroma.pf_convert = E_(I420_RGB8);
+ p_vout->chroma.pf_convert = I420_RGB8;
break;
#endif
case VLC_FOURCC('R','V','1','5'):
{
/* R5G5B6 pixel format */
msg_Dbg(p_this, "RGB pixel format is R5G5B5");
- p_vout->chroma.pf_convert = E_(I420_R5G5B5);
+ p_vout->chroma.pf_convert = I420_R5G5B5;
}
else if( ( p_vout->output.i_rmask == 0xf800
&& p_vout->output.i_gmask == 0x07e0
{
/* R5G6B5 pixel format */
msg_Dbg(p_this, "RGB pixel format is R5G6B5");
- p_vout->chroma.pf_convert = E_(I420_R5G6B5);
+ p_vout->chroma.pf_convert = I420_R5G6B5;
}
else
return -1;
#else
// generic C chroma converter */
- p_vout->chroma.pf_convert = E_(I420_RGB16);
+ p_vout->chroma.pf_convert = I420_RGB16;
#endif
break;
{
/* A8R8G8B8 pixel format */
msg_Dbg(p_this, "RGB pixel format is A8R8G8B8");
- p_vout->chroma.pf_convert = E_(I420_A8R8G8B8);
+ p_vout->chroma.pf_convert = I420_A8R8G8B8;
}
else if( p_vout->output.i_rmask == 0xff000000
&& p_vout->output.i_gmask == 0x00ff0000
{
/* R8G8B8A8 pixel format */
msg_Dbg(p_this, "RGB pixel format is R8G8B8A8");
- p_vout->chroma.pf_convert = E_(I420_R8G8B8A8);
+ p_vout->chroma.pf_convert = I420_R8G8B8A8;
}
else if( p_vout->output.i_rmask == 0x0000ff00
&& p_vout->output.i_gmask == 0x00ff0000
{
/* B8G8R8A8 pixel format */
msg_Dbg(p_this, "RGB pixel format is B8G8R8A8");
- p_vout->chroma.pf_convert = E_(I420_B8G8R8A8);
+ p_vout->chroma.pf_convert = I420_B8G8R8A8;
}
else if( p_vout->output.i_rmask == 0x000000ff
&& p_vout->output.i_gmask == 0x0000ff00
{
/* A8B8G8R8 pixel format */
msg_Dbg(p_this, "RGB pixel format is A8B8G8R8");
- p_vout->chroma.pf_convert = E_(I420_A8B8G8R8);
+ p_vout->chroma.pf_convert = I420_A8B8G8R8;
}
else
return -1;
#else
/* generic C chroma converter */
- p_vout->chroma.pf_convert = E_(I420_RGB32);
+ p_vout->chroma.pf_convert = I420_RGB32;
#endif
break;
* Prototypes
*****************************************************************************/
#ifdef MODULE_NAME_IS_i420_rgb
-void E_(I420_RGB8) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_RGB16_dither) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_RGB16) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_RGB32) ( vout_thread_t *, picture_t *, picture_t * );
+void I420_RGB8 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_RGB16_dither ( vout_thread_t *, picture_t *, picture_t * );
+void I420_RGB16 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_RGB32 ( vout_thread_t *, picture_t *, picture_t * );
#else // if defined(MODULE_NAME_IS_i420_rgb_mmx)
-void E_(I420_R5G5B5) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_R5G6B5) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_A8R8G8B8) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_R8G8B8A8) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_B8G8R8A8) ( vout_thread_t *, picture_t *, picture_t * );
-void E_(I420_A8B8G8R8) ( vout_thread_t *, picture_t *, picture_t * );
+void I420_R5G5B5 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_R5G6B5 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_A8R8G8B8 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_R8G8B8A8 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_B8G8R8A8 ( vout_thread_t *, picture_t *, picture_t * );
+void I420_A8B8G8R8 ( vout_thread_t *, picture_t *, picture_t * );
#endif
/*****************************************************************************
* - input: 2 lines (2 Y lines, 1 U/V line)
* - output: 1 line
*****************************************************************************/
-void E_(I420_RGB16_dither)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_RGB16_dither( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#if defined (MODULE_NAME_IS_i420_rgb)
-void E_(I420_RGB16)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_RGB16( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#else // ! defined (MODULE_NAME_IS_i420_rgb)
-void E_(I420_R5G5B5)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_R5G5B5( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#endif
}
-void E_(I420_R5G6B5)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_R5G6B5( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#if defined (MODULE_NAME_IS_i420_rgb)
-void E_(I420_RGB32)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_RGB32( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#else // defined (MODULE_NAME_IS_i420_rgb_mmx) || defined (MODULE_NAME_IS_i420_rgb_sse2)
-void E_(I420_A8R8G8B8)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_A8R8G8B8( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#endif
}
-void E_(I420_R8G8B8A8)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_R8G8B8A8( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#endif
}
-void E_(I420_B8G8R8A8)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_B8G8R8A8( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
#endif
}
-void E_(I420_A8B8G8R8)( vout_thread_t *p_vout, picture_t *p_src,
+void I420_A8B8G8R8( vout_thread_t *p_vout, picture_t *p_src,
picture_t *p_dest )
{
/* We got this one from the old arguments */
/*****************************************************************************
* I420_RGB8: color YUV 4:2:0 to RGB 8 bpp
*****************************************************************************/
-void E_(I420_RGB8)( vout_thread_t *p_vout, picture_t *p_src, picture_t *p_dest )
+void I420_RGB8( vout_thread_t *p_vout, picture_t *p_src, picture_t *p_dest )
{
/* We got this one from the old arguments */
uint8_t *p_pic = (uint8_t*)p_dest->p->p_pixels;
vlc_object_create( p_vout, sizeof(event_thread_t) );
p_vout->p_sys->p_event->p_vout = p_vout;
if( vlc_thread_create( p_vout->p_sys->p_event, "Vout Events Thread",
- E_(EventThread), 0, 1 ) )
+ EventThread, 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
vlc_object_release( p_vout->p_sys->p_event );
p_vout->output.i_height = p_vout->render.i_height;
p_vout->output.i_aspect = p_vout->render.i_aspect;
p_vout->fmt_out = p_vout->fmt_in;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
/* create picture pool */
p_vout->output.i_chroma = 0;
p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
}
/* We used to call the Win32 PeekMessage function here to read the window
vlc_object_create( p_vout, sizeof(event_thread_t) );
p_vout->p_sys->p_event->p_vout = p_vout;
if( vlc_thread_create( p_vout->p_sys->p_event, "Vout Events Thread",
- E_(EventThread), 0, 1 ) )
+ EventThread, 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
vlc_object_release( p_vout->p_sys->p_event );
p_vout->output.i_height = p_vout->render.i_height;
p_vout->output.i_aspect = p_vout->render.i_aspect;
p_vout->fmt_out = p_vout->fmt_in;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
#define MAX_DIRECTBUFFERS 1
/* Right now we use only 1 directbuffer because we don't want the
p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
}
/* We used to call the Win32 PeekMessage function here to read the window
p_vout->p_sys->i_rgb_colorkey =
DirectXFindColorkey( p_vout, &p_vout->p_sys->i_colorkey );
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
return VLC_SUCCESS;
}
* The main goal of this thread is to isolate the Win32 PeekMessage function
* because this one can block for a long time.
*****************************************************************************/
-void E_(EventThread)( event_thread_t *p_event )
+void EventThread( event_thread_t *p_event )
{
MSG msg;
POINT old_mouse_pos = {0,0}, mouse_pos;
* its job is to update the source and destination RECTs used to display the
* picture.
*****************************************************************************/
-void E_(UpdateRects)( vout_thread_t *p_vout, bool b_force )
+void UpdateRects( vout_thread_t *p_vout, bool b_force )
{
#define rect_src p_vout->p_sys->rect_src
#define rect_src_clipped p_vout->p_sys->rect_src_clipped
{
case WM_WINDOWPOSCHANGED:
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
return 0;
/* the user wants to close the window */
vlc_object_create( p_vout, sizeof(event_thread_t) );
p_vout->p_sys->p_event->p_vout = p_vout;
if( vlc_thread_create( p_vout->p_sys->p_event, "Vout Events Thread",
- E_(EventThread), 0, 1 ) )
+ EventThread, 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
vlc_object_release( p_vout->p_sys->p_event );
p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
}
/* We used to call the Win32 PeekMessage function here to read the window
/*****************************************************************************
* Prototypes from events.c
*****************************************************************************/
-void E_(EventThread) ( event_thread_t *p_event );
-void E_(UpdateRects) ( vout_thread_t *p_vout, bool b_force );
+void EventThread ( event_thread_t *p_event );
+void UpdateRects ( vout_thread_t *p_vout, bool b_force );
void Win32ToggleFullscreen ( vout_thread_t *p_vout );
/*****************************************************************************
vlc_object_create( p_vout, sizeof(event_thread_t) );
p_vout->p_sys->p_event->p_vout = p_vout;
if( vlc_thread_create( p_vout->p_sys->p_event, "VLC Vout Events Thread",
- E_(EventThread), 0, 1 ) )
+ EventThread, 0, 1 ) )
{
msg_Err( p_vout, "cannot create Vout EventThread" );
vlc_object_release( p_vout->p_sys->p_event );
/* Change the window title bar text */
PostMessage( p_vout->p_sys->hwnd, WM_VLC_CHANGE_TEXT, 0, 0 );
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
return VLC_SUCCESS;
}
p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
- E_(UpdateRects)( p_vout, true );
+ UpdateRects( p_vout, true );
}
/*
/*****************************************************************************
* Exported prototypes
*****************************************************************************/
-extern int E_(Activate) ( vlc_object_t * );
-extern void E_(Deactivate) ( vlc_object_t * );
+extern int Activate ( vlc_object_t * );
+extern void Deactivate ( vlc_object_t * );
/*****************************************************************************
* CreateOpenGL: initialize an OpenGL provider
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
- if( E_(Activate)( p_this ) != VLC_SUCCESS )
+ if( Activate( p_this ) != VLC_SUCCESS )
{
return VLC_EGENERIC;
}
glXDestroyWindow( p_sys->p_display, p_sys->gwnd );
}
- E_(Deactivate)( p_this );
+ Deactivate( p_this );
}
/*****************************************************************************
/*****************************************************************************
* Exported prototypes
*****************************************************************************/
-extern int E_(Activate) ( vlc_object_t * );
-extern void E_(Deactivate) ( vlc_object_t * );
+extern int Activate ( vlc_object_t * );
+extern void Deactivate ( vlc_object_t * );
/*****************************************************************************
* Module descriptor
#endif
set_description( _("X11 video output") );
set_capability( "video output", 70 );
- set_callbacks( E_(Activate), E_(Deactivate) );
+ set_callbacks( Activate, Deactivate );
vlc_module_end();
/*****************************************************************************
* Local prototypes
*****************************************************************************/
-int E_(Activate) ( vlc_object_t * );
-void E_(Deactivate) ( vlc_object_t * );
+int Activate ( vlc_object_t * );
+void Deactivate ( vlc_object_t * );
static int InitVideo ( vout_thread_t * );
static void EndVideo ( vout_thread_t * );
* vout properties to choose the window size, and change them according to the
* actual properties of the display.
*****************************************************************************/
-int E_(Activate) ( vlc_object_t *p_this )
+int Activate ( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
char * psz_display;
if( checkXvMCCap( p_vout ) == VLC_EGENERIC )
{
msg_Err( p_vout, "no XVMC capability found" );
- E_(Deactivate)( p_vout );
+ Deactivate( p_vout );
return VLC_EGENERIC;
}
subpicture_t sub_pic;
*****************************************************************************
* Terminate an output method created by Open
*****************************************************************************/
-void E_(Deactivate) ( vlc_object_t *p_this )
+void Deactivate ( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
/*****************************************************************************
* Exported prototypes
*****************************************************************************/
-extern int E_(Activate) ( vlc_object_t * );
-extern void E_(Deactivate) ( vlc_object_t * );
+extern int Activate ( vlc_object_t * );
+extern void Deactivate ( vlc_object_t * );
/*****************************************************************************
* Module descriptor
set_description( _("XVideo extension video output") );
set_capability( "video output", 150 );
- set_callbacks( E_(Activate), E_(Deactivate) );
+ set_callbacks( Activate, Deactivate );
vlc_module_end();
/* following functions are local */
/*****************************************************************************
* Exported prototypes
*****************************************************************************/
-extern int E_(Activate) ( vlc_object_t * );
-extern void E_(Deactivate) ( vlc_object_t * );
+extern int Activate ( vlc_object_t * );
+extern void Deactivate ( vlc_object_t * );
/*****************************************************************************
* Module descriptor
set_description( _("XVMC extension video output") );
set_capability( "video output", 10 );
- set_callbacks( E_(Activate), E_(Deactivate) );
+ set_callbacks( Activate, Deactivate );
vlc_module_end();
/* following functions are local */
projects / vlc / commitdiff