Replace VLC_EXPORT macro with a simple prefix, VLC_API

This should help Doxygen parse VLC headers, and generally makes headers
easier to read. LibVLC already uses a similar approach.

include/vlc_access.h

@@ -151,7 +151,7 @@ static inline void access_InitFields( access_t *p_a )
  * This function will return the parent input of this access.
  * It is retained. It can return NULL.
  */
-VLC_EXPORT( input_thread_t *, access_GetParentInput, ( access_t *p_access ) LIBVLC_USED );
+VLC_API input_thread_t * access_GetParentInput( access_t *p_access ) LIBVLC_USED;
 
 #define ACCESS_SET_CALLBACKS( read, block, control, seek )              \
     p_access->pf_read = read;                                           \

include/vlc_acl.h

@@ -26,15 +26,15 @@
 # define VLC_ACL_H
 
 
-VLC_EXPORT( int, ACL_Check, ( vlc_acl_t *p_acl, const char *psz_ip ) );
-VLC_EXPORT( vlc_acl_t *, ACL_Create, ( vlc_object_t *p_this, bool b_allow ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API int ACL_Check( vlc_acl_t *p_acl, const char *psz_ip );
+VLC_API vlc_acl_t * ACL_Create( vlc_object_t *p_this, bool b_allow ) LIBVLC_USED LIBVLC_MALLOC;
 #define ACL_Create(a, b) ACL_Create(VLC_OBJECT(a), b)
-VLC_EXPORT( vlc_acl_t *, ACL_Duplicate, ( vlc_object_t *p_this, const vlc_acl_t *p_acl ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API vlc_acl_t * ACL_Duplicate( vlc_object_t *p_this, const vlc_acl_t *p_acl ) LIBVLC_USED LIBVLC_MALLOC;
 #define ACL_Duplicate(a,b) ACL_Duplicate(VLC_OBJECT(a),b)
-VLC_EXPORT( void, ACL_Destroy, ( vlc_acl_t *p_acl ) );
+VLC_API void ACL_Destroy( vlc_acl_t *p_acl );
 
 #define ACL_AddHost(a,b,c) ACL_AddNet(a,b,-1,c)
-VLC_EXPORT( int, ACL_AddNet, ( vlc_acl_t *p_acl, const char *psz_ip, int i_len, bool b_allow ) );
-VLC_EXPORT( int, ACL_LoadFile, ( vlc_acl_t *p_acl, const char *path ) );
+VLC_API int ACL_AddNet( vlc_acl_t *p_acl, const char *psz_ip, int i_len, bool b_allow );
+VLC_API int ACL_LoadFile( vlc_acl_t *p_acl, const char *path );
 
 #endif

include/vlc_aout.h

@@ -256,7 +256,7 @@ static const uint32_t pi_vlc_chan_order_wg4[] =
  * Prototypes
  *****************************************************************************/
 
-VLC_EXPORT( aout_buffer_t *, aout_OutputNextBuffer, ( aout_instance_t *, mtime_t, bool ) LIBVLC_USED );
+VLC_API aout_buffer_t * aout_OutputNextBuffer( aout_instance_t *, mtime_t, bool ) LIBVLC_USED;
 
 /**
  * This function computes the reordering needed to go from pi_chan_order_in to
@@ -264,8 +264,8 @@ VLC_EXPORT( aout_buffer_t *, aout_OutputNextBuffer, ( aout_instance_t *, mtime_t
  * If pi_chan_order_in or pi_chan_order_out is NULL, it will assume that vlc
  * internal (WG4) order is requested.
  */
-VLC_EXPORT( int, aout_CheckChannelReorder, ( const uint32_t *pi_chan_order_in, const uint32_t *pi_chan_order_out, uint32_t i_channel_mask, int i_channels, int *pi_chan_table ) );
-VLC_EXPORT( void, aout_ChannelReorder, ( uint8_t *, int, int, const int *, int ) );
+VLC_API int aout_CheckChannelReorder( const uint32_t *pi_chan_order_in, const uint32_t *pi_chan_order_out, uint32_t i_channel_mask, int i_channels, int *pi_chan_table );
+VLC_API void aout_ChannelReorder( uint8_t *, int, int, const int *, int );
 
 /**
  * This fonction will compute the extraction parameter into pi_selection to go
@@ -283,7 +283,7 @@ VLC_EXPORT( void, aout_ChannelReorder, ( uint8_t *, int, int, const int *, int )
  * by VLC. In this case the channel type pi_order_src[] must be set to 0.
  * XXX It must also be used if multiple channels have the same type.
  */
-VLC_EXPORT( bool, aout_CheckChannelExtraction, ( int *pi_selection, uint32_t *pi_layout, int *pi_channels, const uint32_t pi_order_dst[AOUT_CHAN_MAX], const uint32_t *pi_order_src, int i_channels ) );
+VLC_API bool aout_CheckChannelExtraction( int *pi_selection, uint32_t *pi_layout, int *pi_channels, const uint32_t pi_order_dst[AOUT_CHAN_MAX], const uint32_t *pi_order_src, int i_channels );
 
 /**
  * Do the actual channels extraction using the parameters created by
@@ -292,7 +292,7 @@ VLC_EXPORT( bool, aout_CheckChannelExtraction, ( int *pi_selection, uint32_t *pi
  * XXX this function does not work in place (p_dst and p_src must not overlap).
  * XXX Only 8, 16, 24, 32, 64 bits per sample are supported.
  */
-VLC_EXPORT( void, aout_ChannelExtract, ( void *p_dst, int i_dst_channels, const void *p_src, int i_src_channels, int i_sample_count, const int *pi_selection, int i_bits_per_sample ) );
+VLC_API void aout_ChannelExtract( void *p_dst, int i_dst_channels, const void *p_src, int i_src_channels, int i_sample_count, const int *pi_selection, int i_bits_per_sample );
 
 /* */
 static inline unsigned aout_FormatNbChannels(const audio_sample_format_t *fmt)
@@ -300,37 +300,37 @@ static inline unsigned aout_FormatNbChannels(const audio_sample_format_t *fmt)
     return popcount(fmt->i_physical_channels & AOUT_CHAN_PHYSMASK);
 }
 
-VLC_EXPORT( unsigned int, aout_BitsPerSample, ( vlc_fourcc_t i_format ) LIBVLC_USED );
-VLC_EXPORT( void, aout_FormatPrepare, ( audio_sample_format_t * p_format ) );
-VLC_EXPORT( void, aout_FormatPrint, ( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format ) );
-VLC_EXPORT( const char *, aout_FormatPrintChannels, ( const audio_sample_format_t * ) LIBVLC_USED );
+VLC_API unsigned int aout_BitsPerSample( vlc_fourcc_t i_format ) LIBVLC_USED;
+VLC_API void aout_FormatPrepare( audio_sample_format_t * p_format );
+VLC_API void aout_FormatPrint( aout_instance_t * p_aout, const char * psz_text, const audio_sample_format_t * p_format );
+VLC_API const char * aout_FormatPrintChannels( const audio_sample_format_t * ) LIBVLC_USED;
 
-VLC_EXPORT( mtime_t, aout_FifoFirstDate, ( aout_instance_t *, aout_fifo_t * ) LIBVLC_USED );
-VLC_EXPORT( aout_buffer_t *, aout_FifoPop, ( aout_instance_t * p_aout, aout_fifo_t * p_fifo ) LIBVLC_USED );
+VLC_API mtime_t aout_FifoFirstDate( aout_instance_t *, aout_fifo_t * ) LIBVLC_USED;
+VLC_API aout_buffer_t * aout_FifoPop( aout_instance_t * p_aout, aout_fifo_t * p_fifo ) LIBVLC_USED;
 
 /* From intf.c : */
-VLC_EXPORT( void, aout_VolumeSoftInit, ( aout_instance_t * ) );
-VLC_EXPORT( void, aout_VolumeNoneInit, ( aout_instance_t * ) );
-VLC_EXPORT( audio_volume_t, aout_VolumeGet, ( vlc_object_t * ) );
+VLC_API void aout_VolumeSoftInit( aout_instance_t * );
+VLC_API void aout_VolumeNoneInit( aout_instance_t * );
+VLC_API audio_volume_t aout_VolumeGet( vlc_object_t * );
 #define aout_VolumeGet(a) aout_VolumeGet(VLC_OBJECT(a))
-VLC_EXPORT( int, aout_VolumeSet, ( vlc_object_t *, audio_volume_t ) );
+VLC_API int aout_VolumeSet( vlc_object_t *, audio_volume_t );
 #define aout_VolumeSet(a, b) aout_VolumeSet(VLC_OBJECT(a), b)
-VLC_EXPORT( int, aout_VolumeUp, ( vlc_object_t *, int, audio_volume_t * ) );
+VLC_API int aout_VolumeUp( vlc_object_t *, int, audio_volume_t * );
 #define aout_VolumeUp(a, b, c) aout_VolumeUp(VLC_OBJECT(a), b, c)
-VLC_EXPORT( int, aout_VolumeDown, ( vlc_object_t *, int, audio_volume_t * ) );
+VLC_API int aout_VolumeDown( vlc_object_t *, int, audio_volume_t * );
 #define aout_VolumeDown(a, b, c) aout_VolumeDown(VLC_OBJECT(a), b, c)
-VLC_EXPORT( int, aout_ToggleMute, ( vlc_object_t *, audio_volume_t * ) );
+VLC_API int aout_ToggleMute( vlc_object_t *, audio_volume_t * );
 #define aout_ToggleMute(a, b) aout_ToggleMute(VLC_OBJECT(a), b)
-VLC_EXPORT( int, aout_SetMute, ( vlc_object_t *, audio_volume_t *, bool ) );
-VLC_EXPORT( bool, aout_IsMuted, ( vlc_object_t * ) );
-VLC_EXPORT( int, aout_ChannelsRestart, ( vlc_object_t *, const char *, vlc_value_t, vlc_value_t, void * ) );
+VLC_API int aout_SetMute( vlc_object_t *, audio_volume_t *, bool );
+VLC_API bool aout_IsMuted( vlc_object_t * );
+VLC_API int aout_ChannelsRestart( vlc_object_t *, const char *, vlc_value_t, vlc_value_t, void * );
 
-VLC_EXPORT( void, aout_EnableFilter, (vlc_object_t *, const char *, bool ));
+VLC_API void aout_EnableFilter(vlc_object_t *, const char *, bool );
 #define aout_EnableFilter( o, n, b ) \
         aout_EnableFilter( VLC_OBJECT(o), n, b )
 
 /* */
-VLC_EXPORT( vout_thread_t *, aout_filter_RequestVout, ( filter_t *, vout_thread_t *p_vout, video_format_t *p_fmt ) LIBVLC_USED );
+VLC_API vout_thread_t * aout_filter_RequestVout( filter_t *, vout_thread_t *p_vout, video_format_t *p_fmt ) LIBVLC_USED;
 
 # ifdef __cplusplus
 }

include/vlc_atomic.h

@@ -28,9 +28,9 @@
 
 /* All functions return the atom value _after_ the operation. */
 
-VLC_EXPORT(uintptr_t, vlc_atomic_get, (const vlc_atomic_t *));
-VLC_EXPORT(uintptr_t, vlc_atomic_set, (vlc_atomic_t *, uintptr_t));
-VLC_EXPORT(uintptr_t, vlc_atomic_add, (vlc_atomic_t *, uintptr_t));
+VLC_API uintptr_t vlc_atomic_get(const vlc_atomic_t *);
+VLC_API uintptr_t vlc_atomic_set(vlc_atomic_t *, uintptr_t);
+VLC_API uintptr_t vlc_atomic_add(vlc_atomic_t *, uintptr_t);
 
 static inline uintptr_t vlc_atomic_sub (vlc_atomic_t *atom, uintptr_t v)
 {
@@ -47,7 +47,7 @@ static inline uintptr_t vlc_atomic_dec (vlc_atomic_t *atom)
     return vlc_atomic_sub (atom, 1);
 }
 
-VLC_EXPORT(uintptr_t, vlc_atomic_swap, (vlc_atomic_t *, uintptr_t));
-VLC_EXPORT(uintptr_t, vlc_atomic_compare_swap, (vlc_atomic_t *, uintptr_t, uintptr_t));
+VLC_API uintptr_t vlc_atomic_swap(vlc_atomic_t *, uintptr_t);
+VLC_API uintptr_t vlc_atomic_compare_swap(vlc_atomic_t *, uintptr_t, uintptr_t);
 
 #endif

include/vlc_block.h

@@ -136,9 +136,9 @@ struct block_t
  *      and decrease are supported). Use it as it is optimised.
  * - block_Duplicate : create a copy of a block.
  ****************************************************************************/
-VLC_EXPORT( void,      block_Init,    ( block_t *, void *, size_t ) );
-VLC_EXPORT( block_t *, block_Alloc,   ( size_t ) LIBVLC_USED );
-VLC_EXPORT( block_t *, block_Realloc, ( block_t *, ssize_t i_pre, size_t i_body ) LIBVLC_USED );
+VLC_API void block_Init( block_t *, void *, size_t );
+VLC_API block_t * block_Alloc( size_t ) LIBVLC_USED;
+VLC_API block_t * block_Realloc( block_t *, ssize_t i_pre, size_t i_body ) LIBVLC_USED;
 
 #define block_New( dummy, size ) block_Alloc(size)
 
@@ -165,9 +165,9 @@ static inline void block_Release( block_t *p_block )
     p_block->pf_release( p_block );
 }
 
-VLC_EXPORT( block_t *, block_heap_Alloc, (void *, void *, size_t) LIBVLC_USED );
-VLC_EXPORT( block_t *, block_mmap_Alloc, (void *addr, size_t length) LIBVLC_USED );
-VLC_EXPORT( block_t *, block_File, (int fd) LIBVLC_USED );
+VLC_API block_t * block_heap_Alloc(void *, void *, size_t) LIBVLC_USED;
+VLC_API block_t * block_mmap_Alloc(void *addr, size_t length) LIBVLC_USED;
+VLC_API block_t * block_File(int fd) LIBVLC_USED;
 
 static inline void block_Cleanup (void *block)
 {
@@ -306,15 +306,15 @@ static inline block_t *block_ChainGather( block_t *p_list )
  * block_FifoGet and block_FifoShow are cancellation points.
  ****************************************************************************/
 
-VLC_EXPORT( block_fifo_t *, block_FifoNew,      ( void ) LIBVLC_USED );
-VLC_EXPORT( void,           block_FifoRelease,  ( block_fifo_t * ) );
-VLC_EXPORT( void,           block_FifoPace,     ( block_fifo_t *fifo, size_t max_depth, size_t max_size ) );
-VLC_EXPORT( void,           block_FifoEmpty,    ( block_fifo_t * ) );
-VLC_EXPORT( size_t,         block_FifoPut,      ( block_fifo_t *, block_t * ) );
-VLC_EXPORT( void,           block_FifoWake,     ( block_fifo_t * ) );
-VLC_EXPORT( block_t *,      block_FifoGet,      ( block_fifo_t * ) LIBVLC_USED );
-VLC_EXPORT( block_t *,      block_FifoShow,     ( block_fifo_t * ) );
+VLC_API block_fifo_t * block_FifoNew( void ) LIBVLC_USED;
+VLC_API void block_FifoRelease( block_fifo_t * );
+VLC_API void block_FifoPace( block_fifo_t *fifo, size_t max_depth, size_t max_size );
+VLC_API void block_FifoEmpty( block_fifo_t * );
+VLC_API size_t block_FifoPut( block_fifo_t *, block_t * );
+VLC_API void block_FifoWake( block_fifo_t * );
+VLC_API block_t * block_FifoGet( block_fifo_t * ) LIBVLC_USED;
+VLC_API block_t * block_FifoShow( block_fifo_t * );
 size_t block_FifoSize( const block_fifo_t *p_fifo ) LIBVLC_USED;
-VLC_EXPORT( size_t,         block_FifoCount,    ( const block_fifo_t *p_fifo ) LIBVLC_USED );
+VLC_API size_t block_FifoCount( const block_fifo_t *p_fifo ) LIBVLC_USED;
 
 #endif /* VLC_BLOCK_H */

include/vlc_charset.h

@@ -32,24 +32,24 @@
 
 /* iconv wrappers (defined in src/extras/libc.c) */
 typedef void *vlc_iconv_t;
-VLC_EXPORT( vlc_iconv_t, vlc_iconv_open, ( const char *, const char * ) LIBVLC_USED );
-VLC_EXPORT( size_t, vlc_iconv, ( vlc_iconv_t, const char **, size_t *, char **, size_t * ) LIBVLC_USED );
-VLC_EXPORT( int, vlc_iconv_close, ( vlc_iconv_t ) );
+VLC_API vlc_iconv_t vlc_iconv_open( const char *, const char * ) LIBVLC_USED;
+VLC_API size_t vlc_iconv( vlc_iconv_t, const char **, size_t *, char **, size_t * ) LIBVLC_USED;
+VLC_API int vlc_iconv_close( vlc_iconv_t );
 
 #include <stdarg.h>
 
-VLC_EXPORT( void, LocaleFree, ( const char * ) );
-VLC_EXPORT( char *, FromLocale, ( const char * ) LIBVLC_USED );
-VLC_EXPORT( char *, FromLocaleDup, ( const char * ) LIBVLC_USED );
-VLC_EXPORT( char *, ToLocale, ( const char * ) LIBVLC_USED );
-VLC_EXPORT( char *, ToLocaleDup, ( const char * ) LIBVLC_USED );
+VLC_API void LocaleFree( const char * );
+VLC_API char * FromLocale( const char * ) LIBVLC_USED;
+VLC_API char * FromLocaleDup( const char * ) LIBVLC_USED;
+VLC_API char * ToLocale( const char * ) LIBVLC_USED;
+VLC_API char * ToLocaleDup( const char * ) LIBVLC_USED;
 
-VLC_EXPORT( int, utf8_vfprintf, ( FILE *stream, const char *fmt, va_list ap ) );
-VLC_EXPORT( int, utf8_fprintf, ( FILE *, const char *, ... ) LIBVLC_FORMAT( 2, 3 ) );
-VLC_EXPORT( char *, vlc_strcasestr, (const char *, const char *) LIBVLC_USED );
+VLC_API int utf8_vfprintf( FILE *stream, const char *fmt, va_list ap );
+VLC_API int utf8_fprintf( FILE *, const char *, ... ) LIBVLC_FORMAT( 2, 3 );
+VLC_API char * vlc_strcasestr(const char *, const char *) LIBVLC_USED;
 
-VLC_EXPORT( char *, EnsureUTF8, ( char * ) );
-VLC_EXPORT( const char *, IsUTF8, ( const char * ) LIBVLC_USED );
+VLC_API char * EnsureUTF8( char * );
+VLC_API const char * IsUTF8( const char * ) LIBVLC_USED;
 
 #ifdef WIN32
 LIBVLC_USED
@@ -108,13 +108,13 @@ static inline char *FromLatin1 (const char *latin)
     return utf8 ? utf8 : str;
 }
 
-VLC_EXPORT( char *, FromCharset, ( const char *charset, const void *data, size_t data_size ) LIBVLC_USED );
-VLC_EXPORT( void *, ToCharset, ( const char *charset, const char *in, size_t *outsize ) LIBVLC_USED );
+VLC_API char * FromCharset( const char *charset, const void *data, size_t data_size ) LIBVLC_USED;
+VLC_API void * ToCharset( const char *charset, const char *in, size_t *outsize ) LIBVLC_USED;
 
-VLC_EXPORT( double, us_strtod, ( const char *, char ** ) LIBVLC_USED );
-VLC_EXPORT( float, us_strtof, ( const char *, char ** ) LIBVLC_USED );
-VLC_EXPORT( double, us_atof, ( const char * ) LIBVLC_USED );
-VLC_EXPORT( int, us_vasprintf, ( char **, const char *, va_list ) );
-VLC_EXPORT( int, us_asprintf, ( char **, const char *, ... ) LIBVLC_USED );
+VLC_API double us_strtod( const char *, char ** ) LIBVLC_USED;
+VLC_API float us_strtof( const char *, char ** ) LIBVLC_USED;
+VLC_API double us_atof( const char * ) LIBVLC_USED;
+VLC_API int us_vasprintf( char **, const char *, va_list );
+VLC_API int us_asprintf( char **, const char *, ... ) LIBVLC_USED;
 
 #endif

include/vlc_codec.h

@@ -180,67 +180,67 @@ struct encoder_t
  * buffer. You have to release it using decoder_DeletePicture or by returning
  * it to the caller as a pf_decode_video return value.
  */
-VLC_EXPORT( picture_t *, decoder_NewPicture, ( decoder_t * ) LIBVLC_USED );
+VLC_API picture_t * decoder_NewPicture( decoder_t * ) LIBVLC_USED;
 
 /**
  * This function will release a picture create by decoder_NewPicture.
  */
-VLC_EXPORT( void, decoder_DeletePicture, ( decoder_t *, picture_t *p_picture ) );
+VLC_API void decoder_DeletePicture( decoder_t *, picture_t *p_picture );
 
 /**
  * This function will increase the picture reference count.
  * (picture_Hold is not usable.)
  */
-VLC_EXPORT( void, decoder_LinkPicture, ( decoder_t *, picture_t * ) );
+VLC_API void decoder_LinkPicture( decoder_t *, picture_t * );
 
 /**
  * This function will decrease the picture reference count.
  * (picture_Release is not usable.)
  */
-VLC_EXPORT( void, decoder_UnlinkPicture, ( decoder_t *, picture_t * ) );
+VLC_API void decoder_UnlinkPicture( decoder_t *, picture_t * );
 
 /**
  * This function will return a new audio buffer usable by a decoder as an
  * output buffer. You have to release it using decoder_DeleteAudioBuffer
  * or by returning it to the caller as a pf_decode_audio return value.
  */
-VLC_EXPORT( aout_buffer_t *, decoder_NewAudioBuffer, ( decoder_t *, int i_size ) LIBVLC_USED );
+VLC_API aout_buffer_t * decoder_NewAudioBuffer( decoder_t *, int i_size ) LIBVLC_USED;
 
 /**
  * This function will release a audio buffer created by decoder_NewAudioBuffer.
  */
-VLC_EXPORT( void, decoder_DeleteAudioBuffer, ( decoder_t *, aout_buffer_t *p_buffer ) );
+VLC_API void decoder_DeleteAudioBuffer( decoder_t *, aout_buffer_t *p_buffer );
 
 /**
  * This function will return a new subpicture usable by a decoder as an output
  * buffer. You have to release it using decoder_DeleteSubpicture or by returning
  * it to the caller as a pf_decode_sub return value.
  */
-VLC_EXPORT( subpicture_t *, decoder_NewSubpicture, ( decoder_t *, const subpicture_updater_t * ) LIBVLC_USED );
+VLC_API subpicture_t * decoder_NewSubpicture( decoder_t *, const subpicture_updater_t * ) LIBVLC_USED;
 
 /**
  * This function will release a subpicture created by decoder_NewSubicture.
  */
-VLC_EXPORT( void, decoder_DeleteSubpicture, ( decoder_t *, subpicture_t *p_subpicture ) );
+VLC_API void decoder_DeleteSubpicture( decoder_t *, subpicture_t *p_subpicture );
 
 /**
  * This function gives all input attachments at once.
  *
  * You MUST release the returned values
  */
-VLC_EXPORT( int, decoder_GetInputAttachments, ( decoder_t *, input_attachment_t ***ppp_attachment, int *pi_attachment ) );
+VLC_API int decoder_GetInputAttachments( decoder_t *, input_attachment_t ***ppp_attachment, int *pi_attachment );
 
 /**
  * This function converts a decoder timestamp into a display date comparable
  * to mdate().
  * You MUST use it *only* for gathering statistics about speed.
  */
-VLC_EXPORT( mtime_t, decoder_GetDisplayDate, ( decoder_t *, mtime_t ) LIBVLC_USED );
+VLC_API mtime_t decoder_GetDisplayDate( decoder_t *, mtime_t ) LIBVLC_USED;
 
 /**
  * This function returns the current input rate.
  * You MUST use it *only* for gathering statistics about speed.
  */
-VLC_EXPORT( int, decoder_GetDisplayRate, ( decoder_t * ) LIBVLC_USED );
+VLC_API int decoder_GetDisplayRate( decoder_t * ) LIBVLC_USED;
 
 #endif /* _VLC_CODEC_H */

include/vlc_codec_synchro.h

@@ -37,13 +37,13 @@
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( decoder_synchro_t *, decoder_SynchroInit, ( decoder_t *, int ) LIBVLC_USED );
-VLC_EXPORT( void, decoder_SynchroRelease,        ( decoder_synchro_t * ) );
-VLC_EXPORT( void, decoder_SynchroReset,          ( decoder_synchro_t * ) );
-VLC_EXPORT( bool, decoder_SynchroChoose,   ( decoder_synchro_t *, int, int, bool ) );
-VLC_EXPORT( void, decoder_SynchroTrash,          ( decoder_synchro_t * ) );
-VLC_EXPORT( void, decoder_SynchroDecode,         ( decoder_synchro_t * ) );
-VLC_EXPORT( void, decoder_SynchroEnd,            ( decoder_synchro_t *, int, bool ) );
-VLC_EXPORT( mtime_t, decoder_SynchroDate,        ( decoder_synchro_t * ) LIBVLC_USED );
-VLC_EXPORT( void, decoder_SynchroNewPicture,     ( decoder_synchro_t *, int, int, mtime_t, mtime_t, bool ) );
+VLC_API decoder_synchro_t * decoder_SynchroInit( decoder_t *, int ) LIBVLC_USED;
+VLC_API void decoder_SynchroRelease( decoder_synchro_t * );
+VLC_API void decoder_SynchroReset( decoder_synchro_t * );
+VLC_API bool decoder_SynchroChoose( decoder_synchro_t *, int, int, bool );
+VLC_API void decoder_SynchroTrash( decoder_synchro_t * );
+VLC_API void decoder_SynchroDecode( decoder_synchro_t * );
+VLC_API void decoder_SynchroEnd( decoder_synchro_t *, int, bool );
+VLC_API mtime_t decoder_SynchroDate( decoder_synchro_t * ) LIBVLC_USED;
+VLC_API void decoder_SynchroNewPicture( decoder_synchro_t *, int, int, mtime_t, mtime_t, bool );
 

include/vlc_common.h

@@ -2,12 +2,12 @@
  * common.h: common definitions
  * Collection of useful common types and macros definitions
  *****************************************************************************
- * Copyright (C) 1998-2005 the VideoLAN team
- * $Id$
+ * Copyright (C) 1998-2011 the VideoLAN team
  *
  * Authors: Samuel Hocevar <sam@via.ecp.fr>
  *          Vincent Seguin <seguin@via.ecp.fr>
  *          Gildas Bazin <gbazin@videolan.org>
+ *          Rémi Denis-Courmont
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -108,6 +108,24 @@
 # define LIBVLC_DEPRECATED
 #endif
 
+/* Linkage */
+#ifdef __cplusplus
+# define LIBVLC_EXTERN extern "C"
+#else
+# define LIBVLC_EXTERN
+#endif
+
+#if defined (__GNUC__) && (__GNUC__ >= 4)
+# define LIBVLC_EXPORT __attribute__((visibility("default")))
+#elif defined (WIN32) && defined (DLL_EXPORT)
+# define LIBVLC_EXPORT __declspec(dllexport)
+#else
+# define LIBVLC_EXPORT
+#endif
+
+#define VLC_API LIBVLC_EXTERN LIBVLC_EXPORT
+
+
 /*****************************************************************************
  * Basic types definitions
  *****************************************************************************/
@@ -462,26 +480,6 @@ typedef int ( * vlc_callback_t ) ( vlc_object_t *,      /* variable's object */
                                    vlc_value_t,                 /* new value */
                                    void * );                /* callback data */
 
-/*****************************************************************************
- * Plug-in stuff
- *****************************************************************************/
-
-#ifdef __cplusplus
-# define LIBVLC_EXTERN extern "C"
-#else
-# define LIBVLC_EXTERN extern
-#endif
-#if defined (WIN32) && defined (DLL_EXPORT)
-#if defined (UNDER_CE)
-# include <windef.h>
-#endif
-# define LIBVLC_EXPORT __declspec(dllexport)
-#else
-# define LIBVLC_EXPORT
-#endif
-#define VLC_EXPORT( type, name, args ) \
-                        LIBVLC_EXTERN LIBVLC_EXPORT type name args
-
 /*****************************************************************************
  * OS-specific headers and thread types
  *****************************************************************************/
@@ -557,9 +555,9 @@ typedef struct gc_object_t
  */
 #define VLC_GC_MEMBERS gc_object_t vlc_gc_data;
 
-VLC_EXPORT(void *, vlc_gc_init, (gc_object_t *, void (*)(gc_object_t *)));
-VLC_EXPORT(void *, vlc_hold, (gc_object_t *));
-VLC_EXPORT(void, vlc_release, (gc_object_t *));
+VLC_API void * vlc_gc_init(gc_object_t *, void (*)(gc_object_t *));
+VLC_API void * vlc_hold(gc_object_t *);
+VLC_API void vlc_release(gc_object_t *);
 
 #define vlc_gc_init( a,b ) vlc_gc_init( &(a)->vlc_gc_data, (b) )
 #define vlc_gc_incref( a ) vlc_hold( &(a)->vlc_gc_data )
@@ -649,7 +647,7 @@ static inline unsigned popcount (unsigned x)
 
 #define EMPTY_STR(str) (!str || !*str)
 
-VLC_EXPORT( char const *, vlc_error, ( int ) LIBVLC_USED );
+VLC_API char const * vlc_error( int ) LIBVLC_USED;
 
 #include <vlc_arrays.h>
 
@@ -829,24 +827,24 @@ static inline uint64_t ntoh64 (uint64_t ll)
 #   include <tchar.h>
 #endif
 
-VLC_EXPORT( bool, vlc_ureduce, ( unsigned *, unsigned *, uint64_t, uint64_t, uint64_t ) );
+VLC_API bool vlc_ureduce( unsigned *, unsigned *, uint64_t, uint64_t, uint64_t );
 
-VLC_EXPORT( void *, vlc_memalign, ( void **base, size_t alignment, size_t size ) LIBVLC_USED );
+VLC_API void * vlc_memalign( void **base, size_t alignment, size_t size ) LIBVLC_USED;
 
 /* execve wrapper (defined in src/extras/libc.c) */
-VLC_EXPORT( int, vlc_execve, ( vlc_object_t *p_object, int i_argc, char *const *pp_argv, char *const *pp_env, const char *psz_cwd, const char *p_in, size_t i_in, char **pp_data, size_t *pi_data ) LIBVLC_USED );
+VLC_API int vlc_execve( vlc_object_t *p_object, int i_argc, char *const *pp_argv, char *const *pp_env, const char *psz_cwd, const char *p_in, size_t i_in, char **pp_data, size_t *pi_data ) LIBVLC_USED;
 #define vlc_execve(a,b,c,d,e,f,g,h,i) vlc_execve(VLC_OBJECT(a),b,c,d,e,f,g,h,i)
 
-VLC_EXPORT( void, vlc_tdestroy, ( void *, void (*)(void *) ) );
+VLC_API void vlc_tdestroy( void *, void (*)(void *) );
 
 /* Fast large memory copy and memory set */
-VLC_EXPORT( void *, vlc_memcpy, ( void *, const void *, size_t ) );
-VLC_EXPORT( void *, vlc_memset, ( void *, int, size_t ) );
+VLC_API void * vlc_memcpy( void *, const void *, size_t );
+VLC_API void * vlc_memset( void *, int, size_t );
 
 /*****************************************************************************
  * I18n stuff
  *****************************************************************************/
-VLC_EXPORT( char *, vlc_gettext, ( const char *msgid ) LIBVLC_FORMAT_ARG(1) );
+VLC_API char * vlc_gettext( const char *msgid ) LIBVLC_FORMAT_ARG(1);
 
 #define vlc_pgettext( ctx, id ) \
         vlc_pgettext_aux( ctx "\004" id, id )
@@ -880,9 +878,9 @@ static inline void *xrealloc (void *ptr, size_t len)
 /*****************************************************************************
  * libvlc features
  *****************************************************************************/
-VLC_EXPORT( const char *, VLC_CompileBy, ( void ) LIBVLC_USED );
-VLC_EXPORT( const char *, VLC_CompileHost, ( void ) LIBVLC_USED );
-VLC_EXPORT( const char *, VLC_Compiler, ( void ) LIBVLC_USED );
+VLC_API const char * VLC_CompileBy( void ) LIBVLC_USED;
+VLC_API const char * VLC_CompileHost( void ) LIBVLC_USED;
+VLC_API const char * VLC_Compiler( void ) LIBVLC_USED;
 
 /*****************************************************************************
  * Additional vlc stuff

include/vlc_config_cat.h

@@ -283,7 +283,7 @@ static const struct config_category_t categories_array[] =
 LIBVLC_USED
 static inline const char *config_CategoryNameGet( int i_value )
 {
-    int i = 0 ;
+    int i = 0;
     while( categories_array[i].psz_name != NULL )
     {
         if( categories_array[i].i_id == i_value )
@@ -298,7 +298,7 @@ static inline const char *config_CategoryNameGet( int i_value )
 LIBVLC_USED
 static inline const char *config_CategoryHelpGet( int i_value )
 {
-    int i = 0 ;
+    int i = 0;
     while( categories_array[i].psz_help != NULL )
     {
         if( categories_array[i].i_id == i_value )

include/vlc_configuration.h

@@ -188,25 +188,25 @@ struct module_config_t
  * Prototypes - these methods are used to get, set or manipulate configuration
  * data.
  *****************************************************************************/
-VLC_EXPORT( int,    config_GetType,  (vlc_object_t *, const char *) LIBVLC_USED );
-VLC_EXPORT( int64_t, config_GetInt,  (vlc_object_t *, const char *) LIBVLC_USED );
-VLC_EXPORT( void,   config_PutInt,   (vlc_object_t *, const char *, int64_t) );
-VLC_EXPORT( float,  config_GetFloat, (vlc_object_t *, const char *) LIBVLC_USED );
-VLC_EXPORT( void,   config_PutFloat, (vlc_object_t *, const char *, float) );
-VLC_EXPORT( char *, config_GetPsz,   (vlc_object_t *, const char *) LIBVLC_USED LIBVLC_MALLOC );
-VLC_EXPORT( void,   config_PutPsz,   (vlc_object_t *, const char *, const char *) );
-
-VLC_EXPORT( int,    config_SaveConfigFile, ( vlc_object_t * ) );
+VLC_API int config_GetType(vlc_object_t *, const char *) LIBVLC_USED;
+VLC_API int64_t config_GetInt(vlc_object_t *, const char *) LIBVLC_USED;
+VLC_API void config_PutInt(vlc_object_t *, const char *, int64_t);
+VLC_API float config_GetFloat(vlc_object_t *, const char *) LIBVLC_USED;
+VLC_API void config_PutFloat(vlc_object_t *, const char *, float);
+VLC_API char * config_GetPsz(vlc_object_t *, const char *) LIBVLC_USED LIBVLC_MALLOC;
+VLC_API void config_PutPsz(vlc_object_t *, const char *, const char *);
+
+VLC_API int config_SaveConfigFile( vlc_object_t * );
 #define config_SaveConfigFile(a) config_SaveConfigFile(VLC_OBJECT(a))
 
-VLC_EXPORT( void,   config_ResetAll, ( vlc_object_t * ) );
+VLC_API void config_ResetAll( vlc_object_t * );
 #define config_ResetAll(a) config_ResetAll(VLC_OBJECT(a))
 
-VLC_EXPORT( module_config_t *, config_FindConfig,( vlc_object_t *, const char * ) LIBVLC_USED );
-VLC_EXPORT(char *, config_GetDataDir, ( vlc_object_t * ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API module_config_t * config_FindConfig( vlc_object_t *, const char * ) LIBVLC_USED;
+VLC_API char * config_GetDataDir( vlc_object_t * ) LIBVLC_USED LIBVLC_MALLOC;
 #define config_GetDataDir(a) config_GetDataDir(VLC_OBJECT(a))
-VLC_EXPORT(const char *, config_GetLibDir, ( void ) LIBVLC_USED);
-VLC_EXPORT(const char *, config_GetConfDir, ( void ) LIBVLC_USED);
+VLC_API const char * config_GetLibDir( void ) LIBVLC_USED;
+VLC_API const char * config_GetConfDir( void ) LIBVLC_USED;
 
 typedef enum vlc_userdir
 {
@@ -225,11 +225,11 @@ typedef enum vlc_userdir
     VLC_VIDEOS_DIR,
 } vlc_userdir_t;
 
-VLC_EXPORT(char *, config_GetUserDir, ( vlc_userdir_t ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API char * config_GetUserDir( vlc_userdir_t ) LIBVLC_USED LIBVLC_MALLOC;
 
-VLC_EXPORT( void, config_AddIntf,    ( vlc_object_t *, const char * ) );
-VLC_EXPORT( void, config_RemoveIntf, ( vlc_object_t *, const char * ) );
-VLC_EXPORT( bool, config_ExistIntf,  ( vlc_object_t *, const char * ) LIBVLC_USED);
+VLC_API void config_AddIntf( vlc_object_t *, const char * );
+VLC_API void config_RemoveIntf( vlc_object_t *, const char * );
+VLC_API bool config_ExistIntf( vlc_object_t *, const char * ) LIBVLC_USED;
 
 #define config_GetType(a,b) config_GetType(VLC_OBJECT(a),b)
 #define config_GetInt(a,b) config_GetInt(VLC_OBJECT(a),b)
@@ -261,7 +261,7 @@ struct config_chain_t
  *
  * The option names will be created by adding the psz_prefix prefix.
  */
-VLC_EXPORT( void, config_ChainParse, ( vlc_object_t *, const char *psz_prefix, const char *const *ppsz_options, config_chain_t * ) );
+VLC_API void config_ChainParse( vlc_object_t *, const char *psz_prefix, const char *const *ppsz_options, config_chain_t * );
 #define config_ChainParse( a, b, c, d ) config_ChainParse( VLC_OBJECT(a), b, c, d )
 
 /**
@@ -275,18 +275,18 @@ VLC_EXPORT( void, config_ChainParse, ( vlc_object_t *, const char *psz_prefix, c
  *
  * The options values are unescaped using config_StringUnescape.
  */
-VLC_EXPORT( char *, config_ChainCreate, ( char **ppsz_name, config_chain_t **pp_cfg, const char *psz_string ) ) LIBVLC_USED LIBVLC_MALLOC;
+VLC_API char *config_ChainCreate( char **ppsz_name, config_chain_t **pp_cfg, const char *psz_string ) LIBVLC_USED LIBVLC_MALLOC;
 
 /**
  * This function will release a linked list of config_chain_t
  * (Including the head)
  */
-VLC_EXPORT( void, config_ChainDestroy, ( config_chain_t * ) );
+VLC_API void config_ChainDestroy( config_chain_t * );
 
 /**
  * This function will duplicate a linked list of config_chain_t
  */
-VLC_EXPORT( config_chain_t *, config_ChainDuplicate, ( const config_chain_t * ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API config_chain_t * config_ChainDuplicate( const config_chain_t * ) LIBVLC_USED LIBVLC_MALLOC;
 
 /**
  * This function will unescape a string in place and will return a pointer on
@@ -297,7 +297,7 @@ VLC_EXPORT( config_chain_t *, config_ChainDuplicate, ( const config_chain_t * )
  * The following sequences will be unescaped (only one time):
  * \\ \' and \"
  */
-VLC_EXPORT( char *, config_StringUnescape, ( char *psz_string ) );
+VLC_API char * config_StringUnescape( char *psz_string );
 
 /**
  * This function will escape a string that can be unescaped by
@@ -308,7 +308,7 @@ VLC_EXPORT( char *, config_StringUnescape, ( char *psz_string ) );
  *
  * The escaped characters are ' " and \
  */
-VLC_EXPORT( char *, config_StringEscape, ( const char *psz_string ) LIBVLC_USED LIBVLC_MALLOC );
+VLC_API char * config_StringEscape( const char *psz_string ) LIBVLC_USED LIBVLC_MALLOC;
 
 # ifdef __cplusplus
 }

include/vlc_cpu.h

@@ -62,8 +62,8 @@
 #  define CPU_CAPABILITY_NEON    (0)
 # endif
 
-VLC_EXPORT( unsigned, vlc_CPU, ( void ) );
-VLC_EXPORT( unsigned, vlc_GetCPUCount, ( void ) );
+VLC_API unsigned vlc_CPU( void );
+VLC_API unsigned vlc_GetCPUCount( void );
 
 /** Are floating point operations fast?
  * If this bit is not set, you should try to use fixed-point instead.
@@ -88,7 +88,7 @@ VLC_EXPORT( unsigned, vlc_GetCPUCount, ( void ) );
 typedef void *(*vlc_memcpy_t) (void *tgt, const void *src, size_t n);
 typedef void *(*vlc_memset_t) (void *tgt, int c, size_t n);
 
-VLC_EXPORT( void, vlc_fastmem_register, (vlc_memcpy_t cpy, vlc_memset_t set) );
+VLC_API void vlc_fastmem_register(vlc_memcpy_t cpy, vlc_memset_t set);
 
 #endif /* !VLC_CPU_H */
 

include/vlc_demux.h

@@ -161,7 +161,7 @@ enum demux_query_e
     DEMUX_CAN_SEEK,            /* arg1= bool*    can fail (assume false)*/
 };
 
-VLC_EXPORT( int,       demux_vaControlHelper, ( stream_t *, int64_t i_start, int64_t i_end, int64_t i_bitrate, int i_align, int i_query, va_list args ) );
+VLC_API int demux_vaControlHelper( stream_t *, int64_t i_start, int64_t i_end, int64_t i_bitrate, int i_align, int i_query, va_list args );
 
 /*************************************************************************
  * Miscellaneous helpers for demuxers
@@ -194,18 +194,18 @@ static inline bool demux_IsForced( demux_t *p_demux, const char *psz_name )
  * The provided es_format_t will be cleaned on error or by
  * demux_PacketizerDestroy.
  */
-VLC_EXPORT( decoder_t *,demux_PacketizerNew, ( demux_t *p_demux, es_format_t *p_fmt, const char *psz_msg ) LIBVLC_USED );
+VLC_API decoder_t * demux_PacketizerNew( demux_t *p_demux, es_format_t *p_fmt, const char *psz_msg ) LIBVLC_USED;
 
 /**
  * This function will destroy a packetizer create by demux_PacketizerNew.
  */
-VLC_EXPORT( void, demux_PacketizerDestroy, ( decoder_t *p_packetizer ) );
+VLC_API void demux_PacketizerDestroy( decoder_t *p_packetizer );
 
 /**
  * This function will return the parent input of this demux.
  * It is retained. Can return NULL.
  */
-VLC_EXPORT( input_thread_t *, demux_GetParentInput, ( demux_t *p_demux ) LIBVLC_USED );
+VLC_API input_thread_t * demux_GetParentInput( demux_t *p_demux ) LIBVLC_USED;
 
 /* */
 #define DEMUX_INIT_COMMON() do {            \

include/vlc_dialog.h

@@ -37,7 +37,7 @@ typedef struct dialog_fatal_t
     const char *message;
 } dialog_fatal_t;
 
-VLC_EXPORT( void, dialog_VFatal, (vlc_object_t *, bool, const char *, const char *, va_list) );
+VLC_API void dialog_VFatal(vlc_object_t *, bool, const char *, const char *, va_list);
 
 static inline LIBVLC_FORMAT(3, 4)
 void dialog_Fatal (vlc_object_t *obj, const char *title, const char *fmt, ...)
@@ -74,7 +74,7 @@ typedef struct dialog_login_t
     char **password;
 } dialog_login_t;
 
-VLC_EXPORT( void, dialog_Login, (vlc_object_t *, char **, char **, const char *, const char *, ...) ) LIBVLC_FORMAT (5, 6);
+VLC_API void dialog_Login(vlc_object_t *, char **, char **, const char *, const char *, ...) LIBVLC_FORMAT (5, 6);
 #define dialog_Login(o, u, p, t, ...) \
         dialog_Login(VLC_OBJECT(o), u, p, t, __VA_ARGS__)
 
@@ -91,7 +91,7 @@ typedef struct dialog_question_t
     int answer;
 } dialog_question_t;
 
-VLC_EXPORT( int, dialog_Question, (vlc_object_t *, const char *, const char *, const char *, const char *, const char *) );
+VLC_API int dialog_Question(vlc_object_t *, const char *, const char *, const char *, const char *, const char *);
 #define dialog_Question(o, t, m, y, n, c) \
         dialog_Question(VLC_OBJECT(o), t, m, y, n, c)
 
@@ -107,15 +107,15 @@ typedef struct dialog_progress_bar_t
     void *p_sys;
 } dialog_progress_bar_t;
 
-VLC_EXPORT( dialog_progress_bar_t *, dialog_ProgressCreate, (vlc_object_t *, const char *, const char *, const char *) LIBVLC_USED );
+VLC_API dialog_progress_bar_t * dialog_ProgressCreate(vlc_object_t *, const char *, const char *, const char *) LIBVLC_USED;
 #define dialog_ProgressCreate(o, t, m, c) \
         dialog_ProgressCreate(VLC_OBJECT(o), t, m, c)
-VLC_EXPORT( void, dialog_ProgressDestroy, (dialog_progress_bar_t *) );
-VLC_EXPORT( void, dialog_ProgressSet, (dialog_progress_bar_t *, const char *, float) );
-VLC_EXPORT( bool, dialog_ProgressCancelled, (dialog_progress_bar_t *) );
+VLC_API void dialog_ProgressDestroy(dialog_progress_bar_t *);
+VLC_API void dialog_ProgressSet(dialog_progress_bar_t *, const char *, float);
+VLC_API bool dialog_ProgressCancelled(dialog_progress_bar_t *);
 
-VLC_EXPORT( int, dialog_Register, (vlc_object_t *) );
-VLC_EXPORT( int, dialog_Unregister, (vlc_object_t *) );
+VLC_API int dialog_Register(vlc_object_t *);
+VLC_API int dialog_Unregister(vlc_object_t *);
 #define dialog_Register(o) dialog_Register(VLC_OBJECT(o))
 #define dialog_Unregister(o) dialog_Unregister(VLC_OBJECT(o))
 

include/vlc_epg.h

@@ -54,43 +54,43 @@ typedef struct
  *
  * You must call vlc_epg_Clean to release the associated resource.
  */
-VLC_EXPORT(void, vlc_epg_Init, (vlc_epg_t *p_epg, const char *psz_name));
+VLC_API void vlc_epg_Init(vlc_epg_t *p_epg, const char *psz_name);
 
 /**
  * It releases all resources associated to a vlc_epg_t
  */
-VLC_EXPORT(void, vlc_epg_Clean, (vlc_epg_t *p_epg));
+VLC_API void vlc_epg_Clean(vlc_epg_t *p_epg);
 
 /**
  * It creates and appends a new vlc_epg_event_t to a vlc_epg_t.
  *
  * \see vlc_epg_t for the definitions of the parameters.
  */
-VLC_EXPORT(void, vlc_epg_AddEvent, (vlc_epg_t *p_epg, int64_t i_start, int i_duration, const char *psz_name, const char *psz_short_description, const char *psz_description));
+VLC_API void vlc_epg_AddEvent(vlc_epg_t *p_epg, int64_t i_start, int i_duration, const char *psz_name, const char *psz_short_description, const char *psz_description);
 
 /**
  * It creates a new vlc_epg_t*
  *
  * You must call vlc_epg_Delete to release the associated resource.
  */
-VLC_EXPORT(vlc_epg_t *, vlc_epg_New, (const char *psz_name) LIBVLC_USED);
+VLC_API vlc_epg_t * vlc_epg_New(const char *psz_name) LIBVLC_USED;
 
 /**
  * It releases a vlc_epg_t*.
  */
-VLC_EXPORT(void, vlc_epg_Delete, (vlc_epg_t *p_epg));
+VLC_API void vlc_epg_Delete(vlc_epg_t *p_epg);
 
 /**
  * It set the current event of a vlc_epg_t given a start time
  */
-VLC_EXPORT(void, vlc_epg_SetCurrent, (vlc_epg_t *p_epg, int64_t i_start));
+VLC_API void vlc_epg_SetCurrent(vlc_epg_t *p_epg, int64_t i_start);
 
 /**
  * It merges all the event of \p p_src and \p p_dst into \p p_dst.
  *
  * \p p_src is not modified.
  */
-VLC_EXPORT(void, vlc_epg_Merge, (vlc_epg_t *p_dst, const vlc_epg_t *p_src));
+VLC_API void vlc_epg_Merge(vlc_epg_t *p_dst, const vlc_epg_t *p_src);
 
 #endif
 

include/vlc_es.h

@@ -170,28 +170,28 @@ static inline void video_format_Clean( video_format_t *p_src )
  * It will fill up a video_format_tvideo_format_t using the given arguments.
  * Becarefull that the video_format_t must already be initialized.
  */
-VLC_EXPORT( void, video_format_Setup, ( video_format_t *, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den ) );
+VLC_API void video_format_Setup( video_format_t *, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den );
 
 /**
  * It will copy the crop properties from a video_format_t to another.
  */
-VLC_EXPORT( void, video_format_CopyCrop, ( video_format_t *, const video_format_t * ) );
+VLC_API void video_format_CopyCrop( video_format_t *, const video_format_t * );
 
 /**
  * It will compute the crop/ar properties when scaling.
  */
-VLC_EXPORT( void, video_format_ScaleCropAr, ( video_format_t *, const video_format_t * ) );
+VLC_API void video_format_ScaleCropAr( video_format_t *, const video_format_t * );
 
 /**
  * This function will check if the first video format is similar
  * to the second one.
  */
-VLC_EXPORT( bool, video_format_IsSimilar, ( const video_format_t *, const video_format_t * ) );
+VLC_API bool video_format_IsSimilar( const video_format_t *, const video_format_t * );
 
 /**
  * It prints details about the given video_format_t
  */
-VLC_EXPORT( void, video_format_Print, ( vlc_object_t *, const char *, const video_format_t * ) );
+VLC_API void video_format_Print( vlc_object_t *, const char *, const video_format_t * );
 
 /**
  * subtitles format description
@@ -292,29 +292,29 @@ enum es_format_category_e
 /**
  * This function will fill all RGB shift from RGB masks.
  */
-VLC_EXPORT( void, video_format_FixRgb, ( video_format_t * ) );
+VLC_API void video_format_FixRgb( video_format_t * );
 
 /**
  * This function will initialize a es_format_t structure.
  */
-VLC_EXPORT( void, es_format_Init, ( es_format_t *, int i_cat, vlc_fourcc_t i_codec ) );
+VLC_API void es_format_Init( es_format_t *, int i_cat, vlc_fourcc_t i_codec );
 
 /**
  * This function will initialize a es_format_t structure from a video_format_t.
  */
-VLC_EXPORT( void, es_format_InitFromVideo, ( es_format_t *, const video_format_t * ) );
+VLC_API void es_format_InitFromVideo( es_format_t *, const video_format_t * );
 
 /**
  * This functions will copy a es_format_t.
  */
-VLC_EXPORT( int, es_format_Copy, ( es_format_t *p_dst, const es_format_t *p_src ) );
+VLC_API int es_format_Copy( es_format_t *p_dst, const es_format_t *p_src );
 
 /**
  * This function will clean up a es_format_t and relasing all associated
  * resources.
  * You can call it multiple times on the same structure.
  */
-VLC_EXPORT( void, es_format_Clean, ( es_format_t *fmt ) );
+VLC_API void es_format_Clean( es_format_t *fmt );
 
 /**
  * This function will check if the first ES format is similar
@@ -322,6 +322,6 @@ VLC_EXPORT( void, es_format_Clean, ( es_format_t *fmt ) );
  *
  * All descriptive fields are ignored.
  */
-VLC_EXPORT( bool, es_format_IsSimilar, ( const es_format_t *, const es_format_t * ) );
+VLC_API bool es_format_IsSimilar( const es_format_t *, const es_format_t * );
 
 #endif

include/vlc_events.h

@@ -221,44 +221,43 @@ typedef void ( *vlc_event_callback_t )( const vlc_event_t *, void * );
 #define vlc_event_manager_init_with_vlc_object(a,b) \
             vlc_event_manager_init( a, b, b )
 
-VLC_EXPORT(int, vlc_event_manager_init, ( vlc_event_manager_t * p_em,
-                                          void * p_obj, vlc_object_t * ));
+VLC_API int vlc_event_manager_init( vlc_event_manager_t * p_em,
+                                    void * p_obj, vlc_object_t * );
 #define vlc_event_manager_init(a,b,c) \
             vlc_event_manager_init(a, b, VLC_OBJECT(c))
 
 /*
  * Destroy
  */
-VLC_EXPORT(void, vlc_event_manager_fini, ( vlc_event_manager_t * p_em ));
+VLC_API void vlc_event_manager_fini( vlc_event_manager_t * p_em );
 
 /*
  * Tells a specific event manager that it will handle event_type object
  */
-VLC_EXPORT(int, vlc_event_manager_register_event_type,
-                ( vlc_event_manager_t * p_em, vlc_event_type_t event_type ));
+VLC_API int vlc_event_manager_register_event_type( vlc_event_manager_t * p_em,
+                                                   vlc_event_type_t );
 
 /*
  * Send an event to the listener attached to this p_em.
  */
-VLC_EXPORT(void, vlc_event_send, ( vlc_event_manager_t * p_em,
-                                   vlc_event_t * p_event ));
+VLC_API void vlc_event_send( vlc_event_manager_t * p_em, vlc_event_t * );
 
 /*
  * Add a callback for an event.
  */
-VLC_EXPORT(int, vlc_event_attach, ( vlc_event_manager_t * p_event_manager,
-                                    vlc_event_type_t event_type,
-                                    vlc_event_callback_t pf_callback,
-                                    void *p_user_data,
-                                    const char * psz_debug_name ));
+VLC_API int vlc_event_attach( vlc_event_manager_t * p_event_manager,
+                              vlc_event_type_t event_type,
+                              vlc_event_callback_t pf_callback,
+                              void *p_user_data,
+                              const char * psz_debug_name );
 #define vlc_event_attach(a, b, c, d) vlc_event_attach(a, b, c, d, #c)
 
 /*
  * Remove a callback for an event.
  */
-VLC_EXPORT(int, vlc_event_detach, ( vlc_event_manager_t *p_event_manager,
-                                    vlc_event_type_t event_type,
-                                    vlc_event_callback_t pf_callback,
-                                    void *p_user_data ));
+VLC_API int vlc_event_detach( vlc_event_manager_t *p_event_manager,
+                              vlc_event_type_t event_type,
+                              vlc_event_callback_t pf_callback,
+                              void *p_user_data );
 
 #endif /* VLC_EVENTS_H */

include/vlc_extensions.h

@@ -304,7 +304,7 @@ struct extension_widget_t
     extension_dialog_t *p_dialog; ///< Parent dialog
 };
 
-VLC_EXPORT(int, dialog_ExtensionUpdate, (vlc_object_t*, extension_dialog_t *));
+VLC_API int dialog_ExtensionUpdate(vlc_object_t*, extension_dialog_t *);
 #define dialog_ExtensionUpdate(o, d) dialog_ExtensionUpdate(VLC_OBJECT(o), d)
 
 #endif /* VLC_EXTENSIONS_H */

include/vlc_filter.h

@@ -248,25 +248,25 @@ static inline int filter_GetInputAttachments( filter_t *p_filter,
  * Only the chroma properties of the dest format is used (chroma
  * type, rgb masks and shifts)
  */
-VLC_EXPORT( filter_t *, filter_NewBlend, ( vlc_object_t *, const video_format_t *p_dst_chroma ) LIBVLC_USED );
+VLC_API filter_t * filter_NewBlend( vlc_object_t *, const video_format_t *p_dst_chroma ) LIBVLC_USED;
 
 /**
  * It configures blend filter parameters that are allowed to changed
  * after the creation.
  */
-VLC_EXPORT( int, filter_ConfigureBlend, ( filter_t *, int i_dst_width, int i_dst_height, const video_format_t *p_src ) );
+VLC_API int filter_ConfigureBlend( filter_t *, int i_dst_width, int i_dst_height, const video_format_t *p_src );
 
 /**
  * It blends a picture into another one.
  *
  * The input picture is not modified and not released.
  */
-VLC_EXPORT( int, filter_Blend, ( filter_t *, picture_t *p_dst, int i_dst_x, int i_dst_y, const picture_t *p_src, int i_alpha ) );
+VLC_API int filter_Blend( filter_t *, picture_t *p_dst, int i_dst_x, int i_dst_y, const picture_t *p_src, int i_alpha );
 
 /**
  * It destroys a blend filter created by filter_NewBlend.
  */
-VLC_EXPORT( void, filter_DeleteBlend, ( filter_t * ) );
+VLC_API void filter_DeleteBlend( filter_t * );
 
 /**
  * Create a picture_t *(*)( filter_t *, picture_t * ) compatible wrapper
@@ -307,7 +307,7 @@ typedef struct filter_chain_t filter_chain_t;
  * \param p_buffer_allocation_data pointer to private allocation data
  * \return pointer to a filter chain
  */
-VLC_EXPORT( filter_chain_t *, filter_chain_New, ( vlc_object_t *, const char *, bool, int (*)( filter_t *, void * ), void (*)( filter_t * ), void *  ) LIBVLC_USED );
+VLC_API filter_chain_t * filter_chain_New( vlc_object_t *, const char *, bool, int (*)( filter_t *, void * ), void (*)( filter_t * ), void *  ) LIBVLC_USED;
 #define filter_chain_New( a, b, c, d, e, f ) filter_chain_New( VLC_OBJECT( a ), b, c, d, e, f )
 
 /**
@@ -316,7 +316,7 @@ VLC_EXPORT( filter_chain_t *, filter_chain_New, ( vlc_object_t *, const char *,
  *
  * \param p_chain pointer to filter chain
  */
-VLC_EXPORT( void, filter_chain_Delete, ( filter_chain_t * ) );
+VLC_API void filter_chain_Delete( filter_chain_t * );
 
 /**
  * Reset filter chain will delete all filters in the chain and
@@ -326,7 +326,7 @@ VLC_EXPORT( void, filter_chain_Delete, ( filter_chain_t * ) );
  * \param p_fmt_in new fmt_in params
  * \param p_fmt_out new fmt_out params
  */
-VLC_EXPORT( void, filter_chain_Reset, ( filter_chain_t *, const es_format_t *, const es_format_t * ) );
+VLC_API void filter_chain_Reset( filter_chain_t *, const es_format_t *, const es_format_t * );
 
 /**
  * Append filter to the end of the chain.
@@ -338,7 +338,7 @@ VLC_EXPORT( void, filter_chain_Reset, ( filter_chain_t *, const es_format_t *, c
  * \param p_fmt_out output es_format_t
  * \return pointer to filter chain
  */
-VLC_EXPORT( filter_t *, filter_chain_AppendFilter, ( filter_chain_t *, const char *, config_chain_t *, const es_format_t *, const es_format_t * ) );
+VLC_API filter_t * filter_chain_AppendFilter( filter_chain_t *, const char *, config_chain_t *, const es_format_t *, const es_format_t * );
 
 /**
  * Append new filter to filter chain from string.
@@ -347,7 +347,7 @@ VLC_EXPORT( filter_t *, filter_chain_AppendFilter, ( filter_chain_t *, const cha
  * \param psz_string string of filters
  * \return 0 for success
  */
-VLC_EXPORT( int, filter_chain_AppendFromString, ( filter_chain_t *, const char * ) );
+VLC_API int filter_chain_AppendFromString( filter_chain_t *, const char * );
 
 /**
  * Delete filter from filter chain. This function also releases the filter
@@ -358,7 +358,7 @@ VLC_EXPORT( int, filter_chain_AppendFromString, ( filter_chain_t *, const char *
  * \param p_filter pointer to filter object
  * \return VLC_SUCCESS on succes, else VLC_EGENERIC
  */
-VLC_EXPORT( int, filter_chain_DeleteFilter, ( filter_chain_t *, filter_t * ) );
+VLC_API int filter_chain_DeleteFilter( filter_chain_t *, filter_t * );
 
 /**
  * Get the number of filters in the filter chain.
@@ -366,7 +366,7 @@ VLC_EXPORT( int, filter_chain_DeleteFilter, ( filter_chain_t *, filter_t * ) );
  * \param p_chain pointer to filter chain
  * \return number of filters in this filter chain
  */
-VLC_EXPORT( int, filter_chain_GetLength, ( filter_chain_t * ) );
+VLC_API int filter_chain_GetLength( filter_chain_t * );
 
 /**
  * Get last p_fmt_out in the chain.
@@ -374,7 +374,7 @@ VLC_EXPORT( int, filter_chain_GetLength, ( filter_chain_t * ) );
  * \param p_chain pointer to filter chain
  * \return last p_fmt (es_format_t) of this filter chain
  */
-VLC_EXPORT( const es_format_t *, filter_chain_GetFmtOut, ( filter_chain_t * ) );
+VLC_API const es_format_t * filter_chain_GetFmtOut( filter_chain_t * );
 
 /**
  * Apply the filter chain to a video picture.
@@ -383,12 +383,12 @@ VLC_EXPORT( const es_format_t *, filter_chain_GetFmtOut, ( filter_chain_t * ) );
  * \param p_picture picture to apply filters on
  * \return modified picture after applying all video filters
  */
-VLC_EXPORT( picture_t *, filter_chain_VideoFilter, ( filter_chain_t *, picture_t * ) );
+VLC_API picture_t * filter_chain_VideoFilter( filter_chain_t *, picture_t * );
 
 /**
  * Flush a video filter chain.
  */
-VLC_EXPORT( void, filter_chain_VideoFlush, ( filter_chain_t * ) );
+VLC_API void filter_chain_VideoFlush( filter_chain_t * );
 
 /**
  * Apply the filter chain to a audio block.
@@ -397,7 +397,7 @@ VLC_EXPORT( void, filter_chain_VideoFlush, ( filter_chain_t * ) );
  * \param p_block audio frame to apply filters on
  * \return modified audio frame after applying all audio filters
  */
-VLC_EXPORT( block_t *, filter_chain_AudioFilter, ( filter_chain_t *, block_t * ) );
+VLC_API block_t * filter_chain_AudioFilter( filter_chain_t *, block_t * );
 
 /**
  * Apply filter chain to subpictures.
@@ -405,7 +405,7 @@ VLC_EXPORT( block_t *, filter_chain_AudioFilter, ( filter_chain_t *, block_t * )
  * \param p_chain pointer to filter chain
  * \param display_date of subpictures
  */
-VLC_EXPORT( void, filter_chain_SubSource, ( filter_chain_t *, mtime_t ) );
+VLC_API void filter_chain_SubSource( filter_chain_t *, mtime_t );
 
 /**
  * Apply filter chain to subpictures.
@@ -414,7 +414,7 @@ VLC_EXPORT( void, filter_chain_SubSource, ( filter_chain_t *, mtime_t ) );
  * \param p_subpicture subpicture to apply filters on
  * \return modified subpicture after applying all subpicture filters
  */
-VLC_EXPORT( subpicture_t *, filter_chain_SubFilter, ( filter_chain_t *, subpicture_t * ) );
+VLC_API subpicture_t * filter_chain_SubFilter( filter_chain_t *, subpicture_t * );
 
 /**
  * Apply the filter chain to a mouse state.
@@ -424,14 +424,14 @@ VLC_EXPORT( subpicture_t *, filter_chain_SubFilter, ( filter_chain_t *, subpictu
  *
  * The vlc_mouse_t* pointers may be the same.
  */
-VLC_EXPORT( int, filter_chain_MouseFilter, ( filter_chain_t *, vlc_mouse_t *, const vlc_mouse_t * ) );
+VLC_API int filter_chain_MouseFilter( filter_chain_t *, vlc_mouse_t *, const vlc_mouse_t * );
 
 /**
  * Inform the filter chain of mouse state.
  *
  * It makes sense only for a sub source chain.
  */
-VLC_EXPORT( int, filter_chain_MouseEvent, ( filter_chain_t *, const vlc_mouse_t *, const video_format_t * ) );
+VLC_API int filter_chain_MouseEvent( filter_chain_t *, const vlc_mouse_t *, const video_format_t * );
 
 #endif /* _VLC_FILTER_H */
 

include/vlc_fourcc.h

@@ -354,7 +354,7 @@
  *
  * You may use UNKNOWN_ES for the ES category if you don't have the information.
  */
-VLC_EXPORT( vlc_fourcc_t, vlc_fourcc_GetCodec, ( int i_cat, vlc_fourcc_t i_fourcc ) );
+VLC_API vlc_fourcc_t vlc_fourcc_GetCodec( int i_cat, vlc_fourcc_t i_fourcc );
 
 /**
  * It returns the codec associated to a fourcc store in a zero terminated
@@ -365,7 +365,7 @@ VLC_EXPORT( vlc_fourcc_t, vlc_fourcc_GetCodec, ( int i_cat, vlc_fourcc_t i_fourc
  *
  * Provided for convenience.
  */
-VLC_EXPORT( vlc_fourcc_t, vlc_fourcc_GetCodecFromString, ( int i_cat, const char * ) );
+VLC_API vlc_fourcc_t vlc_fourcc_GetCodecFromString( int i_cat, const char * );
 
 /**
  * It convert the gives fourcc to an audio codec when possible.
@@ -374,14 +374,14 @@ VLC_EXPORT( vlc_fourcc_t, vlc_fourcc_GetCodecFromString, ( int i_cat, const char
  * is detected, 0 is returned.
  * The other fourcc goes through vlc_fourcc_GetCodec and i_bits is not checked.
  */
-VLC_EXPORT( vlc_fourcc_t, vlc_fourcc_GetCodecAudio, ( vlc_fourcc_t i_fourcc, int i_bits ) );
+VLC_API vlc_fourcc_t vlc_fourcc_GetCodecAudio( vlc_fourcc_t i_fourcc, int i_bits );
 
 /**
  * It returns the description of the given fourcc or NULL if not found.
  *
  * You may use UNKNOWN_ES for the ES category if you don't have the information.
  */
-VLC_EXPORT( const char *, vlc_fourcc_GetDescription, ( int i_cat, vlc_fourcc_t i_fourcc ) );
+VLC_API const char * vlc_fourcc_GetDescription( int i_cat, vlc_fourcc_t i_fourcc );
 
 /**
  * It returns a list (terminated with the value 0) of YUV fourccs in
@@ -389,7 +389,7 @@ VLC_EXPORT( const char *, vlc_fourcc_GetDescription, ( int i_cat, vlc_fourcc_t i
  *
  * It will always return a non NULL pointer that must not be freed.
  */
-VLC_EXPORT( const vlc_fourcc_t *, vlc_fourcc_GetYUVFallback, ( vlc_fourcc_t ) );
+VLC_API const vlc_fourcc_t * vlc_fourcc_GetYUVFallback( vlc_fourcc_t );
 
 /**
  * It returns a list (terminated with the value 0) of RGB fourccs in
@@ -397,18 +397,18 @@ VLC_EXPORT( const vlc_fourcc_t *, vlc_fourcc_GetYUVFallback, ( vlc_fourcc_t ) );
  *
  * It will always return a non NULL pointer that must not be freed.
  */
-VLC_EXPORT( const vlc_fourcc_t *, vlc_fourcc_GetRGBFallback, ( vlc_fourcc_t ) );
+VLC_API const vlc_fourcc_t * vlc_fourcc_GetRGBFallback( vlc_fourcc_t );
 
 /**
  * It returns true if the given fourcc is YUV and false otherwise.
  */
-VLC_EXPORT( bool, vlc_fourcc_IsYUV, ( vlc_fourcc_t ) );
+VLC_API bool vlc_fourcc_IsYUV( vlc_fourcc_t );
 
 /**
  * It returns true if the two fourccs are equivalent if their U&V planes are
  * swapped.
  */
-VLC_EXPORT( bool, vlc_fourcc_AreUVPlanesSwapped, (vlc_fourcc_t , vlc_fourcc_t ) );
+VLC_API bool vlc_fourcc_AreUVPlanesSwapped(vlc_fourcc_t , vlc_fourcc_t );
 
 /**
  * Chroma related information.
@@ -432,7 +432,7 @@ typedef struct {
  * It returns a vlc_chroma_description_t describing the request fourcc or NULL
  * if not found.
  */
-VLC_EXPORT( const vlc_chroma_description_t *, vlc_fourcc_GetChromaDescription, ( vlc_fourcc_t fourcc ) );
+VLC_API const vlc_chroma_description_t * vlc_fourcc_GetChromaDescription( vlc_fourcc_t fourcc );
 
 #endif /* _VLC_FOURCC_H */
 

include/vlc_fs.h

@@ -31,18 +31,18 @@
 #include <sys/types.h>
 #include <dirent.h>
 
-VLC_EXPORT( int, vlc_open, ( const char *filename, int flags, ... ) LIBVLC_USED );
-VLC_EXPORT( FILE *, vlc_fopen, ( const char *filename, const char *mode ) LIBVLC_USED );
-VLC_EXPORT( int, vlc_openat, ( int fd, const char *filename, int flags, ... ) LIBVLC_USED );
+VLC_API int vlc_open( const char *filename, int flags, ... ) LIBVLC_USED;
+VLC_API FILE * vlc_fopen( const char *filename, const char *mode ) LIBVLC_USED;
+VLC_API int vlc_openat( int fd, const char *filename, int flags, ... ) LIBVLC_USED;
 
-VLC_EXPORT( DIR *, vlc_opendir, ( const char *dirname ) LIBVLC_USED );
-VLC_EXPORT( char *, vlc_readdir, ( DIR *dir ) LIBVLC_USED );
-VLC_EXPORT( int, vlc_loaddir, ( DIR *dir, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
-VLC_EXPORT( int, vlc_scandir, ( const char *dirname, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
-VLC_EXPORT( int, vlc_mkdir, ( const char *filename, mode_t mode ) );
+VLC_API DIR * vlc_opendir( const char *dirname ) LIBVLC_USED;
+VLC_API char * vlc_readdir( DIR *dir ) LIBVLC_USED;
+VLC_API int vlc_loaddir( DIR *dir, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) );
+VLC_API int vlc_scandir( const char *dirname, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) );
+VLC_API int vlc_mkdir( const char *filename, mode_t mode );
 
-VLC_EXPORT( int, vlc_unlink, ( const char *filename ) );
-VLC_EXPORT( int, vlc_rename, ( const char *oldpath, const char *newpath ) );
+VLC_API int vlc_unlink( const char *filename );
+VLC_API int vlc_rename( const char *oldpath, const char *newpath );
 
 #if defined( WIN32 )
 # ifndef UNDER_CE
@@ -67,11 +67,11 @@ static inline void vlc_rewinddir( DIR *dir )
 # define rewinddir vlc_rewinddir
 #endif
 
-VLC_EXPORT( int, vlc_stat, ( const char *filename, struct stat *buf ) );
-VLC_EXPORT( int, vlc_lstat, ( const char *filename, struct stat *buf ) );
+VLC_API int vlc_stat( const char *filename, struct stat *buf );
+VLC_API int vlc_lstat( const char *filename, struct stat *buf );
 
-VLC_EXPORT( int, vlc_mkstemp, ( char * ) );
+VLC_API int vlc_mkstemp( char * );
 
-VLC_EXPORT( int, vlc_dup, ( int ) );
-VLC_EXPORT( int, vlc_pipe, ( int[2] ) );
+VLC_API int vlc_dup( int );
+VLC_API int vlc_pipe( int[2] );
 #endif

include/vlc_http.h

@@ -49,19 +49,19 @@ typedef struct http_auth_t
 } http_auth_t;
 
 
-VLC_EXPORT( void, http_auth_Init, ( http_auth_t * ) );
-VLC_EXPORT( void, http_auth_Reset, ( http_auth_t * ) );
-VLC_EXPORT( void, http_auth_ParseWwwAuthenticateHeader,
+VLC_API void http_auth_Init( http_auth_t * );
+VLC_API void http_auth_Reset( http_auth_t * );
+VLC_API void http_auth_ParseWwwAuthenticateHeader
             ( vlc_object_t *, http_auth_t * ,
-              const char * ) );
-VLC_EXPORT( int, http_auth_ParseAuthenticationInfoHeader,
+              const char * );
+VLC_API int http_auth_ParseAuthenticationInfoHeader
             ( vlc_object_t *, http_auth_t *,
               const char *, const char *,
               const char *, const char *,
-              const char * ) );
-VLC_EXPORT( char *, http_auth_FormatAuthorizationHeader,
+              const char * );
+VLC_API char *http_auth_FormatAuthorizationHeader
             ( vlc_object_t *, http_auth_t *,
               const char *, const char *,
-              const char *, const char * ) LIBVLC_USED );
+              const char *, const char * ) LIBVLC_USED;
 
 #endif /* VLC_HTTP_H */

include/vlc_httpd.h

@@ -99,49 +99,49 @@ struct httpd_message_t
 };
 
 /* create a new host */
-VLC_EXPORT( httpd_host_t *, httpd_HostNew, ( vlc_object_t *, const char *psz_host, int i_port ) LIBVLC_USED );
-VLC_EXPORT( httpd_host_t *, httpd_TLSHostNew, ( vlc_object_t *, const char *, int, const char *, const char *, const char *, const char * ) LIBVLC_USED );
+VLC_API httpd_host_t * httpd_HostNew( vlc_object_t *, const char *psz_host, int i_port ) LIBVLC_USED;
+VLC_API httpd_host_t * httpd_TLSHostNew( vlc_object_t *, const char *, int, const char *, const char *, const char *, const char * ) LIBVLC_USED;
 
 /* delete a host */
-VLC_EXPORT( void,           httpd_HostDelete, ( httpd_host_t * ) );
+VLC_API void httpd_HostDelete( httpd_host_t * );
 
 /* register a new url */
-VLC_EXPORT( httpd_url_t *,  httpd_UrlNew, ( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED );
-VLC_EXPORT( httpd_url_t *,  httpd_UrlNewUnique, ( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED );
+VLC_API httpd_url_t * httpd_UrlNew( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED;
+VLC_API httpd_url_t * httpd_UrlNewUnique( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED;
 /* register callback on a url */
-VLC_EXPORT( int,            httpd_UrlCatch, ( httpd_url_t *, int i_msg, httpd_callback_t, httpd_callback_sys_t * ) );
+VLC_API int httpd_UrlCatch( httpd_url_t *, int i_msg, httpd_callback_t, httpd_callback_sys_t * );
 /* delete a url */
-VLC_EXPORT( void,           httpd_UrlDelete, ( httpd_url_t * ) );
+VLC_API void httpd_UrlDelete( httpd_url_t * );
 
 /* Default client mode is FILE, use these to change it */
-VLC_EXPORT( void,           httpd_ClientModeStream, ( httpd_client_t *cl ) );
-VLC_EXPORT( void,           httpd_ClientModeBidir, ( httpd_client_t *cl ) );
-VLC_EXPORT( char*,          httpd_ClientIP, ( const httpd_client_t *cl, char *psz_ip ) );
-VLC_EXPORT( char*,          httpd_ServerIP, ( const httpd_client_t *cl, char *psz_ip ) );
+VLC_API void httpd_ClientModeStream( httpd_client_t *cl );
+VLC_API void httpd_ClientModeBidir( httpd_client_t *cl );
+VLC_API char* httpd_ClientIP( const httpd_client_t *cl, char *psz_ip );
+VLC_API char* httpd_ServerIP( const httpd_client_t *cl, char *psz_ip );
 
 /* High level */
 
-VLC_EXPORT( httpd_file_t *, httpd_FileNew, ( httpd_host_t *, const char *psz_url, const char *psz_mime, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl, httpd_file_callback_t pf_fill, httpd_file_sys_t * ) LIBVLC_USED );
-VLC_EXPORT( httpd_file_sys_t *, httpd_FileDelete, ( httpd_file_t * ) );
+VLC_API httpd_file_t * httpd_FileNew( httpd_host_t *, const char *psz_url, const char *psz_mime, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl, httpd_file_callback_t pf_fill, httpd_file_sys_t * ) LIBVLC_USED;
+VLC_API httpd_file_sys_t * httpd_FileDelete( httpd_file_t * );
 
 
-VLC_EXPORT( httpd_handler_t *, httpd_HandlerNew, ( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl, httpd_handler_callback_t pf_fill, httpd_handler_sys_t * ) LIBVLC_USED );
-VLC_EXPORT( httpd_handler_sys_t *, httpd_HandlerDelete, ( httpd_handler_t * ) );
+VLC_API httpd_handler_t * httpd_HandlerNew( httpd_host_t *, const char *psz_url, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl, httpd_handler_callback_t pf_fill, httpd_handler_sys_t * ) LIBVLC_USED;
+VLC_API httpd_handler_sys_t * httpd_HandlerDelete( httpd_handler_t * );
 
 
-VLC_EXPORT( httpd_redirect_t *, httpd_RedirectNew, ( httpd_host_t *, const char *psz_url_dst, const char *psz_url_src ) LIBVLC_USED );
-VLC_EXPORT( void,               httpd_RedirectDelete, ( httpd_redirect_t * ) );
+VLC_API httpd_redirect_t * httpd_RedirectNew( httpd_host_t *, const char *psz_url_dst, const char *psz_url_src ) LIBVLC_USED;
+VLC_API void httpd_RedirectDelete( httpd_redirect_t * );
 
 
-VLC_EXPORT( httpd_stream_t *, httpd_StreamNew,    ( httpd_host_t *, const char *psz_url, const char *psz_mime, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED );
-VLC_EXPORT( void,             httpd_StreamDelete, ( httpd_stream_t * ) );
-VLC_EXPORT( int,              httpd_StreamHeader, ( httpd_stream_t *, uint8_t *p_data, int i_data ) );
-VLC_EXPORT( int,              httpd_StreamSend,   ( httpd_stream_t *, uint8_t *p_data, int i_data ) );
+VLC_API httpd_stream_t * httpd_StreamNew( httpd_host_t *, const char *psz_url, const char *psz_mime, const char *psz_user, const char *psz_password, const vlc_acl_t *p_acl ) LIBVLC_USED;
+VLC_API void httpd_StreamDelete( httpd_stream_t * );
+VLC_API int httpd_StreamHeader( httpd_stream_t *, uint8_t *p_data, int i_data );
+VLC_API int httpd_StreamSend( httpd_stream_t *, uint8_t *p_data, int i_data );
 
 
 /* Msg functions facilities */
-VLC_EXPORT( void,         httpd_MsgAdd, ( httpd_message_t *, const char *psz_name, const char *psz_value, ... ) LIBVLC_FORMAT( 3, 4 ) );
+VLC_API void httpd_MsgAdd( httpd_message_t *, const char *psz_name, const char *psz_value, ... ) LIBVLC_FORMAT( 3, 4 );
 /* return "" if not found. The string is not allocated */
-VLC_EXPORT( const char *, httpd_MsgGet, ( const httpd_message_t *, const char *psz_name ) );
+VLC_API const char * httpd_MsgGet( const httpd_message_t *, const char *psz_name );
 
 #endif /* _VLC_HTTPD_H */

include/vlc_image.h

@@ -59,9 +59,9 @@ struct image_handler_t
     filter_t  *p_filter;
 };
 
-VLC_EXPORT( image_handler_t *, image_HandlerCreate, ( vlc_object_t * ) LIBVLC_USED );
+VLC_API image_handler_t * image_HandlerCreate( vlc_object_t * ) LIBVLC_USED;
 #define image_HandlerCreate( a ) image_HandlerCreate( VLC_OBJECT(a) )
-VLC_EXPORT( void, image_HandlerDelete, ( image_handler_t * ) );
+VLC_API void image_HandlerDelete( image_handler_t * );
 
 #define image_Read( a, b, c, d ) a->pf_read( a, b, c, d )
 #define image_ReadUrl( a, b, c, d ) a->pf_read_url( a, b, c, d )
@@ -70,9 +70,9 @@ VLC_EXPORT( void, image_HandlerDelete, ( image_handler_t * ) );
 #define image_Convert( a, b, c, d ) a->pf_convert( a, b, c, d )
 #define image_Filter( a, b, c, d ) a->pf_filter( a, b, c, d )
 
-VLC_EXPORT( vlc_fourcc_t, image_Type2Fourcc, ( const char *psz_name ) );
-VLC_EXPORT( vlc_fourcc_t, image_Ext2Fourcc, ( const char *psz_name ) );
-VLC_EXPORT( vlc_fourcc_t, image_Mime2Fourcc, ( const char *psz_mime ) );
+VLC_API vlc_fourcc_t image_Type2Fourcc( const char *psz_name );
+VLC_API vlc_fourcc_t image_Ext2Fourcc( const char *psz_name );
+VLC_API vlc_fourcc_t image_Mime2Fourcc( const char *psz_mime );
 
 # ifdef __cplusplus
 }

include/vlc_input.h

@@ -526,22 +526,22 @@ enum input_query_e
  * Prototypes
  *****************************************************************************/
 
-VLC_EXPORT( input_thread_t *, input_Create, ( vlc_object_t *p_parent, input_item_t *, const char *psz_log, input_resource_t * ) LIBVLC_USED );
+VLC_API input_thread_t * input_Create( vlc_object_t *p_parent, input_item_t *, const char *psz_log, input_resource_t * ) LIBVLC_USED;
 #define input_Create(a,b,c,d) input_Create(VLC_OBJECT(a),b,c,d)
 
-VLC_EXPORT( input_thread_t *, input_CreateAndStart, ( vlc_object_t *p_parent, input_item_t *, const char *psz_log ) LIBVLC_USED );
+VLC_API input_thread_t * input_CreateAndStart( vlc_object_t *p_parent, input_item_t *, const char *psz_log ) LIBVLC_USED;
 #define input_CreateAndStart(a,b,c) input_CreateAndStart(VLC_OBJECT(a),b,c)
 
-VLC_EXPORT( int,  input_Start, ( input_thread_t * ) );
+VLC_API int input_Start( input_thread_t * );
 
-VLC_EXPORT( void, input_Stop, ( input_thread_t *, bool b_abort ) );
+VLC_API void input_Stop( input_thread_t *, bool b_abort );
 
-VLC_EXPORT( int, input_Read, ( vlc_object_t *, input_item_t * ) );
+VLC_API int input_Read( vlc_object_t *, input_item_t * );
 #define input_Read(a,b) input_Read(VLC_OBJECT(a),b)
 
-VLC_EXPORT( int, input_vaControl,( input_thread_t *, int i_query, va_list  ) );
+VLC_API int input_vaControl( input_thread_t *, int i_query, va_list  );
 
-VLC_EXPORT( int, input_Control,  ( input_thread_t *, int i_query, ...  ) );
+VLC_API int input_Control( input_thread_t *, int i_query, ...  );
 
 /**
  * Get the input item for an input thread
@@ -549,7 +549,7 @@ VLC_EXPORT( int, input_Control,  ( input_thread_t *, int i_query, ...  ) );
  * You have to keep a reference to the input or to the input_item_t until
  * you do not need it anymore.
  */
-VLC_EXPORT( input_item_t*, input_GetItem, ( input_thread_t * ) LIBVLC_USED );
+VLC_API input_item_t* input_GetItem( input_thread_t * ) LIBVLC_USED;
 
 /**
  * It will return the current state of the input.
@@ -635,9 +635,9 @@ static inline int input_ModifyPcrSystem( input_thread_t *p_input, bool b_absolut
 }
 
 /* */
-VLC_EXPORT( decoder_t *, input_DecoderCreate, ( vlc_object_t *, es_format_t *, input_resource_t * ) LIBVLC_USED );
-VLC_EXPORT( void, input_DecoderDelete, ( decoder_t * ) );
-VLC_EXPORT( void, input_DecoderDecode,( decoder_t *, block_t *, bool b_do_pace ) );
+VLC_API decoder_t * input_DecoderCreate( vlc_object_t *, es_format_t *, input_resource_t * ) LIBVLC_USED;
+VLC_API void input_DecoderDelete( decoder_t * );
+VLC_API void input_DecoderDecode( decoder_t *, block_t *, bool b_do_pace );
 
 /**
  * This function allows to split a MRL into access, demux and path part.
@@ -646,12 +646,12 @@ VLC_EXPORT( void, input_DecoderDecode,( decoder_t *, block_t *, bool b_do_pace )
  * the provided buffer.
  *  The buffer provided by psz_dup will be modified.
  */
-VLC_EXPORT( void, input_SplitMRL, ( const char **ppsz_access, const char **ppsz_demux, char **ppsz_path, char *psz_dup ) );
+VLC_API void input_SplitMRL( const char **ppsz_access, const char **ppsz_demux, char **ppsz_path, char *psz_dup );
 
 /**
  * This function creates a sane filename path.
  */
-VLC_EXPORT( char *, input_CreateFilename, ( vlc_object_t *, const char *psz_path, const char *psz_prefix, const char *psz_extension ) LIBVLC_USED );
+VLC_API char * input_CreateFilename( vlc_object_t *, const char *psz_path, const char *psz_prefix, const char *psz_extension ) LIBVLC_USED;
 
 /**
  * It creates an empty input resource handler.
@@ -659,21 +659,21 @@ VLC_EXPORT( char *, input_CreateFilename, ( vlc_object_t *, const char *psz_path
  * The given object MUST stay alive as long as the input_resource_t is
  * not deleted.
  */
-VLC_EXPORT( input_resource_t *, input_resource_New, ( vlc_object_t * ) LIBVLC_USED );
+VLC_API input_resource_t * input_resource_New( vlc_object_t * ) LIBVLC_USED;
 
 /**
  * It releases an input resource.
  */
-VLC_EXPORT(void, input_resource_Release, ( input_resource_t * ) );
+VLC_API void input_resource_Release( input_resource_t * );
 
 /**
  * Forcefully destroys the video output (e.g. when the playlist is stopped).
  */
-VLC_EXPORT(void, input_resource_TerminateVout, ( input_resource_t * ) );
+VLC_API void input_resource_TerminateVout( input_resource_t * );
 
 /**
  * This function releases all resources (object).
  */
-VLC_EXPORT( void, input_resource_Terminate, ( input_resource_t * ) );
+VLC_API void input_resource_Terminate( input_resource_t * );
 
 #endif

include/vlc_input_item.h

@@ -115,8 +115,8 @@ struct input_item_node_t
     input_item_node_t      *p_parent;
 };
 
-VLC_EXPORT( void, input_item_CopyOptions, ( input_item_t *p_parent, input_item_t *p_child ) );
-VLC_EXPORT( void, input_item_SetName, ( input_item_t *p_item, const char *psz_name ) );
+VLC_API void input_item_CopyOptions( input_item_t *p_parent, input_item_t *p_child );
+VLC_API void input_item_SetName( input_item_t *p_item, const char *psz_name );
 
 /**
  * Add one subitem to this item
@@ -128,29 +128,29 @@ VLC_EXPORT( void, input_item_SetName, ( input_item_t *p_item, const char *psz_na
  *
  * Sends a vlc_InputItemSubItemTreeAdded and a vlc_InputItemSubItemAdded event
  */
-VLC_EXPORT( void, input_item_PostSubItem, ( input_item_t *p_parent, input_item_t *p_child ) );
+VLC_API void input_item_PostSubItem( input_item_t *p_parent, input_item_t *p_child );
 
 /**
  * Start adding multiple subitems.
  *
  * Create a root node to hold a tree of subitems for given item
  */
-VLC_EXPORT( input_item_node_t *, input_item_node_Create, ( input_item_t *p_input ) LIBVLC_USED );
+VLC_API input_item_node_t * input_item_node_Create( input_item_t *p_input ) LIBVLC_USED;
 
 /**
  * Add a new child node to this parent node that will point to this subitem.
  */
-VLC_EXPORT( input_item_node_t *, input_item_node_AppendItem, ( input_item_node_t *p_node, input_item_t *p_item ) );
+VLC_API input_item_node_t * input_item_node_AppendItem( input_item_node_t *p_node, input_item_t *p_item );
 
 /**
  * Add an already created node to children of this parent node.
  */
-VLC_EXPORT( void, input_item_node_AppendNode, ( input_item_node_t *p_parent, input_item_node_t *p_child ) );
+VLC_API void input_item_node_AppendNode( input_item_node_t *p_parent, input_item_node_t *p_child );
 
 /**
  * Delete a node created with input_item_node_Create() and all its children.
  */
-VLC_EXPORT( void, input_item_node_Delete, ( input_item_node_t *p_node ) );
+VLC_API void input_item_node_Delete( input_item_node_t *p_node );
 
 /**
  * End adding multiple subitems.
@@ -163,7 +163,7 @@ VLC_EXPORT( void, input_item_node_Delete, ( input_item_node_t *p_node ) );
  *
  * In the end deletes the node and all its children nodes.
  */
-VLC_EXPORT( void, input_item_node_PostAndDelete, ( input_item_node_t *p_node ) );
+VLC_API void input_item_node_PostAndDelete( input_item_node_t *p_node );
 
 
 /**
@@ -183,21 +183,21 @@ enum input_item_option_e
 /**
  * This function allows to add an option to an existing input_item_t.
  */
-VLC_EXPORT( int,  input_item_AddOption, (input_item_t *, const char *, unsigned i_flags ) );
+VLC_API int input_item_AddOption(input_item_t *, const char *, unsigned i_flags );
 
 /* */
-VLC_EXPORT( bool, input_item_HasErrorWhenReading, ( input_item_t * ) );
-VLC_EXPORT( void, input_item_SetMeta, ( input_item_t *, vlc_meta_type_t meta_type, const char *psz_val ));
-VLC_EXPORT( bool, input_item_MetaMatch, ( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz ) );
-VLC_EXPORT( char *, input_item_GetMeta, ( input_item_t *p_i, vlc_meta_type_t meta_type ) LIBVLC_USED );
-VLC_EXPORT( char *, input_item_GetName, ( input_item_t * p_i ) LIBVLC_USED );
-VLC_EXPORT( char *, input_item_GetTitleFbName, ( input_item_t * p_i ) LIBVLC_USED );
-VLC_EXPORT( char *, input_item_GetURI, ( input_item_t * p_i ) LIBVLC_USED );
-VLC_EXPORT( void,   input_item_SetURI, ( input_item_t * p_i, const char *psz_uri ) );
-VLC_EXPORT(mtime_t, input_item_GetDuration, ( input_item_t * p_i ) );
-VLC_EXPORT( void,   input_item_SetDuration, ( input_item_t * p_i, mtime_t i_duration ));
-VLC_EXPORT( bool,   input_item_IsPreparsed, ( input_item_t *p_i ));
-VLC_EXPORT( bool,   input_item_IsArtFetched, ( input_item_t *p_i ));
+VLC_API bool input_item_HasErrorWhenReading( input_item_t * );
+VLC_API void input_item_SetMeta( input_item_t *, vlc_meta_type_t meta_type, const char *psz_val );
+VLC_API bool input_item_MetaMatch( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz );
+VLC_API char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type ) LIBVLC_USED;
+VLC_API char * input_item_GetName( input_item_t * p_i ) LIBVLC_USED;
+VLC_API char * input_item_GetTitleFbName( input_item_t * p_i ) LIBVLC_USED;
+VLC_API char * input_item_GetURI( input_item_t * p_i ) LIBVLC_USED;
+VLC_API void input_item_SetURI( input_item_t * p_i, const char *psz_uri );
+VLC_API mtime_t input_item_GetDuration( input_item_t * p_i );
+VLC_API void input_item_SetDuration( input_item_t * p_i, mtime_t i_duration );
+VLC_API bool input_item_IsPreparsed( input_item_t *p_i );
+VLC_API bool input_item_IsArtFetched( input_item_t *p_i );
 
 #define INPUT_META( name ) \
 static inline \
@@ -234,11 +234,11 @@ INPUT_META(TrackID)
 #define input_item_SetArtURL   input_item_SetArtworkURL
 #define input_item_GetArtURL   input_item_GetArtworkURL
 
-VLC_EXPORT( char *, input_item_GetInfo, ( input_item_t *p_i, const char *psz_cat,const char *psz_name ) LIBVLC_USED );
-VLC_EXPORT( int, input_item_AddInfo, ( input_item_t *p_i, const char *psz_cat, const char *psz_name, const char *psz_format, ... ) LIBVLC_FORMAT( 4, 5 ) );
-VLC_EXPORT( int, input_item_DelInfo, ( input_item_t *p_i, const char *psz_cat, const char *psz_name ) );
-VLC_EXPORT( void, input_item_ReplaceInfos, ( input_item_t *, info_category_t * ) );
-VLC_EXPORT( void, input_item_MergeInfos, ( input_item_t *, info_category_t * ) );
+VLC_API char * input_item_GetInfo( input_item_t *p_i, const char *psz_cat,const char *psz_name ) LIBVLC_USED;
+VLC_API int input_item_AddInfo( input_item_t *p_i, const char *psz_cat, const char *psz_name, const char *psz_format, ... ) LIBVLC_FORMAT( 4, 5 );
+VLC_API int input_item_DelInfo( input_item_t *p_i, const char *psz_cat, const char *psz_name );
+VLC_API void input_item_ReplaceInfos( input_item_t *, info_category_t * );
+VLC_API void input_item_MergeInfos( input_item_t *, info_category_t * );
 
 /**
  * This function creates a new input_item_t with the provided information.
@@ -246,14 +246,14 @@ VLC_EXPORT( void, input_item_MergeInfos, ( input_item_t *, info_category_t * ) )
  * XXX You may also use input_item_New or input_item_NewExt as they need
  * less arguments.
  */
-VLC_EXPORT( input_item_t *, input_item_NewWithType, ( vlc_object_t *, const char *psz_uri, const char *psz_name, int i_options, const char *const *ppsz_options, unsigned i_option_flags, mtime_t i_duration, int i_type ) LIBVLC_USED );
+VLC_API input_item_t * input_item_NewWithType( vlc_object_t *, const char *psz_uri, const char *psz_name, int i_options, const char *const *ppsz_options, unsigned i_option_flags, mtime_t i_duration, int i_type ) LIBVLC_USED;
 
 /**
  * This function creates a new input_item_t with the provided information.
  *
  * Provided for convenience.
  */
-VLC_EXPORT( input_item_t *, input_item_NewExt, (vlc_object_t *, const char *psz_uri, const char *psz_name, int i_options, const char *const *ppsz_options, unsigned i_option_flags, mtime_t i_duration ) LIBVLC_USED );
+VLC_API input_item_t * input_item_NewExt(vlc_object_t *, const char *psz_uri, const char *psz_name, int i_options, const char *const *ppsz_options, unsigned i_option_flags, mtime_t i_duration ) LIBVLC_USED;
 #define input_item_NewExt(a,b,c,d,e,f,g) input_item_NewExt( VLC_OBJECT(a),b,c,d,e,f,g)
 
 /**
@@ -266,7 +266,7 @@ VLC_EXPORT( input_item_t *, input_item_NewExt, (vlc_object_t *, const char *psz_
 /**
  * This function creates a new input_item_t as a copy of another.
  */
-VLC_EXPORT( input_item_t *, input_item_Copy, (vlc_object_t *, input_item_t * ) LIBVLC_USED );
+VLC_API input_item_t * input_item_Copy(vlc_object_t *, input_item_t * ) LIBVLC_USED;
 
 
 /******************

include/vlc_interface.h

@@ -99,13 +99,13 @@ struct intf_dialog_args_t
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( int, intf_Create, ( vlc_object_t *, const char * ) );
+VLC_API int intf_Create( vlc_object_t *, const char * );
 #define intf_Create(a,b) intf_Create(VLC_OBJECT(a),b)
 
-VLC_EXPORT( int, intf_Eject, ( vlc_object_t *, const char * ) );
+VLC_API int intf_Eject( vlc_object_t *, const char * );
 #define intf_Eject(a,b) intf_Eject(VLC_OBJECT(a),b)
 
-VLC_EXPORT( void, libvlc_Quit, ( libvlc_int_t * ) );
+VLC_API void libvlc_Quit( libvlc_int_t * );
 
 /*@}*/
 

include/vlc_iso_lang.h

@@ -39,9 +39,9 @@ struct iso639_lang_t
 #if defined( __cplusplus )
 extern "C" {
 #endif
-VLC_EXPORT( const iso639_lang_t *, GetLang_1, ( const char * ) );
-VLC_EXPORT( const iso639_lang_t *, GetLang_2T, ( const char * ) );
-VLC_EXPORT( const iso639_lang_t *, GetLang_2B, ( const char * ) );
+VLC_API const iso639_lang_t * GetLang_1( const char * );
+VLC_API const iso639_lang_t * GetLang_2T( const char * );
+VLC_API const iso639_lang_t * GetLang_2B( const char * );
 #if defined( __cplusplus )
 }
 #endif

include/vlc_keys.h

@@ -86,8 +86,8 @@
 #define KEY_MOUSEWHEELLEFT   0x00F20000
 #define KEY_MOUSEWHEELRIGHT  0x00F30000
 
-VLC_EXPORT( char *, vlc_keycode2str, (uint_fast32_t i_key) ) LIBVLC_USED;
-VLC_EXPORT( uint_fast32_t, vlc_str2keycode, (const char *str) ) LIBVLC_USED;
+VLC_API char *vlc_keycode2str(uint_fast32_t i_key) LIBVLC_USED;
+VLC_API uint_fast32_t vlc_str2keycode(const char *str) LIBVLC_USED;
 
 typedef enum vlc_action {
     ACTIONID_NONE = 0,
@@ -202,7 +202,7 @@ typedef enum vlc_action {
 
 } vlc_action_t;
 
-VLC_EXPORT( vlc_action_t, vlc_GetActionId, (const char *psz_key) ) LIBVLC_USED;
+VLC_API vlc_action_t vlc_GetActionId(const char *psz_key) LIBVLC_USED;
 
 struct hotkey
 {

include/vlc_md5.h

@@ -43,9 +43,9 @@ struct md5_s
     uint32_t p_data[16];  /* Buffer to cache non-aligned writes */
 };
 
-VLC_EXPORT(void, InitMD5, ( struct md5_s * ) );
-VLC_EXPORT(void, AddMD5, ( struct md5_s *, const void *, size_t ) );
-VLC_EXPORT(void, EndMD5, ( struct md5_s * ) );
+VLC_API void InitMD5( struct md5_s * );
+VLC_API void AddMD5( struct md5_s *, const void *, size_t );
+VLC_API void EndMD5( struct md5_s * );
 
 /**
  * Returns a char representation of the md5 hash, as shown by UNIX md5 or

include/vlc_media_library.h

@@ -397,7 +397,7 @@ struct ml_person_t
  * @return The media library object. NULL if the media library
  * object could not be loaded
  */
-VLC_EXPORT( media_library_t*, ml_Get, ( vlc_object_t* p_this ) );
+VLC_API media_library_t* ml_Get( vlc_object_t* p_this );
 #define ml_Get( a ) ml_Get( VLC_OBJECT(a) )
 
 /**
@@ -406,13 +406,13 @@ VLC_EXPORT( media_library_t*, ml_Get, ( vlc_object_t* p_this ) );
  * @param psz_name Name for the module
  * @return The ML object.
  */
-VLC_EXPORT( media_library_t*, ml_Create, ( vlc_object_t *p_this, char* psz_name ) );
+VLC_API media_library_t* ml_Create( vlc_object_t *p_this, char* psz_name );
 
 /**
  * @brief Destructor for the Media library singleton
  * @param p_this Parent the ML object is attached to
  */
-VLC_EXPORT( void, ml_Destroy, ( vlc_object_t* p_this ) );
+VLC_API void ml_Destroy( vlc_object_t* p_this );
 
 /**
  * @brief Control the Media Library
@@ -681,8 +681,8 @@ static inline void ml_DestroyResultArray( vlc_array_t *p_result_array )
  * @param select Type of object
  * @param reload Whether to reload from database
  */
-VLC_EXPORT( ml_media_t*, media_New, ( media_library_t* p_ml, int id,
-        ml_select_e select, bool reload ) );
+VLC_API ml_media_t *media_New( media_library_t* p_ml, int id,
+        ml_select_e select, bool reload );
 
 
 /* Forward declaration */
@@ -819,8 +819,8 @@ static inline int ml_FtreeHasOp( ml_ftree_t* tree )
  * @return Pointer to new tree
  * @note Use the helpers!
  */
-VLC_EXPORT( ml_ftree_t*, ml_OpConnectChilds, ( ml_op_e op, ml_ftree_t* left,
-        ml_ftree_t* right ) );
+VLC_API ml_ftree_t *ml_OpConnectChilds( ml_op_e op, ml_ftree_t* left,
+        ml_ftree_t* right );
 
 /**
  * @brief Attaches a special node to a tree
@@ -831,10 +831,10 @@ VLC_EXPORT( ml_ftree_t*, ml_OpConnectChilds, ( ml_op_e op, ml_ftree_t* left,
  * @return Pointer to new tree
  * @note Use the helpers
  */
-VLC_EXPORT( ml_ftree_t*, ml_FtreeSpec, ( ml_ftree_t* tree,
+VLC_API ml_ftree_t *ml_FtreeSpec( ml_ftree_t* tree,
                                           ml_select_e crit,
                                           int limit,
-                                          char* sort ) );
+                                          char* sort );
 
 /**
  * @brief This function gives quick sequential adding capability
@@ -1030,10 +1030,10 @@ static inline int ml_Update( media_library_t *p_media_library,
  * @param id The id of the row to update
  * @param ... The update data. [SelectType [RoleType] Value]
  */
-VLC_EXPORT( int, ml_UpdateSimple, ( media_library_t *p_media_library,
+VLC_API int ml_UpdateSimple( media_library_t *p_media_library,
                                      ml_select_e selected_type,
                                      const char* psz_lvalue,
-                                     int id, ... ) );
+                                     int id, ... );
 #define ml_UpdateSimple( ml, sel, lval, id, ... ) \
         ml_UpdateSimple( ml, sel, lval, id, __VA_ARGS__, ML_END )
 
@@ -1151,9 +1151,9 @@ static inline int ml_CopyPersons( ml_person_t** a, ml_person_t* b )
  * @param i_type The person type
  * @note This function is thread safe
  */
-VLC_EXPORT( ml_person_t*, ml_GetPersonsFromMedia, ( media_library_t* p_ml,
+VLC_API ml_person_t *ml_GetPersonsFromMedia( media_library_t* p_ml,
                                                     ml_media_t* p_media,
-                                                    const char *psz_role ) );
+                                                    const char *psz_role );
 
 
 #define ml_GetAlbumArtistsFromMedia( a, b ) ml_GetPersonsFromMedia( a, b, ML_PERSON_ALBUM_ARTIST );
@@ -1167,8 +1167,8 @@ VLC_EXPORT( ml_person_t*, ml_GetPersonsFromMedia, ( media_library_t* p_ml,
  * @param i_type Type of person to delete
  * @note This function is threadsafe
  */
-VLC_EXPORT( void, ml_DeletePersonTypeFromMedia, ( ml_media_t* p_media,
-                                                 const char *psz_role ) );
+VLC_API void ml_DeletePersonTypeFromMedia( ml_media_t* p_media,
+                                                 const char *psz_role );
 
 
 /**
@@ -1177,8 +1177,8 @@ VLC_EXPORT( void, ml_DeletePersonTypeFromMedia, ( ml_media_t* p_media,
  * @param p_tree Find tree to create SELECT
  */
 
-VLC_EXPORT( void, ml_PlaySmartPlaylistBasedOn, ( media_library_t* p_ml,
-                                                ml_ftree_t* p_tree ) );
+VLC_API void ml_PlaySmartPlaylistBasedOn( media_library_t* p_ml,
+                                                ml_ftree_t* p_tree );
 
 
 /**

include/vlc_messages.h

@@ -87,8 +87,8 @@ typedef struct msg_subscription_t msg_subscription_t;
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( void, msg_Generic, ( vlc_object_t *, int, const char *, const char *, ... ) LIBVLC_FORMAT( 4, 5 ) );
-VLC_EXPORT( void, msg_GenericVa, ( vlc_object_t *, int, const char *, const char *, va_list args ) );
+VLC_API void msg_Generic( vlc_object_t *, int, const char *, const char *, ... ) LIBVLC_FORMAT( 4, 5 );
+VLC_API void msg_GenericVa( vlc_object_t *, int, const char *, const char *, va_list args );
 #define msg_GenericVa(a, b, c, d, e) msg_GenericVa(VLC_OBJECT(a), b, c, d, e)
 
 #define msg_Info( p_this, ... ) \
@@ -112,14 +112,14 @@ typedef struct msg_cb_data_t msg_cb_data_t;
  */
 typedef void (*msg_callback_t) (msg_cb_data_t *, msg_item_t *, unsigned);
 
-VLC_EXPORT( msg_subscription_t*, msg_Subscribe, ( libvlc_int_t *, msg_callback_t, msg_cb_data_t * ) LIBVLC_USED );
-VLC_EXPORT( void, msg_Unsubscribe, ( msg_subscription_t * ) );
-VLC_EXPORT( void, msg_SubscriptionSetVerbosity, ( msg_subscription_t *, const int) );
+VLC_API msg_subscription_t* msg_Subscribe( libvlc_int_t *, msg_callback_t, msg_cb_data_t * ) LIBVLC_USED;
+VLC_API void msg_Unsubscribe( msg_subscription_t * );
+VLC_API void msg_SubscriptionSetVerbosity( msg_subscription_t *, const int);
 
 /* Enable or disable a certain object debug messages */
-VLC_EXPORT( void, msg_EnableObjectPrinting, ( vlc_object_t *, const char * psz_object ) );
+VLC_API void msg_EnableObjectPrinting( vlc_object_t *, const char * psz_object );
 #define msg_EnableObjectPrinting(a,b) msg_EnableObjectPrinting(VLC_OBJECT(a),b)
-VLC_EXPORT( void, msg_DisableObjectPrinting, ( vlc_object_t *, const char * psz_object ) );
+VLC_API void msg_DisableObjectPrinting( vlc_object_t *, const char * psz_object );
 #define msg_DisableObjectPrinting(a,b) msg_DisableObjectPrinting(VLC_OBJECT(a),b)
 
 
@@ -204,19 +204,19 @@ enum
 /*********
  * Timing
  ********/
-VLC_EXPORT( void, stats_TimerStart, (vlc_object_t*, const char *, unsigned int ) );
-VLC_EXPORT( void, stats_TimerStop, (vlc_object_t*, unsigned int) );
-VLC_EXPORT( void, stats_TimerDump, (vlc_object_t*, unsigned int) );
-VLC_EXPORT( void, stats_TimersDumpAll, (vlc_object_t*) );
+VLC_API void stats_TimerStart(vlc_object_t*, const char *, unsigned int );
+VLC_API void stats_TimerStop(vlc_object_t*, unsigned int);
+VLC_API void stats_TimerDump(vlc_object_t*, unsigned int);
+VLC_API void stats_TimersDumpAll(vlc_object_t*);
 #define stats_TimerStart(a,b,c) stats_TimerStart( VLC_OBJECT(a), b,c )
 #define stats_TimerStop(a,b) stats_TimerStop( VLC_OBJECT(a), b )
 #define stats_TimerDump(a,b) stats_TimerDump( VLC_OBJECT(a), b )
 #define stats_TimersDumpAll(a) stats_TimersDumpAll( VLC_OBJECT(a) )
 
-VLC_EXPORT( void, stats_TimersCleanAll, (vlc_object_t * ) );
+VLC_API void stats_TimersCleanAll(vlc_object_t * );
 #define stats_TimersCleanAll(a) stats_TimersCleanAll( VLC_OBJECT(a) )
 
-VLC_EXPORT( void, stats_TimerClean, (vlc_object_t *, unsigned int ) );
+VLC_API void stats_TimerClean(vlc_object_t *, unsigned int );
 #define stats_TimerClean(a,b) stats_TimerClean( VLC_OBJECT(a), b )
 
 /**

include/vlc_meta.h

@@ -63,30 +63,30 @@ typedef enum vlc_meta_type_t
  */
 struct vlc_meta_t;
 
-VLC_EXPORT(vlc_meta_t *, vlc_meta_New, ( void ) LIBVLC_USED );
-VLC_EXPORT(void,         vlc_meta_Delete, ( vlc_meta_t *m ));
-VLC_EXPORT(void,         vlc_meta_Set, ( vlc_meta_t *p_meta, vlc_meta_type_t meta_type, const char *psz_val ));
-VLC_EXPORT(const char *, vlc_meta_Get, ( const vlc_meta_t *p_meta, vlc_meta_type_t meta_type ));
+VLC_API vlc_meta_t * vlc_meta_New( void ) LIBVLC_USED;
+VLC_API void vlc_meta_Delete( vlc_meta_t *m );
+VLC_API void vlc_meta_Set( vlc_meta_t *p_meta, vlc_meta_type_t meta_type, const char *psz_val );
+VLC_API const char * vlc_meta_Get( const vlc_meta_t *p_meta, vlc_meta_type_t meta_type );
 
-VLC_EXPORT(void,         vlc_meta_AddExtra, ( vlc_meta_t *m, const char *psz_name, const char *psz_value ));
-VLC_EXPORT(const char *, vlc_meta_GetExtra, ( const vlc_meta_t *m, const char *psz_name ));
-VLC_EXPORT(unsigned,     vlc_meta_GetExtraCount, ( const vlc_meta_t *m ));
+VLC_API void vlc_meta_AddExtra( vlc_meta_t *m, const char *psz_name, const char *psz_value );
+VLC_API const char * vlc_meta_GetExtra( const vlc_meta_t *m, const char *psz_name );
+VLC_API unsigned vlc_meta_GetExtraCount( const vlc_meta_t *m );
 
 /**
  * Allocate a copy of all extra meta names and a table with it.
  * Be sure to free both the returned pointers and its name.
  */
-VLC_EXPORT(char **,      vlc_meta_CopyExtraNames, ( const vlc_meta_t *m ) LIBVLC_USED );
+VLC_API char ** vlc_meta_CopyExtraNames( const vlc_meta_t *m ) LIBVLC_USED;
 
-VLC_EXPORT(void,         vlc_meta_Merge, ( vlc_meta_t *dst, const vlc_meta_t *src ));
+VLC_API void vlc_meta_Merge( vlc_meta_t *dst, const vlc_meta_t *src );
 
-VLC_EXPORT(int,  vlc_meta_GetStatus, ( vlc_meta_t *m ));
-VLC_EXPORT(void, vlc_meta_SetStatus, ( vlc_meta_t *m, int status ));
+VLC_API int vlc_meta_GetStatus( vlc_meta_t *m );
+VLC_API void vlc_meta_SetStatus( vlc_meta_t *m, int status );
 
 /**
  * Returns a localizes string describing the meta
  */
-VLC_EXPORT(const char *, vlc_meta_TypeToLocalizedString, ( vlc_meta_type_t meta_type ) );
+VLC_API const char * vlc_meta_TypeToLocalizedString( vlc_meta_type_t meta_type );
 
 enum {
     ALBUM_ART_WHEN_ASKED,
@@ -102,7 +102,7 @@ typedef struct meta_export_t
     const char *psz_file;
 } meta_export_t;
 
-VLC_EXPORT( int, input_item_WriteMeta, (vlc_object_t *, input_item_t *) );
+VLC_API int input_item_WriteMeta(vlc_object_t *, input_item_t *);
 
 /* Setters for meta.
  * Warning: Make sure to use the input_item meta setters (defined in vlc_input.h)

include/vlc_modules.h

@@ -33,39 +33,39 @@ typedef void (*vlc_deactivate_t)(void *func, va_list args);
  * Exported functions.
  *****************************************************************************/
 
-VLC_EXPORT( module_t *, vlc_module_load, ( vlc_object_t *obj, const char *cap, const char *name, bool strict, vlc_activate_t probe, ... ) LIBVLC_USED );
+VLC_API module_t * vlc_module_load( vlc_object_t *obj, const char *cap, const char *name, bool strict, vlc_activate_t probe, ... ) LIBVLC_USED;
 #define vlc_module_load(o,c,n,s,...) \
         vlc_module_load(VLC_OBJECT(o),c,n,s,__VA_ARGS__)
-VLC_EXPORT( void, vlc_module_unload, ( module_t *, vlc_deactivate_t deinit, ... ) );
+VLC_API void vlc_module_unload( module_t *, vlc_deactivate_t deinit, ... );
 
-VLC_EXPORT( module_t *, module_need, ( vlc_object_t *, const char *, const char *, bool ) LIBVLC_USED );
+VLC_API module_t * module_need( vlc_object_t *, const char *, const char *, bool ) LIBVLC_USED;
 #define module_need(a,b,c,d) module_need(VLC_OBJECT(a),b,c,d)
-VLC_EXPORT( void, module_unneed, ( vlc_object_t *, module_t * ) );
+VLC_API void module_unneed( vlc_object_t *, module_t * );
 #define module_unneed(a,b) module_unneed(VLC_OBJECT(a),b)
-VLC_EXPORT( bool,  module_exists, (const char *) LIBVLC_USED );
-VLC_EXPORT( module_t *, module_find, (const char *) LIBVLC_USED );
+VLC_API bool module_exists(const char *) LIBVLC_USED;
+VLC_API module_t * module_find(const char *) LIBVLC_USED;
 
 int module_start(vlc_object_t *, module_t *);
 #define module_start(o, m) module_start(VLC_OBJECT(o),m)
 void module_stop(vlc_object_t *, module_t *);
 #define module_stop(o, m) module_stop(VLC_OBJECT(o),m)
 
-VLC_EXPORT( module_config_t *, module_config_get, ( const module_t *, unsigned * ) LIBVLC_USED );
-VLC_EXPORT( void, module_config_free, ( module_config_t * ) );
+VLC_API module_config_t * module_config_get( const module_t *, unsigned * ) LIBVLC_USED;
+VLC_API void module_config_free( module_config_t * );
 
-VLC_EXPORT( module_t *, module_hold, (module_t *module) );
-VLC_EXPORT( void, module_release, (module_t *module) );
-VLC_EXPORT( void, module_list_free, (module_t **) );
-VLC_EXPORT( module_t **, module_list_get, (size_t *n) LIBVLC_USED );
+VLC_API module_t * module_hold(module_t *module);
+VLC_API void module_release(module_t *module);
+VLC_API void module_list_free(module_t **);
+VLC_API module_t ** module_list_get(size_t *n) LIBVLC_USED;
 
-VLC_EXPORT( bool, module_provides, ( const module_t *m, const char *cap ) );
-VLC_EXPORT( const char *, module_get_object, ( const module_t *m ) LIBVLC_USED );
-VLC_EXPORT( const char *, module_get_name, ( const module_t *m, bool long_name ) LIBVLC_USED );
+VLC_API bool module_provides( const module_t *m, const char *cap );
+VLC_API const char * module_get_object( const module_t *m ) LIBVLC_USED;
+VLC_API const char * module_get_name( const module_t *m, bool long_name ) LIBVLC_USED;
 #define module_GetLongName( m ) module_get_name( m, true )
-VLC_EXPORT( const char *, module_get_help, ( const module_t *m ) LIBVLC_USED );
-VLC_EXPORT( const char *, module_get_capability, ( const module_t *m ) LIBVLC_USED );
-VLC_EXPORT( int, module_get_score, ( const module_t *m ) LIBVLC_USED );
-VLC_EXPORT( const char *, module_gettext, ( const module_t *, const char * ) LIBVLC_USED );
+VLC_API const char * module_get_help( const module_t *m ) LIBVLC_USED;
+VLC_API const char * module_get_capability( const module_t *m ) LIBVLC_USED;
+VLC_API int module_get_score( const module_t *m ) LIBVLC_USED;
+VLC_API const char * module_gettext( const module_t *, const char * ) LIBVLC_USED;
 
 LIBVLC_USED static inline module_t *module_get_main (void)
 {

include/vlc_mtime.h

@@ -54,11 +54,11 @@
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( char *,  mstrtime, ( char *psz_buffer, mtime_t date ) );
-VLC_EXPORT( mtime_t, mdate,    ( void ) );
-VLC_EXPORT( void,    mwait,    ( mtime_t date ) );
-VLC_EXPORT( void,    msleep,   ( mtime_t delay ) );
-VLC_EXPORT( char *,  secstotimestr, ( char *psz_buffer, int32_t secs ) );
+VLC_API char * mstrtime( char *psz_buffer, mtime_t date );
+VLC_API mtime_t mdate( void );
+VLC_API void mwait( mtime_t date );
+VLC_API void msleep( mtime_t delay );
+VLC_API char * secstotimestr( char *psz_buffer, int32_t secs );
 
 # define VLC_HARD_MIN_SLEEP 10000   /* 10 milliseconds = 1 tick at 100Hz */
 
@@ -128,12 +128,12 @@ struct date_t
     uint32_t i_remainder;
 };
 
-VLC_EXPORT( void,    date_Init,      ( date_t *, uint32_t, uint32_t ) );
-VLC_EXPORT( void,    date_Change,    ( date_t *, uint32_t, uint32_t ) );
-VLC_EXPORT( void,    date_Set,       ( date_t *, mtime_t ) );
-VLC_EXPORT( mtime_t, date_Get,       ( const date_t * ) );
-VLC_EXPORT( void,    date_Move,      ( date_t *, mtime_t ) );
-VLC_EXPORT( mtime_t, date_Increment, ( date_t *, uint32_t ) );
-VLC_EXPORT( mtime_t, date_Decrement, ( date_t *, uint32_t ) );
-VLC_EXPORT( uint64_t, NTPtime64,     ( void ) );
+VLC_API void date_Init( date_t *, uint32_t, uint32_t );
+VLC_API void date_Change( date_t *, uint32_t, uint32_t );
+VLC_API void date_Set( date_t *, mtime_t );
+VLC_API mtime_t date_Get( const date_t * );
+VLC_API void date_Move( date_t *, mtime_t );
+VLC_API mtime_t date_Increment( date_t *, uint32_t );
+VLC_API mtime_t date_Decrement( date_t *, uint32_t );
+VLC_API uint64_t NTPtime64( void );
 #endif /* !__VLC_MTIME_ */

include/vlc_network.h

@@ -88,7 +88,7 @@ struct msghdr
 int vlc_socket (int, int, int, bool nonblock) LIBVLC_USED;
 
 struct sockaddr;
-VLC_EXPORT( int, vlc_accept, ( int, struct sockaddr *, socklen_t *, bool ) LIBVLC_USED );
+VLC_API int vlc_accept( int, struct sockaddr *, socklen_t *, bool ) LIBVLC_USED;
 
 # ifdef __cplusplus
 extern "C" {
@@ -97,10 +97,10 @@ extern "C" {
 /* Portable networking layer communication */
 int net_Socket (vlc_object_t *obj, int family, int socktype, int proto);
 
-VLC_EXPORT( int, net_Connect, (vlc_object_t *p_this, const char *psz_host, int i_port, int socktype, int protocol) );
+VLC_API int net_Connect(vlc_object_t *p_this, const char *psz_host, int i_port, int socktype, int protocol);
 #define net_Connect(a, b, c, d, e) net_Connect(VLC_OBJECT(a), b, c, d, e)
 
-VLC_EXPORT( int *, net_Listen, (vlc_object_t *p_this, const char *psz_host, int i_port, int socktype, int protocol) );
+VLC_API int * net_Listen(vlc_object_t *p_this, const char *psz_host, int i_port, int socktype, int protocol);
 
 #define net_ListenTCP(a, b, c) net_Listen(VLC_OBJECT(a), b, c, \
                                           SOCK_STREAM, IPPROTO_TCP)
@@ -111,13 +111,13 @@ static inline int net_ConnectTCP (vlc_object_t *obj, const char *host, int port)
 }
 #define net_ConnectTCP(a, b, c) net_ConnectTCP(VLC_OBJECT(a), b, c)
 
-VLC_EXPORT( int, net_AcceptSingle, (vlc_object_t *obj, int lfd) );
+VLC_API int net_AcceptSingle(vlc_object_t *obj, int lfd);
 
-VLC_EXPORT( int, net_Accept, ( vlc_object_t *, int * ) );
+VLC_API int net_Accept( vlc_object_t *, int * );
 #define net_Accept(a, b) \
         net_Accept(VLC_OBJECT(a), b)
 
-VLC_EXPORT( int, net_ConnectDgram, ( vlc_object_t *p_this, const char *psz_host, int i_port, int hlim, int proto ) );
+VLC_API int net_ConnectDgram( vlc_object_t *p_this, const char *psz_host, int i_port, int hlim, int proto );
 #define net_ConnectDgram(a, b, c, d, e ) \
         net_ConnectDgram(VLC_OBJECT(a), b, c, d, e)
 
@@ -126,7 +126,7 @@ static inline int net_ConnectUDP (vlc_object_t *obj, const char *host, int port,
     return net_ConnectDgram (obj, host, port, hlim, IPPROTO_UDP);
 }
 
-VLC_EXPORT( int, net_OpenDgram, ( vlc_object_t *p_this, const char *psz_bind, int i_bind, const char *psz_server, int i_server, int family, int proto ) );
+VLC_API int net_OpenDgram( vlc_object_t *p_this, const char *psz_bind, int i_bind, const char *psz_server, int i_server, int family, int proto );
 #define net_OpenDgram( a, b, c, d, e, g, h ) \
         net_OpenDgram(VLC_OBJECT(a), b, c, d, e, g, h)
 
@@ -135,12 +135,12 @@ static inline int net_ListenUDP1 (vlc_object_t *obj, const char *host, int port)
     return net_OpenDgram (obj, host, port, NULL, 0, 0, IPPROTO_UDP);
 }
 
-VLC_EXPORT( void, net_ListenClose, ( int *fd ) );
+VLC_API void net_ListenClose( int *fd );
 
 int net_Subscribe (vlc_object_t *obj, int fd, const struct sockaddr *addr,
                    socklen_t addrlen);
 
-VLC_EXPORT( int, net_SetCSCov, ( int fd, int sendcov, int recvcov ) );
+VLC_API int net_SetCSCov( int fd, int sendcov, int recvcov );
 
 /* Functions to read from or write to the networking layer */
 struct virtual_socket_t
@@ -150,24 +150,24 @@ struct virtual_socket_t
     int (*pf_send) ( void *, const void *, int );
 };
 
-VLC_EXPORT( ssize_t, net_Read, ( vlc_object_t *p_this, int fd, const v_socket_t *, void *p_data, size_t i_data, bool b_retry ) );
+VLC_API ssize_t net_Read( vlc_object_t *p_this, int fd, const v_socket_t *, void *p_data, size_t i_data, bool b_retry );
 #define net_Read(a,b,c,d,e,f) net_Read(VLC_OBJECT(a),b,c,d,e,f)
-VLC_EXPORT( ssize_t, net_Write, ( vlc_object_t *p_this, int fd, const v_socket_t *, const void *p_data, size_t i_data ) );
+VLC_API ssize_t net_Write( vlc_object_t *p_this, int fd, const v_socket_t *, const void *p_data, size_t i_data );
 #define net_Write(a,b,c,d,e) net_Write(VLC_OBJECT(a),b,c,d,e)
-VLC_EXPORT( char *, net_Gets, ( vlc_object_t *p_this, int fd, const v_socket_t * ) );
+VLC_API char * net_Gets( vlc_object_t *p_this, int fd, const v_socket_t * );
 #define net_Gets(a,b,c) net_Gets(VLC_OBJECT(a),b,c)
 
 
-VLC_EXPORT( ssize_t, net_Printf, ( vlc_object_t *p_this, int fd, const v_socket_t *, const char *psz_fmt, ... ) LIBVLC_FORMAT( 4, 5 ) );
+VLC_API ssize_t net_Printf( vlc_object_t *p_this, int fd, const v_socket_t *, const char *psz_fmt, ... ) LIBVLC_FORMAT( 4, 5 );
 #define net_Printf(o,fd,vs,...) net_Printf(VLC_OBJECT(o),fd,vs, __VA_ARGS__)
-VLC_EXPORT( ssize_t, net_vaPrintf, ( vlc_object_t *p_this, int fd, const v_socket_t *, const char *psz_fmt, va_list args ) );
+VLC_API ssize_t net_vaPrintf( vlc_object_t *p_this, int fd, const v_socket_t *, const char *psz_fmt, va_list args );
 #define net_vaPrintf(a,b,c,d,e) net_vaPrintf(VLC_OBJECT(a),b,c,d,e)
 
-VLC_EXPORT (int, vlc_inet_pton, (int af, const char *src, void *dst) );
-VLC_EXPORT (const char *, vlc_inet_ntop, (int af, const void *src,
-                                          char *dst, socklen_t cnt) );
+VLC_API int vlc_inet_pton(int af, const char *src, void *dst);
+VLC_API const char *vlc_inet_ntop(int af, const void *src,
+                                  char *dst, socklen_t cnt);
 struct pollfd;
-VLC_EXPORT (int, vlc_poll, (struct pollfd *fds, unsigned nfds, int timeout));
+VLC_API int vlc_poll(struct pollfd *fds, unsigned nfds, int timeout);
 
 
 #ifdef WIN32
@@ -234,8 +234,8 @@ VLC_EXPORT (int, vlc_poll, (struct pollfd *fds, unsigned nfds, int timeout));
 # define AI_NUMERICSERV 0
 #endif
 
-VLC_EXPORT( int, vlc_getnameinfo, ( const struct sockaddr *, int, char *, int, int *, int ) );
-VLC_EXPORT( int, vlc_getaddrinfo, ( vlc_object_t *, const char *, int, const struct addrinfo *, struct addrinfo ** ) );
+VLC_API int vlc_getnameinfo( const struct sockaddr *, int, char *, int, int *, int );
+VLC_API int vlc_getaddrinfo( vlc_object_t *, const char *, int, const struct addrinfo *, struct addrinfo ** );
 
 
 static inline bool

include/vlc_objects.h

@@ -62,14 +62,14 @@ struct vlc_object_t
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( void *, vlc_object_create, ( vlc_object_t *, size_t ) ) LIBVLC_MALLOC LIBVLC_USED;
-VLC_EXPORT( void, vlc_object_attach, ( vlc_object_t *, vlc_object_t * ) );
-VLC_EXPORT( vlc_object_t *, vlc_object_find_name, ( vlc_object_t *, const char *, int ) ) LIBVLC_USED LIBVLC_DEPRECATED;
-VLC_EXPORT( void *, vlc_object_hold, ( vlc_object_t * ) );
-VLC_EXPORT( void, vlc_object_release, ( vlc_object_t * ) );
-VLC_EXPORT( vlc_list_t *, vlc_list_children, ( vlc_object_t * ) ) LIBVLC_USED;
-VLC_EXPORT( void, vlc_list_release, ( vlc_list_t * ) );
-VLC_EXPORT( char *, vlc_object_get_name, ( const vlc_object_t * ) ) LIBVLC_USED;
+VLC_API void *vlc_object_create( vlc_object_t *, size_t ) LIBVLC_MALLOC LIBVLC_USED;
+VLC_API void vlc_object_attach( vlc_object_t *, vlc_object_t * );
+VLC_API vlc_object_t *vlc_object_find_name( vlc_object_t *, const char *, int ) LIBVLC_USED LIBVLC_DEPRECATED;
+VLC_API void * vlc_object_hold( vlc_object_t * );
+VLC_API void vlc_object_release( vlc_object_t * );
+VLC_API vlc_list_t *vlc_list_children( vlc_object_t * ) LIBVLC_USED;
+VLC_API void vlc_list_release( vlc_list_t * );
+VLC_API char *vlc_object_get_name( const vlc_object_t * ) LIBVLC_USED;
 #define vlc_object_get_name(o) vlc_object_get_name(VLC_OBJECT(o))
 
 /**}@*/
@@ -92,7 +92,7 @@ VLC_EXPORT( char *, vlc_object_get_name, ( const vlc_object_t * ) ) LIBVLC_USED;
     vlc_list_children( VLC_OBJECT(a) )
 
 /* Objects and threading */
-VLC_EXPORT( void, vlc_object_kill, ( vlc_object_t * ) );
+VLC_API void vlc_object_kill( vlc_object_t * );
 #define vlc_object_kill(a) \
     vlc_object_kill( VLC_OBJECT(a) )
 

include/vlc_opengl.h

@@ -56,8 +56,8 @@ enum {
     VLC_OPENGL_ES2,
 };
 
-VLC_EXPORT( vlc_gl_t *, vlc_gl_Create, (struct vout_window_t *, unsigned, const char *) ) LIBVLC_USED;
-VLC_EXPORT( void, vlc_gl_Destroy, (vlc_gl_t *) );
+VLC_API vlc_gl_t *vlc_gl_Create(struct vout_window_t *, unsigned, const char *) LIBVLC_USED;
+VLC_API void vlc_gl_Destroy(vlc_gl_t *);
 
 static inline int vlc_gl_MakeCurrent(vlc_gl_t *gl)
 {

include/vlc_osd.h

@@ -264,7 +264,7 @@ struct osd_menu_t
  * functions. It creates the osd_menu object and holds a pointer to it
  * during its lifetime.
  */
-VLC_EXPORT( osd_menu_t *, osd_MenuCreate, ( vlc_object_t *, const char * ) LIBVLC_USED );
+VLC_API osd_menu_t * osd_MenuCreate( vlc_object_t *, const char * ) LIBVLC_USED;
 
 /**
  * Delete the osd_menu_t object
@@ -273,7 +273,7 @@ VLC_EXPORT( osd_menu_t *, osd_MenuCreate, ( vlc_object_t *, const char * ) LIBVL
  * memory for the osdmenu. After return of this function the pointer to
  * osd_menu_t* is invalid.
  */
-VLC_EXPORT( void, osd_MenuDelete, ( vlc_object_t *, osd_menu_t * ) );
+VLC_API void osd_MenuDelete( vlc_object_t *, osd_menu_t * );
 
 #define osd_MenuCreate(object,file) osd_MenuCreate( VLC_OBJECT(object), file )
 #define osd_MenuDelete(object,osd)  osd_MenuDelete( VLC_OBJECT(object), osd )
@@ -281,15 +281,15 @@ VLC_EXPORT( void, osd_MenuDelete, ( vlc_object_t *, osd_menu_t * ) );
 /**
  * Find OSD Menu button at position x,y
  */
-VLC_EXPORT( osd_button_t *, osd_ButtonFind, ( vlc_object_t *p_this,
-     int, int, int, int, int, int ) LIBVLC_USED );
+VLC_API osd_button_t *osd_ButtonFind( vlc_object_t *p_this,
+     int, int, int, int, int, int ) LIBVLC_USED;
 
 #define osd_ButtonFind(object,x,y,h,w,sh,sw)  osd_ButtonFind(object,x,y,h,w,sh,sw)
 
 /**
  * Select the button provided as the new active button
  */
-VLC_EXPORT( void, osd_ButtonSelect, ( vlc_object_t *, osd_button_t *) );
+VLC_API void osd_ButtonSelect( vlc_object_t *, osd_button_t *);
 
 #define osd_ButtonSelect(object,button) osd_ButtonSelect(object,button)
 
@@ -300,14 +300,14 @@ VLC_EXPORT( void, osd_ButtonSelect, ( vlc_object_t *, osd_button_t *) );
  * Every change to the OSD menu will now be visible in the output. An output
  * can be a video output window or a stream (\see stream output)
  */
-VLC_EXPORT( void, osd_MenuShow, ( vlc_object_t * ) );
+VLC_API void osd_MenuShow( vlc_object_t * );
 
 /**
  * Hide the OSD menu.
  *
  * Stop showing the OSD menu on the video output or mux it into the stream.
  */
-VLC_EXPORT( void, osd_MenuHide, ( vlc_object_t * ) );
+VLC_API void osd_MenuHide( vlc_object_t * );
 
 /**
  * Activate the action of this OSD menu item.
@@ -316,7 +316,7 @@ VLC_EXPORT( void, osd_MenuHide, ( vlc_object_t * ) );
  * hotkey action to the hotkey interface. The hotkey that belongs to
  * the current highlighted OSD menu item will be used.
  */
-VLC_EXPORT( void, osd_MenuActivate,   ( vlc_object_t * ) );
+VLC_API void osd_MenuActivate( vlc_object_t * );
 
 #define osd_MenuShow(object) osd_MenuShow( VLC_OBJECT(object) )
 #define osd_MenuHide(object) osd_MenuHide( VLC_OBJECT(object) )
@@ -329,7 +329,7 @@ VLC_EXPORT( void, osd_MenuActivate,   ( vlc_object_t * ) );
  * Note: The actual position on screen of the menu item is determined by
  * the OSD menu configuration file.
  */
-VLC_EXPORT( void, osd_MenuNext, ( vlc_object_t * ) );
+VLC_API void osd_MenuNext( vlc_object_t * );
 
 /**
  * Previous OSD menu item
@@ -338,7 +338,7 @@ VLC_EXPORT( void, osd_MenuNext, ( vlc_object_t * ) );
  * Note: The actual position on screen of the menu item is determined by
  * the OSD menu configuration file.
  */
-VLC_EXPORT( void, osd_MenuPrev, ( vlc_object_t * ) );
+VLC_API void osd_MenuPrev( vlc_object_t * );
 
 /**
  * OSD menu item above
@@ -347,7 +347,7 @@ VLC_EXPORT( void, osd_MenuPrev, ( vlc_object_t * ) );
  * Note: The actual position on screen of the menu item is determined by
  * the OSD menu configuration file.
  */
-VLC_EXPORT( void, osd_MenuUp,   ( vlc_object_t * ) );
+VLC_API void osd_MenuUp( vlc_object_t * );
 
 /**
  * OSD menu item below
@@ -356,7 +356,7 @@ VLC_EXPORT( void, osd_MenuUp,   ( vlc_object_t * ) );
  * Note: The actual position on screen of the menu item is determined by
  * the OSD menu configuration file.
  */
-VLC_EXPORT( void, osd_MenuDown, ( vlc_object_t * ) );
+VLC_API void osd_MenuDown( vlc_object_t * );
 
 #define osd_MenuNext(object) osd_MenuNext( VLC_OBJECT(object) )
 #define osd_MenuPrev(object) osd_MenuPrev( VLC_OBJECT(object) )
@@ -369,7 +369,7 @@ VLC_EXPORT( void, osd_MenuDown, ( vlc_object_t * ) );
  * Display the correct audio volume bitmap that corresponds to the
  * current Audio Volume setting.
  */
-VLC_EXPORT( void, osd_Volume, ( vlc_object_t * ) );
+VLC_API void osd_Volume( vlc_object_t * );
 
 #define osd_Volume(object)     osd_Volume( VLC_OBJECT(object) )
 
@@ -443,9 +443,9 @@ static inline void osd_SetMenuUpdate( osd_menu_t *p_osd, bool b_value )
  * object. The types are declared in the include file include/vlc_osd.h
  * @see vlc_osd.h
  */
-VLC_EXPORT( int, osd_ShowTextRelative, ( spu_t *, int, const char *, const text_style_t *, int, int, int, mtime_t ) );
-VLC_EXPORT( int, osd_ShowTextAbsolute, ( spu_t *, int, const char *, const text_style_t *, int, int, int, mtime_t, mtime_t ) );
-VLC_EXPORT( void, osd_Message, ( spu_t *, int, char *, ... ) LIBVLC_FORMAT( 3, 4 ) );
+VLC_API int osd_ShowTextRelative( spu_t *, int, const char *, const text_style_t *, int, int, int, mtime_t );
+VLC_API int osd_ShowTextAbsolute( spu_t *, int, const char *, const text_style_t *, int, int, int, mtime_t, mtime_t );
+VLC_API void osd_Message( spu_t *, int, char *, ... ) LIBVLC_FORMAT( 3, 4 );
 
 /** @} */
 

include/vlc_picture.h

@@ -114,7 +114,7 @@ struct picture_t
  * with picture_Hold and picture_Release. This default management will release
  * p_sys, p_q, p_data_orig fields if non NULL.
  */
-VLC_EXPORT( picture_t *, picture_New, ( vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den ) LIBVLC_USED );
+VLC_API picture_t * picture_New( vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den ) LIBVLC_USED;
 
 /**
  * This function will create a new picture using the given format.
@@ -122,7 +122,7 @@ VLC_EXPORT( picture_t *, picture_New, ( vlc_fourcc_t i_chroma, int i_width, int
  * When possible, it is preferred to use this function over picture_New
  * as more information about the format is kept.
  */
-VLC_EXPORT( picture_t *, picture_NewFromFormat, ( const video_format_t *p_fmt ) LIBVLC_USED );
+VLC_API picture_t * picture_NewFromFormat( const video_format_t *p_fmt ) LIBVLC_USED;
 
 /**
  * Resource for a picture.
@@ -148,7 +148,7 @@ typedef struct
  *
  * If the resource is NULL then a plain picture_NewFromFormat is returned.
  */
-VLC_EXPORT( picture_t *, picture_NewFromResource, ( const video_format_t *, const picture_resource_t * ) LIBVLC_USED );
+VLC_API picture_t * picture_NewFromResource( const video_format_t *, const picture_resource_t * ) LIBVLC_USED;
 
 /**
  * This function will force the destruction a picture.
@@ -157,7 +157,7 @@ VLC_EXPORT( picture_t *, picture_NewFromResource, ( const video_format_t *, cons
  * Unless used for reimplementing pf_release, you should not use this
  * function but picture_Release.
  */
-VLC_EXPORT( void, picture_Delete, ( picture_t * ) );
+VLC_API void picture_Delete( picture_t * );
 
 /**
  * This function will increase the picture reference count.
@@ -223,15 +223,15 @@ static inline void picture_CopyProperties( picture_t *p_dst, const picture_t *p_
  * This function will reset a picture information (properties and quantizers).
  * It is sometimes useful for reusing pictures (like from a pool).
  */
-VLC_EXPORT( void, picture_Reset, ( picture_t * ) );
+VLC_API void picture_Reset( picture_t * );
 
 /**
  * This function will copy the picture pixels.
  * You can safely copy between pictures that do not have the same size,
  * only the compatible(smaller) part will be copied.
  */
-VLC_EXPORT( void, picture_CopyPixels, ( picture_t *p_dst, const picture_t *p_src ) );
-VLC_EXPORT( void, plane_CopyPixels, ( plane_t *p_dst, const plane_t *p_src ) );
+VLC_API void picture_CopyPixels( picture_t *p_dst, const picture_t *p_src );
+VLC_API void plane_CopyPixels( plane_t *p_dst, const plane_t *p_src );
 
 /**
  * This function will copy both picture dynamic properties and pixels.
@@ -264,7 +264,7 @@ static inline void picture_Copy( picture_t *p_dst, const picture_t *p_src )
  *  - if strictly higher than 0, it will override the dimension.
  * If at most one of them is > 0 then the picture aspect ratio will be kept.
  */
-VLC_EXPORT( int, picture_Export, ( vlc_object_t *p_obj, block_t **pp_image, video_format_t *p_fmt, picture_t *p_picture, vlc_fourcc_t i_format, int i_override_width, int i_override_height ) );
+VLC_API int picture_Export( vlc_object_t *p_obj, block_t **pp_image, video_format_t *p_fmt, picture_t *p_picture, vlc_fourcc_t i_format, int i_override_width, int i_override_height );
 
 /**
  * This function will setup all fields of a picture_t without allocating any
@@ -277,7 +277,7 @@ VLC_EXPORT( int, picture_Export, ( vlc_object_t *p_obj, block_t **pp_image, vide
  *
  * It can be useful to get the properties of planes.
  */
-VLC_EXPORT( int, picture_Setup, ( picture_t *, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den ) );
+VLC_API int picture_Setup( picture_t *, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den );
 
 
 /**
@@ -289,7 +289,7 @@ VLC_EXPORT( int, picture_Setup, ( picture_t *, vlc_fourcc_t i_chroma, int i_widt
  *  - not have the fade flag.
  *  - contains only picture (no text rendering).
  */
-VLC_EXPORT( void, picture_BlendSubpicture, ( picture_t *, filter_t *p_blend, subpicture_t * ) );
+VLC_API void picture_BlendSubpicture( picture_t *, filter_t *p_blend, subpicture_t * );
 
 
 /*****************************************************************************

include/vlc_picture_fifo.h

@@ -41,21 +41,21 @@ typedef struct picture_fifo_t picture_fifo_t;
 /**
  * It creates an empty picture_fifo_t.
  */
-VLC_EXPORT( picture_fifo_t *, picture_fifo_New, ( void ) LIBVLC_USED );
+VLC_API picture_fifo_t * picture_fifo_New( void ) LIBVLC_USED;
 
 /**
  * It destroys a fifo created by picture_fifo_New.
  *
  * All pictures inside the fifo will be released by picture_Release.
  */
-VLC_EXPORT( void, picture_fifo_Delete, ( picture_fifo_t * ) );
+VLC_API void picture_fifo_Delete( picture_fifo_t * );
 
 /**
  * It retreives a picture_t from the fifo.
  *
  * If the fifo is empty, it return NULL without waiting.
  */
-VLC_EXPORT( picture_t *, picture_fifo_Pop, ( picture_fifo_t * ) LIBVLC_USED );
+VLC_API picture_t * picture_fifo_Pop( picture_fifo_t * ) LIBVLC_USED;
 
 /**
  * It returns the first picture_t pointer from the fifo but does not
@@ -64,12 +64,12 @@ VLC_EXPORT( picture_t *, picture_fifo_Pop, ( picture_fifo_t * ) LIBVLC_USED );
  *
  * If the fifo is empty, it return NULL without waiting.
  */
-VLC_EXPORT( picture_t *, picture_fifo_Peek, ( picture_fifo_t * ) LIBVLC_USED );
+VLC_API picture_t * picture_fifo_Peek( picture_fifo_t * ) LIBVLC_USED;
 
 /**
  * It saves a picture_t into the fifo.
  */
-VLC_EXPORT( void, picture_fifo_Push, ( picture_fifo_t *, picture_t * ) );
+VLC_API void picture_fifo_Push( picture_fifo_t *, picture_t * );
 
 /**
  * It release all picture inside the fifo that have a lower or equal date
@@ -77,12 +77,12 @@ VLC_EXPORT( void, picture_fifo_Push, ( picture_fifo_t *, picture_t * ) );
  *
  * All pictures inside the fifo will be released by picture_Release.
  */
-VLC_EXPORT( void, picture_fifo_Flush, ( picture_fifo_t *, mtime_t date, bool flush_before ) );
+VLC_API void picture_fifo_Flush( picture_fifo_t *, mtime_t date, bool flush_before );
 
 /**
  * It applies a delta on all the picture timestamp.
  */
-VLC_EXPORT( void, picture_fifo_OffsetDate, ( picture_fifo_t *, mtime_t delta ) );
+VLC_API void picture_fifo_OffsetDate( picture_fifo_t *, mtime_t delta );
 
 
 #endif /* VLC_PICTURE_FIFO_H */

include/vlc_picture_pool.h

@@ -62,21 +62,21 @@ typedef struct {
  * as soon as a picture is unused. They are allowed to modify picture_t::p and
  * access picture_t::p_sys.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_NewExtended, ( const picture_pool_configuration_t * ) LIBVLC_USED );
+VLC_API picture_pool_t * picture_pool_NewExtended( const picture_pool_configuration_t * ) LIBVLC_USED;
 
 /**
  * It creates a picture_pool_t wrapping the given arrays of picture.
  *
  * It is provided as convenience.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_New, ( int picture_count, picture_t *picture[] ) LIBVLC_USED );
+VLC_API picture_pool_t * picture_pool_New( int picture_count, picture_t *picture[] ) LIBVLC_USED;
 
 /**
  * It creates a picture_pool_t creating images using the given format.
  *
  * Provided for convenience.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_NewFromFormat, ( const video_format_t *, int picture_count ) LIBVLC_USED );
+VLC_API picture_pool_t * picture_pool_NewFromFormat( const video_format_t *, int picture_count ) LIBVLC_USED;
 
 /**
  * It destroys a pool created by picture_pool_New.
@@ -84,14 +84,14 @@ VLC_EXPORT( picture_pool_t *, picture_pool_NewFromFormat, ( const video_format_t
  * All pictures must already be released to the pool. The pool will then
  * released them.
  */
-VLC_EXPORT( void, picture_pool_Delete, ( picture_pool_t * ) );
+VLC_API void picture_pool_Delete( picture_pool_t * );
 
 /**
  * It retreives a picture_t from a pool.
  *
  * The picture must be release by using picture_Release.
  */
-VLC_EXPORT( picture_t *, picture_pool_Get, ( picture_pool_t * ) LIBVLC_USED );
+VLC_API picture_t * picture_pool_Get( picture_pool_t * ) LIBVLC_USED;
 
 /**
  * It forces the next picture_pool_Get to return a picture even if no
@@ -104,7 +104,7 @@ VLC_EXPORT( picture_t *, picture_pool_Get, ( picture_pool_t * ) LIBVLC_USED );
  * XXX it should be used with great care, the only reason you may need
  * it is to workaround a bug.
  */
-VLC_EXPORT( void, picture_pool_NonEmpty, ( picture_pool_t *, bool reset ) );
+VLC_API void picture_pool_NonEmpty( picture_pool_t *, bool reset );
 
 /**
  * It reserves picture_count pictures from the given pool and returns
@@ -114,12 +114,12 @@ VLC_EXPORT( void, picture_pool_NonEmpty, ( picture_pool_t *, bool reset ) );
  * The returned pool must be deleted before the master pool.
  * When deleted, all pictures return to the master pool.
  */
-VLC_EXPORT( picture_pool_t *, picture_pool_Reserve, (picture_pool_t *, int picture_count) LIBVLC_USED );
+VLC_API picture_pool_t * picture_pool_Reserve(picture_pool_t *, int picture_count) LIBVLC_USED;
 
 /**
  * It returns the size of the given pool.
  */
-VLC_EXPORT( int, picture_pool_GetSize, (picture_pool_t *) );
+VLC_API int picture_pool_GetSize(picture_pool_t *);
 
 
 #endif /* VLC_PICTURE_POOL_H */

include/vlc_playlist.h

@@ -250,7 +250,7 @@ enum pl_locked_state
 #define PL_UNLOCK playlist_Unlock( p_playlist )
 #define PL_ASSERT_LOCKED playlist_AssertLocked( p_playlist )
 
-VLC_EXPORT( playlist_t *, pl_Get, ( vlc_object_t * ) LIBVLC_USED );
+VLC_API playlist_t * pl_Get( vlc_object_t * ) LIBVLC_USED;
 #define pl_Get( a ) pl_Get( VLC_OBJECT(a) )
 
 /* Playlist control */
@@ -261,9 +261,9 @@ VLC_EXPORT( playlist_t *, pl_Get, ( vlc_object_t * ) LIBVLC_USED );
 #define playlist_Prev(p) playlist_Control(p,PLAYLIST_SKIP, pl_Unlocked, -1)
 #define playlist_Skip(p,i) playlist_Control(p,PLAYLIST_SKIP, pl_Unlocked,  (i) )
 
-VLC_EXPORT( void, playlist_Lock, ( playlist_t * ) );
-VLC_EXPORT( void, playlist_Unlock, ( playlist_t * ) );
-VLC_EXPORT( void, playlist_AssertLocked, ( playlist_t * ) );
+VLC_API void playlist_Lock( playlist_t * );
+VLC_API void playlist_Unlock( playlist_t * );
+VLC_API void playlist_AssertLocked( playlist_t * );
 
 /**
  * Do a playlist action.
@@ -275,30 +275,30 @@ VLC_EXPORT( void, playlist_AssertLocked, ( playlist_t * ) );
  * \param variable number of arguments
  * \return VLC_SUCCESS or an error
  */
-VLC_EXPORT( int, playlist_Control, ( playlist_t *p_playlist, int i_query, bool b_locked, ...  ) );
+VLC_API int playlist_Control( playlist_t *p_playlist, int i_query, bool b_locked, ...  );
 
 /** Get current playing input. The object is retained.
  */
-VLC_EXPORT( input_thread_t *, playlist_CurrentInput, ( playlist_t *p_playlist ) LIBVLC_USED );
+VLC_API input_thread_t * playlist_CurrentInput( playlist_t *p_playlist ) LIBVLC_USED;
 
 /** Clear the playlist
  * \param b_locked TRUE if playlist is locked when entering this function
  */
-VLC_EXPORT( void,  playlist_Clear, ( playlist_t *, bool ) );
+VLC_API void playlist_Clear( playlist_t *, bool );
 
 /** Enqueue an input item for preparsing */
-VLC_EXPORT( int, playlist_PreparseEnqueue, (playlist_t *, input_item_t * ) );
+VLC_API int playlist_PreparseEnqueue(playlist_t *, input_item_t * );
 
 /** Request the art for an input item to be fetched */
-VLC_EXPORT( int, playlist_AskForArtEnqueue, (playlist_t *, input_item_t * ) );
+VLC_API int playlist_AskForArtEnqueue(playlist_t *, input_item_t * );
 
 /* Playlist sorting */
-VLC_EXPORT( int,  playlist_TreeMove, ( playlist_t *, playlist_item_t *, playlist_item_t *, int ) );
-VLC_EXPORT( int,  playlist_TreeMoveMany, ( playlist_t *, int, playlist_item_t **, playlist_item_t *, int ) );
-VLC_EXPORT( int,  playlist_RecursiveNodeSort, ( playlist_t *, playlist_item_t *,int, int ) );
+VLC_API int playlist_TreeMove( playlist_t *, playlist_item_t *, playlist_item_t *, int );
+VLC_API int playlist_TreeMoveMany( playlist_t *, int, playlist_item_t **, playlist_item_t *, int );
+VLC_API int playlist_RecursiveNodeSort( playlist_t *, playlist_item_t *,int, int );
 
-VLC_EXPORT( playlist_item_t *,  playlist_CurrentPlayingItem, ( playlist_t * ) LIBVLC_USED );
-VLC_EXPORT( int,   playlist_Status, ( playlist_t * ) );
+VLC_API playlist_item_t * playlist_CurrentPlayingItem( playlist_t * ) LIBVLC_USED;
+VLC_API int playlist_Status( playlist_t * );
 
 /**
  * Export a node of the playlist to a certain type of playlistfile
@@ -308,23 +308,23 @@ VLC_EXPORT( int,   playlist_Status, ( playlist_t * ) );
  * \param psz_type the type of playlist file to create (m3u, pls, ..)
  * \return VLC_SUCCESS on success
  */
-VLC_EXPORT( int,  playlist_Export, ( playlist_t *p_playlist, const char *psz_name, playlist_item_t *p_export_root, const char *psz_type ) );
+VLC_API int playlist_Export( playlist_t *p_playlist, const char *psz_name, playlist_item_t *p_export_root, const char *psz_type );
 
 /**
  * Open a playlist file, add its content to the current playlist
  */
-VLC_EXPORT( int, playlist_Import, ( playlist_t *p_playlist, const char *psz_file ) );
+VLC_API int playlist_Import( playlist_t *p_playlist, const char *psz_file );
 
 /********************** Services discovery ***********************/
 
 /** Add a list of comma-separated service discovery modules */
-VLC_EXPORT( int, playlist_ServicesDiscoveryAdd, (playlist_t *, const char *));
+VLC_API int playlist_ServicesDiscoveryAdd(playlist_t *, const char *);
 /** Remove a services discovery module by name */
-VLC_EXPORT( int, playlist_ServicesDiscoveryRemove, (playlist_t *, const char *));
+VLC_API int playlist_ServicesDiscoveryRemove(playlist_t *, const char *);
 /** Check whether a given SD is loaded */
-VLC_EXPORT( bool, playlist_IsServicesDiscoveryLoaded, ( playlist_t *,const char *));
+VLC_API bool playlist_IsServicesDiscoveryLoaded( playlist_t *,const char *);
 /** Query a services discovery */
-VLC_EXPORT( int, playlist_ServicesDiscoveryControl, ( playlist_t *, const char *, int, ... ) );
+VLC_API int playlist_ServicesDiscoveryControl( playlist_t *, const char *, int, ... );
 
 
 
@@ -333,34 +333,34 @@ VLC_EXPORT( int, playlist_ServicesDiscoveryControl, ( playlist_t *, const char *
  ********************************************************/
 
 /*************************** Item deletion **************************/
-VLC_EXPORT( int,  playlist_DeleteFromInput, ( playlist_t *, input_item_t *, bool ) );
+VLC_API int playlist_DeleteFromInput( playlist_t *, input_item_t *, bool );
 
 /******************** Item addition ********************/
-VLC_EXPORT( int,  playlist_Add,    ( playlist_t *, const char *, const char *, int, int, bool, bool ) );
-VLC_EXPORT( int,  playlist_AddExt, ( playlist_t *, const char *, const char *, int, int, mtime_t, int, const char *const *, unsigned, bool, bool ) );
-VLC_EXPORT( int, playlist_AddInput, ( playlist_t *, input_item_t *, int, int, bool, bool ) );
-VLC_EXPORT( playlist_item_t *, playlist_NodeAddInput, ( playlist_t *, input_item_t *, playlist_item_t *, int, int, bool ) );
-VLC_EXPORT( int, playlist_NodeAddCopy, ( playlist_t *, playlist_item_t *, playlist_item_t *, int ) );
+VLC_API int playlist_Add( playlist_t *, const char *, const char *, int, int, bool, bool );
+VLC_API int playlist_AddExt( playlist_t *, const char *, const char *, int, int, mtime_t, int, const char *const *, unsigned, bool, bool );
+VLC_API int playlist_AddInput( playlist_t *, input_item_t *, int, int, bool, bool );
+VLC_API playlist_item_t * playlist_NodeAddInput( playlist_t *, input_item_t *, playlist_item_t *, int, int, bool );
+VLC_API int playlist_NodeAddCopy( playlist_t *, playlist_item_t *, playlist_item_t *, int );
 
 /********************************** Item search *************************/
-VLC_EXPORT( playlist_item_t *, playlist_ItemGetById, (playlist_t *, int ) LIBVLC_USED );
-VLC_EXPORT( playlist_item_t *, playlist_ItemGetByInput, (playlist_t *,input_item_t * ) LIBVLC_USED );
+VLC_API playlist_item_t * playlist_ItemGetById(playlist_t *, int ) LIBVLC_USED;
+VLC_API playlist_item_t * playlist_ItemGetByInput(playlist_t *,input_item_t * ) LIBVLC_USED;
 
-VLC_EXPORT( int, playlist_LiveSearchUpdate, (playlist_t *, playlist_item_t *, const char *, bool ) );
+VLC_API int playlist_LiveSearchUpdate(playlist_t *, playlist_item_t *, const char *, bool );
 
 /********************************************************
  * Tree management
  ********************************************************/
 /* Node management */
-VLC_EXPORT( playlist_item_t *, playlist_NodeCreate, ( playlist_t *, const char *, playlist_item_t * p_parent, int i_pos, int i_flags, input_item_t * ) );
-VLC_EXPORT( int, playlist_NodeAppend, (playlist_t *,playlist_item_t*,playlist_item_t *) );
-VLC_EXPORT( int, playlist_NodeInsert, (playlist_t *,playlist_item_t*,playlist_item_t *, int) );
-VLC_EXPORT( int, playlist_NodeRemoveItem, (playlist_t *,playlist_item_t*,playlist_item_t *) );
-VLC_EXPORT( playlist_item_t *, playlist_ChildSearchName, (playlist_item_t*, const char* ) LIBVLC_USED );
-VLC_EXPORT( int, playlist_NodeDelete, ( playlist_t *, playlist_item_t *, bool , bool ) );
-
-VLC_EXPORT( playlist_item_t *, playlist_GetNextLeaf, ( playlist_t *p_playlist, playlist_item_t *p_root, playlist_item_t *p_item, bool b_ena, bool b_unplayed ) LIBVLC_USED );
-VLC_EXPORT( playlist_item_t *, playlist_GetPrevLeaf, ( playlist_t *p_playlist, playlist_item_t *p_root, playlist_item_t *p_item, bool b_ena, bool b_unplayed ) LIBVLC_USED );
+VLC_API playlist_item_t * playlist_NodeCreate( playlist_t *, const char *, playlist_item_t * p_parent, int i_pos, int i_flags, input_item_t * );
+VLC_API int playlist_NodeAppend(playlist_t *,playlist_item_t*,playlist_item_t *);
+VLC_API int playlist_NodeInsert(playlist_t *,playlist_item_t*,playlist_item_t *, int);
+VLC_API int playlist_NodeRemoveItem(playlist_t *,playlist_item_t*,playlist_item_t *);
+VLC_API playlist_item_t * playlist_ChildSearchName(playlist_item_t*, const char* ) LIBVLC_USED;
+VLC_API int playlist_NodeDelete( playlist_t *, playlist_item_t *, bool , bool );
+
+VLC_API playlist_item_t * playlist_GetNextLeaf( playlist_t *p_playlist, playlist_item_t *p_root, playlist_item_t *p_item, bool b_ena, bool b_unplayed ) LIBVLC_USED;
+VLC_API playlist_item_t * playlist_GetPrevLeaf( playlist_t *p_playlist, playlist_item_t *p_root, playlist_item_t *p_item, bool b_ena, bool b_unplayed ) LIBVLC_USED;
 
 /***********************************************************************
  * Inline functions

include/vlc_plugin.h

@@ -29,7 +29,7 @@
  * This file implements plugin (module) macros used to define a vlc module.
  */
 
-VLC_EXPORT( int, vlc_plugin_set, (module_t *, module_config_t *, int, ...) );
+VLC_API int vlc_plugin_set(module_t *, module_config_t *, int, ...);
 
 #define vlc_module_set( mod, ... ) vlc_plugin_set ((mod), NULL, __VA_ARGS__)
 #define vlc_config_set( cfg, ... ) vlc_plugin_set (NULL, (cfg), __VA_ARGS__)

include/vlc_rand.h

@@ -27,11 +27,11 @@
  * This file defined random number generator function in vlc
  */
 
-VLC_EXPORT( void, vlc_rand_bytes, (void *buf, size_t len) );
+VLC_API void vlc_rand_bytes(void *buf, size_t len);
 
 /* Interlocked (but not reproducible) functions for the POSIX PRNG */
-VLC_EXPORT( double, vlc_drand48, (void) LIBVLC_USED );
-VLC_EXPORT( long, vlc_lrand48, (void) LIBVLC_USED );
-VLC_EXPORT( long, vlc_mrand48, (void) LIBVLC_USED );
+VLC_API double vlc_drand48(void) LIBVLC_USED;
+VLC_API long vlc_lrand48(void) LIBVLC_USED;
+VLC_API long vlc_mrand48(void) LIBVLC_USED;
 
 #endif

include/vlc_services_discovery.h

@@ -127,15 +127,15 @@ static inline int vlc_sd_control( services_discovery_t *p_sd, int i_control, va_
 
 /* Get the services discovery modules names to use in Create(), in a null
  * terminated string array. Array and string must be freed after use. */
-VLC_EXPORT( char **, vlc_sd_GetNames, ( vlc_object_t *, char ***, int ** ) LIBVLC_USED );
+VLC_API char ** vlc_sd_GetNames( vlc_object_t *, char ***, int ** ) LIBVLC_USED;
 #define vlc_sd_GetNames(obj, pln, pcat ) \
         vlc_sd_GetNames(VLC_OBJECT(obj), pln, pcat)
 
 /* Creation of a services_discovery object */
-VLC_EXPORT( services_discovery_t *, vlc_sd_Create, ( vlc_object_t *, const char * ) LIBVLC_USED );
-VLC_EXPORT( bool, vlc_sd_Start, ( services_discovery_t * ) );
-VLC_EXPORT( void, vlc_sd_Stop, ( services_discovery_t * ) );
-VLC_EXPORT( void, vlc_sd_Destroy, ( services_discovery_t * ) );
+VLC_API services_discovery_t * vlc_sd_Create( vlc_object_t *, const char * ) LIBVLC_USED;
+VLC_API bool vlc_sd_Start( services_discovery_t * );
+VLC_API void vlc_sd_Stop( services_discovery_t * );
+VLC_API void vlc_sd_Destroy( services_discovery_t * );
 
 /**
  * Helper to stop and destroy the Service Discovery
@@ -147,21 +147,21 @@ static inline void vlc_sd_StopAndDestroy( services_discovery_t * p_this )
 }
 
 /* Read info from discovery object */
-VLC_EXPORT( char *,                 services_discovery_GetLocalizedName, ( services_discovery_t * p_this ) LIBVLC_USED );
+VLC_API char * services_discovery_GetLocalizedName( services_discovery_t * p_this ) LIBVLC_USED;
 
 /* Receive event notification (preferred way to get new items) */
-VLC_EXPORT( vlc_event_manager_t *,  services_discovery_EventManager, ( services_discovery_t * p_this ) LIBVLC_USED );
+VLC_API vlc_event_manager_t * services_discovery_EventManager( services_discovery_t * p_this ) LIBVLC_USED;
 
 /* Used by services_discovery to post update about their items */
     /* About the psz_category, it is a legacy way to add info to the item,
      * for more options, directly set the (meta) data on the input item */
-VLC_EXPORT( void,                   services_discovery_AddItem, ( services_discovery_t * p_this, input_item_t * p_item, const char * psz_category ) );
-VLC_EXPORT( void,                   services_discovery_RemoveItem, ( services_discovery_t * p_this, input_item_t * p_item ) );
+VLC_API void services_discovery_AddItem( services_discovery_t * p_this, input_item_t * p_item, const char * psz_category );
+VLC_API void services_discovery_RemoveItem( services_discovery_t * p_this, input_item_t * p_item );
 
 
 /* SD probing */
 
-VLC_EXPORT(int, vlc_sd_probe_Add, (vlc_probe_t *, const char *, const char *, int category));
+VLC_API int vlc_sd_probe_Add(vlc_probe_t *, const char *, const char *, int category);
 
 #define VLC_SD_PROBE_SUBMODULE \
     add_submodule() \

include/vlc_sout.h

@@ -91,14 +91,14 @@ enum access_out_query_e
     ACCESS_OUT_CONTROLS_PACE, /* arg1=bool *, can fail (assume true) */
 };
 
-VLC_EXPORT( sout_access_out_t *,sout_AccessOutNew, ( vlc_object_t *, const char *psz_access, const char *psz_name ) LIBVLC_USED );
+VLC_API sout_access_out_t * sout_AccessOutNew( vlc_object_t *, const char *psz_access, const char *psz_name ) LIBVLC_USED;
 #define sout_AccessOutNew( obj, access, name ) \
         sout_AccessOutNew( VLC_OBJECT(obj), access, name )
-VLC_EXPORT( void, sout_AccessOutDelete, ( sout_access_out_t * ) );
-VLC_EXPORT( int, sout_AccessOutSeek, ( sout_access_out_t *, off_t ) );
-VLC_EXPORT( ssize_t, sout_AccessOutRead, ( sout_access_out_t *, block_t * ) );
-VLC_EXPORT( ssize_t, sout_AccessOutWrite, ( sout_access_out_t *, block_t * ) );
-VLC_EXPORT( int, sout_AccessOutControl, ( sout_access_out_t *, int, ... ) );
+VLC_API void sout_AccessOutDelete( sout_access_out_t * );
+VLC_API int sout_AccessOutSeek( sout_access_out_t *, off_t );
+VLC_API ssize_t sout_AccessOutRead( sout_access_out_t *, block_t * );
+VLC_API ssize_t sout_AccessOutWrite( sout_access_out_t *, block_t * );
+VLC_API int sout_AccessOutControl( sout_access_out_t *, int, ... );
 
 static inline bool sout_AccessOutCanControlPace( sout_access_out_t *p_ao )
 {
@@ -162,12 +162,12 @@ struct sout_input_t
 };
 
 
-VLC_EXPORT( sout_mux_t *,   sout_MuxNew,          ( sout_instance_t*, const char *, sout_access_out_t * ) LIBVLC_USED );
-VLC_EXPORT( sout_input_t *, sout_MuxAddStream,    ( sout_mux_t *, es_format_t * ) LIBVLC_USED );
-VLC_EXPORT( void,           sout_MuxDeleteStream, ( sout_mux_t *, sout_input_t * ) );
-VLC_EXPORT( void,           sout_MuxDelete,       ( sout_mux_t * ) );
-VLC_EXPORT( void,           sout_MuxSendBuffer, ( sout_mux_t *, sout_input_t  *, block_t * ) );
-VLC_EXPORT( int,            sout_MuxGetStream, (sout_mux_t *, int , mtime_t *));
+VLC_API sout_mux_t * sout_MuxNew( sout_instance_t*, const char *, sout_access_out_t * ) LIBVLC_USED;
+VLC_API sout_input_t * sout_MuxAddStream( sout_mux_t *, es_format_t * ) LIBVLC_USED;
+VLC_API void sout_MuxDeleteStream( sout_mux_t *, sout_input_t * );
+VLC_API void sout_MuxDelete( sout_mux_t * );
+VLC_API void sout_MuxSendBuffer( sout_mux_t *, sout_input_t  *, block_t * );
+VLC_API int sout_MuxGetStream(sout_mux_t *, int , mtime_t *);
 
 static inline int sout_MuxControl( sout_mux_t *p_mux, int i_query, ... )
 {
@@ -207,9 +207,9 @@ struct sout_stream_t
     sout_stream_sys_t *p_sys;
 };
 
-VLC_EXPORT( void, sout_StreamChainDelete, (sout_stream_t *p_first, sout_stream_t *p_last ) );
-VLC_EXPORT( sout_stream_t *, sout_StreamChainNew, (sout_instance_t *p_sout,
-        char *psz_chain, sout_stream_t *p_next, sout_stream_t **p_last) LIBVLC_USED );
+VLC_API void sout_StreamChainDelete(sout_stream_t *p_first, sout_stream_t *p_last );
+VLC_API sout_stream_t *sout_StreamChainNew(sout_instance_t *p_sout,
+        char *psz_chain, sout_stream_t *p_next, sout_stream_t **p_last) LIBVLC_USED;
 
 static inline sout_stream_id_t *sout_StreamIdAdd( sout_stream_t *s, es_format_t *fmt )
 {
@@ -228,14 +228,14 @@ static inline int sout_StreamIdSend( sout_stream_t *s, sout_stream_id_t *id, blo
  * Encoder
  ****************************************************************************/
 
-VLC_EXPORT( encoder_t *, sout_EncoderCreate, ( vlc_object_t *obj ) );
+VLC_API encoder_t * sout_EncoderCreate( vlc_object_t *obj );
 #define sout_EncoderCreate(o) sout_EncoderCreate(VLC_OBJECT(o))
 
 /****************************************************************************
  * Announce handler
  ****************************************************************************/
-VLC_EXPORT(session_descriptor_t*,sout_AnnounceRegisterSDP, ( vlc_object_t *, const char *, const char * ) LIBVLC_USED );
-VLC_EXPORT( int,                sout_AnnounceUnRegister, (vlc_object_t *,session_descriptor_t* ) );
+VLC_API session_descriptor_t* sout_AnnounceRegisterSDP( vlc_object_t *, const char *, const char * ) LIBVLC_USED;
+VLC_API int sout_AnnounceUnRegister(vlc_object_t *,session_descriptor_t* );
 #define sout_AnnounceRegisterSDP(o, sdp, addr) \
         sout_AnnounceRegisterSDP(VLC_OBJECT (o), sdp, addr)
 #define sout_AnnounceUnRegister(o, a) \
@@ -245,9 +245,9 @@ VLC_EXPORT( int,                sout_AnnounceUnRegister, (vlc_object_t *,session
 
 struct sockaddr;
 
-VLC_EXPORT( char *, vlc_sdp_Start, ( vlc_object_t *obj, const char *cfgpref, const struct sockaddr *src, size_t srclen, const struct sockaddr *addr, size_t addrlen ) LIBVLC_USED );
-VLC_EXPORT( char *, sdp_AddMedia, (char **sdp, const char *type, const char *protocol, int dport, unsigned pt, bool bw_indep, unsigned bw, const char *ptname, unsigned clockrate, unsigned channels, const char *fmtp) );
-VLC_EXPORT( char *, sdp_AddAttribute, (char **sdp, const char *name, const char *fmt, ...) LIBVLC_FORMAT( 3, 4 ) );
+VLC_API char * vlc_sdp_Start( vlc_object_t *obj, const char *cfgpref, const struct sockaddr *src, size_t srclen, const struct sockaddr *addr, size_t addrlen ) LIBVLC_USED;
+VLC_API char * sdp_AddMedia(char **sdp, const char *type, const char *protocol, int dport, unsigned pt, bool bw_indep, unsigned bw, const char *ptname, unsigned clockrate, unsigned channels, const char *fmtp);
+VLC_API char * sdp_AddAttribute(char **sdp, const char *name, const char *fmt, ...) LIBVLC_FORMAT( 3, 4 );
 
 /** Description module */
 typedef struct sout_description_data_t

include/vlc_spu.h

@@ -58,9 +58,9 @@ struct spu_t
     spu_private_t *p;
 };
 
-VLC_EXPORT( spu_t *, spu_Create, ( vlc_object_t * ) );
+VLC_API spu_t * spu_Create( vlc_object_t * );
 #define spu_Create(a) spu_Create(VLC_OBJECT(a))
-VLC_EXPORT( void, spu_Destroy, ( spu_t * ) );
+VLC_API void spu_Destroy( spu_t * );
 
 /**
  * This function sends a subpicture to the spu_t core.
@@ -68,7 +68,7 @@ VLC_EXPORT( void, spu_Destroy, ( spu_t * ) );
  * You cannot use the provided subpicture anymore. The spu_t core
  * will destroy it at its convenience.
  */
-VLC_EXPORT( void, spu_PutSubpicture, ( spu_t *, subpicture_t * ) );
+VLC_API void spu_PutSubpicture( spu_t *, subpicture_t * );
 
 /**
  * This function will return an unique subpicture containing the OSD and
@@ -80,27 +80,27 @@ VLC_EXPORT( void, spu_PutSubpicture, ( spu_t *, subpicture_t * ) );
  *
  * The returned value if non NULL must be released by subpicture_Delete().
  */
-VLC_EXPORT( subpicture_t *, spu_Render, ( spu_t *, const vlc_fourcc_t *p_chroma_list, const video_format_t *p_fmt_dst, const video_format_t *p_fmt_src, mtime_t render_subtitle_date, mtime_t render_osd_date, bool ignore_osd ) );
+VLC_API subpicture_t * spu_Render( spu_t *, const vlc_fourcc_t *p_chroma_list, const video_format_t *p_fmt_dst, const video_format_t *p_fmt_src, mtime_t render_subtitle_date, mtime_t render_osd_date, bool ignore_osd );
 
 /**
  * It registers a new SPU channel.
  */
-VLC_EXPORT( int, spu_RegisterChannel, ( spu_t * ) );
+VLC_API int spu_RegisterChannel( spu_t * );
 
 /**
  * It clears all subpictures associated to a SPU channel.
  */
-VLC_EXPORT( void, spu_ClearChannel, ( spu_t *, int ) );
+VLC_API void spu_ClearChannel( spu_t *, int );
 
 /**
  * It changes the sub sources list
  */
-VLC_EXPORT( void, spu_ChangeSources, ( spu_t *, const char * ) );
+VLC_API void spu_ChangeSources( spu_t *, const char * );
 
 /**
  * It changes the sub filters list
  */
-VLC_EXPORT( void, spu_ChangeFilters, ( spu_t *, const char * ) );
+VLC_API void spu_ChangeFilters( spu_t *, const char * );
 
 /** @}*/
 

include/vlc_sql.h

@@ -150,9 +150,9 @@ struct sql_t
  * @param psz_pass Password for the database
  * @return The VLC SQL object, type sql_t.
  **/
-VLC_EXPORT( sql_t*, sql_Create, ( vlc_object_t *p_this, const char *psz_name,
+VLC_API sql_t *sql_Create( vlc_object_t *p_this, const char *psz_name,
             const char* psz_host, int i_port,
-            const char* psz_user, const char* psz_pass ) );
+            const char* psz_user, const char* psz_pass );
 #define sql_Create( a, b, c, d, e, f ) sql_Create( VLC_OBJECT(a), b, c, d, e, f )
 
 
@@ -161,7 +161,7 @@ VLC_EXPORT( sql_t*, sql_Create, ( vlc_object_t *p_this, const char *psz_name,
  * @param obj This p_sql object
  * @return Nothing
  */
-VLC_EXPORT( void, sql_Destroy, ( vlc_object_t *obj ) );
+VLC_API void sql_Destroy( vlc_object_t *obj );
 #define sql_Destroy( a ) sql_Destroy( VLC_OBJECT( a ) )
 
 

include/vlc_stream.h

@@ -113,13 +113,13 @@ enum stream_query_e
     STREAM_SET_RECORD_STATE,     /**< arg1=bool, arg2=const char *psz_ext (if arg1 is true)  res=can fail */
 };
 
-VLC_EXPORT( int, stream_Read, ( stream_t *s, void *p_read, int i_read ) );
-VLC_EXPORT( int, stream_Peek, ( stream_t *s, const uint8_t **pp_peek, int i_peek ) );
-VLC_EXPORT( int, stream_vaControl, ( stream_t *s, int i_query, va_list args ) );
-VLC_EXPORT( void, stream_Delete, ( stream_t *s ) );
-VLC_EXPORT( int, stream_Control, ( stream_t *s, int i_query, ... ) );
-VLC_EXPORT( block_t *, stream_Block, ( stream_t *s, int i_size ) );
-VLC_EXPORT( char *, stream_ReadLine, ( stream_t * ) );
+VLC_API int stream_Read( stream_t *s, void *p_read, int i_read );
+VLC_API int stream_Peek( stream_t *s, const uint8_t **pp_peek, int i_peek );
+VLC_API int stream_vaControl( stream_t *s, int i_query, va_list args );
+VLC_API void stream_Delete( stream_t *s );
+VLC_API int stream_Control( stream_t *s, int i_query, ... );
+VLC_API block_t * stream_Block( stream_t *s, int i_size );
+VLC_API char * stream_ReadLine( stream_t * );
 
 /**
  * Get the current position in a stream
@@ -166,25 +166,25 @@ static inline char *stream_ContentType( stream_t *s )
  * Create a special stream and a demuxer, this allows chaining demuxers
  * You must delete it using stream_Delete.
  */
-VLC_EXPORT( stream_t *, stream_DemuxNew, ( demux_t *p_demux, const char *psz_demux, es_out_t *out ) );
+VLC_API stream_t * stream_DemuxNew( demux_t *p_demux, const char *psz_demux, es_out_t *out );
 
 /**
  * Send data to a stream_t handle created by stream_DemuxNew.
  */
-VLC_EXPORT( void,      stream_DemuxSend,  ( stream_t *s, block_t *p_block ) );
+VLC_API void stream_DemuxSend( stream_t *s, block_t *p_block );
 
 /**
  * Create a stream_t reading from memory.
  * You must delete it using stream_Delete.
  */
-VLC_EXPORT( stream_t *, stream_MemoryNew, (vlc_object_t *p_obj, uint8_t *p_buffer, uint64_t i_size, bool b_preserve_memory ) );
+VLC_API stream_t * stream_MemoryNew(vlc_object_t *p_obj, uint8_t *p_buffer, uint64_t i_size, bool b_preserve_memory );
 #define stream_MemoryNew( a, b, c, d ) stream_MemoryNew( VLC_OBJECT(a), b, c, d )
 
 /**
  * Create a stream_t reading from a URL.
  * You must delete it using stream_Delete.
  */
-VLC_EXPORT( stream_t *, stream_UrlNew, (vlc_object_t *p_this, const char *psz_url ) );
+VLC_API stream_t * stream_UrlNew(vlc_object_t *p_this, const char *psz_url );
 #define stream_UrlNew( a, b ) stream_UrlNew( VLC_OBJECT(a), b )
 
 
@@ -192,7 +192,7 @@ VLC_EXPORT( stream_t *, stream_UrlNew, (vlc_object_t *p_this, const char *psz_ur
  * Try to add a stream filter to an open stream.
  * @return New stream to use, or NULL if the filter could not be added.
  **/
-VLC_EXPORT( stream_t*, stream_FilterNew, ( stream_t *p_source, const char *psz_stream_filter ) );
+VLC_API stream_t* stream_FilterNew( stream_t *p_source, const char *psz_stream_filter );
 /**
  * @}
  */

include/vlc_strings.h

@@ -34,24 +34,24 @@
  * @{
  */
 
-VLC_EXPORT( void, resolve_xml_special_chars, ( char *psz_value ) );
-VLC_EXPORT( char *, convert_xml_special_chars, ( const char *psz_content ) );
+VLC_API void resolve_xml_special_chars( char *psz_value );
+VLC_API char * convert_xml_special_chars( const char *psz_content );
 
-VLC_EXPORT( char *, vlc_b64_encode_binary, ( const uint8_t *, size_t ) );
-VLC_EXPORT( char *, vlc_b64_encode, ( const char * ) );
+VLC_API char * vlc_b64_encode_binary( const uint8_t *, size_t );
+VLC_API char * vlc_b64_encode( const char * );
 
-VLC_EXPORT( size_t, vlc_b64_decode_binary_to_buffer, ( uint8_t *p_dst, size_t i_dst_max, const char *psz_src ) );
-VLC_EXPORT( size_t, vlc_b64_decode_binary, ( uint8_t **pp_dst, const char *psz_src ) );
-VLC_EXPORT( char *, vlc_b64_decode, ( const char *psz_src ) );
+VLC_API size_t vlc_b64_decode_binary_to_buffer( uint8_t *p_dst, size_t i_dst_max, const char *psz_src );
+VLC_API size_t vlc_b64_decode_binary( uint8_t **pp_dst, const char *psz_src );
+VLC_API char * vlc_b64_decode( const char *psz_src );
 
-VLC_EXPORT( char *, str_format_time, ( const char * ) );
-VLC_EXPORT( char *, str_format_meta, ( vlc_object_t *, const char * ) );
+VLC_API char * str_format_time( const char * );
+VLC_API char * str_format_meta( vlc_object_t *, const char * );
 #define str_format_meta( a, b ) str_format_meta( VLC_OBJECT( a ), b )
-VLC_EXPORT( char *, str_format, ( vlc_object_t *, const char * ) );
+VLC_API char * str_format( vlc_object_t *, const char * );
 #define str_format( a, b ) str_format( VLC_OBJECT( a ), b )
 
-VLC_EXPORT( void, filename_sanitize, ( char * ) );
-VLC_EXPORT( void, path_sanitize, ( char * ) );
+VLC_API void filename_sanitize( char * );
+VLC_API void path_sanitize( char * );
 
 /**
  * @}

include/vlc_subpicture.h

@@ -85,7 +85,7 @@ struct subpicture_region_t
  *
  * You must use subpicture_region_Delete to destroy it.
  */
-VLC_EXPORT( subpicture_region_t *, subpicture_region_New, ( const video_format_t *p_fmt ) );
+VLC_API subpicture_region_t * subpicture_region_New( const video_format_t *p_fmt );
 
 /**
  * This function will destroy a subpicture region allocated by
@@ -93,7 +93,7 @@ VLC_EXPORT( subpicture_region_t *, subpicture_region_New, ( const video_format_t
  *
  * You may give it NULL.
  */
-VLC_EXPORT( void, subpicture_region_Delete, ( subpicture_region_t *p_region ) );
+VLC_API void subpicture_region_Delete( subpicture_region_t *p_region );
 
 /**
  * This function will destroy a list of subpicture regions allocated by
@@ -101,7 +101,7 @@ VLC_EXPORT( void, subpicture_region_Delete, ( subpicture_region_t *p_region ) );
  *
  * Provided for convenience.
  */
-VLC_EXPORT( void, subpicture_region_ChainDelete, ( subpicture_region_t *p_head ) );
+VLC_API void subpicture_region_ChainDelete( subpicture_region_t *p_head );
 
 /**
  *
@@ -178,13 +178,13 @@ struct subpicture_t
  *
  * You must use subpicture_Delete to destroy it.
  */
-VLC_EXPORT( subpicture_t *, subpicture_New, ( const subpicture_updater_t * ) );
+VLC_API subpicture_t * subpicture_New( const subpicture_updater_t * );
 
 /**
  * This function delete a subpicture created by subpicture_New.
  * You may give it NULL.
  */
-VLC_EXPORT( void,  subpicture_Delete, ( subpicture_t *p_subpic ) );
+VLC_API void subpicture_Delete( subpicture_t *p_subpic );
 
 /**
  * This function will create a subpicture having one region in the requested
@@ -193,13 +193,13 @@ VLC_EXPORT( void,  subpicture_Delete, ( subpicture_t *p_subpic ) );
  * The picture_t given is not released nor used inside the
  * returned subpicture_t.
  */
-VLC_EXPORT( subpicture_t *, subpicture_NewFromPicture, ( vlc_object_t *, picture_t *, vlc_fourcc_t i_chroma ) );
+VLC_API subpicture_t * subpicture_NewFromPicture( vlc_object_t *, picture_t *, vlc_fourcc_t i_chroma );
 
 /**
  * This function will update the content of a subpicture created with
  * a non NULL subpicture_updater_t.
  */
-VLC_EXPORT( void, subpicture_Update, ( subpicture_t *, const video_format_t *src, const video_format_t *, mtime_t ) );
+VLC_API void subpicture_Update( subpicture_t *, const video_format_t *src, const video_format_t *, mtime_t );
 
 /**@}*/
 

include/vlc_text_style.h

@@ -79,22 +79,22 @@ typedef struct
 /**
  * Create a default text style
  */
-VLC_EXPORT( text_style_t *, text_style_New, ( void ) );
+VLC_API text_style_t * text_style_New( void );
 
 /**
  * Copy a text style into another
  */
-VLC_EXPORT( text_style_t *, text_style_Copy, ( text_style_t *, const text_style_t * ) );
+VLC_API text_style_t * text_style_Copy( text_style_t *, const text_style_t * );
 
 /**
  * Duplicate a text style
  */
-VLC_EXPORT( text_style_t *, text_style_Duplicate, ( const text_style_t * ) );
+VLC_API text_style_t * text_style_Duplicate( const text_style_t * );
 
 /**
  * Delete a text style created by text_style_New or text_style_Duplicate
  */
-VLC_EXPORT( void, text_style_Delete, ( text_style_t * ) );
+VLC_API void text_style_Delete( text_style_t * );
 
 #ifdef __cplusplus
 }

include/vlc_threads.h

@@ -167,46 +167,46 @@ typedef struct vlc_timer *vlc_timer_t;
 /*****************************************************************************
  * Function definitions
  *****************************************************************************/
-VLC_EXPORT( void, vlc_mutex_init,    ( vlc_mutex_t * ) );
-VLC_EXPORT( void, vlc_mutex_init_recursive, ( vlc_mutex_t * ) );
-VLC_EXPORT( void, vlc_mutex_destroy, ( vlc_mutex_t * ) );
-VLC_EXPORT( void, vlc_mutex_lock, ( vlc_mutex_t * ) );
-VLC_EXPORT( int,  vlc_mutex_trylock, ( vlc_mutex_t * ) LIBVLC_USED );
-VLC_EXPORT( void, vlc_mutex_unlock, ( vlc_mutex_t * ) );
-VLC_EXPORT( void, vlc_cond_init,     ( vlc_cond_t * ) );
-VLC_EXPORT( void, vlc_cond_init_daytime, ( vlc_cond_t * ) );
-VLC_EXPORT( void, vlc_cond_destroy,  ( vlc_cond_t * ) );
-VLC_EXPORT( void, vlc_cond_signal, (vlc_cond_t *) );
-VLC_EXPORT( void, vlc_cond_broadcast, (vlc_cond_t *) );
-VLC_EXPORT( void, vlc_cond_wait, (vlc_cond_t *, vlc_mutex_t *) );
-VLC_EXPORT( int,  vlc_cond_timedwait, (vlc_cond_t *, vlc_mutex_t *, mtime_t) );
-VLC_EXPORT( void, vlc_sem_init, (vlc_sem_t *, unsigned) );
-VLC_EXPORT( void, vlc_sem_destroy, (vlc_sem_t *) );
-VLC_EXPORT( int,  vlc_sem_post, (vlc_sem_t *) );
-VLC_EXPORT( void, vlc_sem_wait, (vlc_sem_t *) );
-
-VLC_EXPORT( void, vlc_rwlock_init, (vlc_rwlock_t *) );
-VLC_EXPORT( void, vlc_rwlock_destroy, (vlc_rwlock_t *) );
-VLC_EXPORT( void, vlc_rwlock_rdlock, (vlc_rwlock_t *) );
-VLC_EXPORT( void, vlc_rwlock_wrlock, (vlc_rwlock_t *) );
-VLC_EXPORT( void, vlc_rwlock_unlock, (vlc_rwlock_t *) );
-VLC_EXPORT( int, vlc_threadvar_create, (vlc_threadvar_t * , void (*) (void *) ) );
-VLC_EXPORT( void, vlc_threadvar_delete, (vlc_threadvar_t *) );
-VLC_EXPORT( int, vlc_threadvar_set, (vlc_threadvar_t, void *) );
-VLC_EXPORT( void *, vlc_threadvar_get, (vlc_threadvar_t) );
-VLC_EXPORT( int,  vlc_thread_create, ( vlc_object_t *, void * ( * ) ( vlc_object_t * ), int ) LIBVLC_USED LIBVLC_DEPRECATED );
-VLC_EXPORT( int,  vlc_thread_set_priority, ( vlc_object_t *, int ) LIBVLC_DEPRECATED );
-VLC_EXPORT( void, vlc_thread_join,   ( vlc_object_t * ) LIBVLC_DEPRECATED );
-
-VLC_EXPORT( int, vlc_clone, (vlc_thread_t *, void * (*) (void *), void *, int) LIBVLC_USED );
-VLC_EXPORT( void, vlc_cancel, (vlc_thread_t) );
-VLC_EXPORT( void, vlc_join, (vlc_thread_t, void **) );
-VLC_EXPORT (void, vlc_control_cancel, (int cmd, ...));
-
-VLC_EXPORT( int, vlc_timer_create, (vlc_timer_t *, void (*) (void *), void *) LIBVLC_USED );
-VLC_EXPORT( void, vlc_timer_destroy, (vlc_timer_t) );
-VLC_EXPORT( void, vlc_timer_schedule, (vlc_timer_t, bool, mtime_t, mtime_t) );
-VLC_EXPORT( unsigned, vlc_timer_getoverrun, (vlc_timer_t) LIBVLC_USED );
+VLC_API void vlc_mutex_init( vlc_mutex_t * );
+VLC_API void vlc_mutex_init_recursive( vlc_mutex_t * );
+VLC_API void vlc_mutex_destroy( vlc_mutex_t * );
+VLC_API void vlc_mutex_lock( vlc_mutex_t * );
+VLC_API int vlc_mutex_trylock( vlc_mutex_t * ) LIBVLC_USED;
+VLC_API void vlc_mutex_unlock( vlc_mutex_t * );
+VLC_API void vlc_cond_init( vlc_cond_t * );
+VLC_API void vlc_cond_init_daytime( vlc_cond_t * );
+VLC_API void vlc_cond_destroy( vlc_cond_t * );
+VLC_API void vlc_cond_signal(vlc_cond_t *);
+VLC_API void vlc_cond_broadcast(vlc_cond_t *);
+VLC_API void vlc_cond_wait(vlc_cond_t *, vlc_mutex_t *);
+VLC_API int vlc_cond_timedwait(vlc_cond_t *, vlc_mutex_t *, mtime_t);
+VLC_API void vlc_sem_init(vlc_sem_t *, unsigned);
+VLC_API void vlc_sem_destroy(vlc_sem_t *);
+VLC_API int vlc_sem_post(vlc_sem_t *);
+VLC_API void vlc_sem_wait(vlc_sem_t *);
+
+VLC_API void vlc_rwlock_init(vlc_rwlock_t *);
+VLC_API void vlc_rwlock_destroy(vlc_rwlock_t *);
+VLC_API void vlc_rwlock_rdlock(vlc_rwlock_t *);
+VLC_API void vlc_rwlock_wrlock(vlc_rwlock_t *);
+VLC_API void vlc_rwlock_unlock(vlc_rwlock_t *);
+VLC_API int vlc_threadvar_create(vlc_threadvar_t * , void (*) (void *) );
+VLC_API void vlc_threadvar_delete(vlc_threadvar_t *);
+VLC_API int vlc_threadvar_set(vlc_threadvar_t, void *);
+VLC_API void * vlc_threadvar_get(vlc_threadvar_t);
+VLC_API int vlc_thread_create( vlc_object_t *, void * ( * ) ( vlc_object_t * ), int ) LIBVLC_USED LIBVLC_DEPRECATED;
+VLC_API int vlc_thread_set_priority( vlc_object_t *, int ) LIBVLC_DEPRECATED;
+VLC_API void vlc_thread_join( vlc_object_t * ) LIBVLC_DEPRECATED;
+
+VLC_API int vlc_clone(vlc_thread_t *, void * (*) (void *), void *, int) LIBVLC_USED;
+VLC_API void vlc_cancel(vlc_thread_t);
+VLC_API void vlc_join(vlc_thread_t, void **);
+VLC_API void vlc_control_cancel (int cmd, ...);
+
+VLC_API int vlc_timer_create(vlc_timer_t *, void (*) (void *), void *) LIBVLC_USED;
+VLC_API void vlc_timer_destroy(vlc_timer_t);
+VLC_API void vlc_timer_schedule(vlc_timer_t, bool, mtime_t, mtime_t);
+VLC_API unsigned vlc_timer_getoverrun(vlc_timer_t) LIBVLC_USED;
 
 #ifndef LIBVLC_USE_PTHREAD_CANCEL
 enum {
@@ -215,9 +215,9 @@ enum {
 };
 #endif
 
-VLC_EXPORT( int, vlc_savecancel, (void) );
-VLC_EXPORT( void, vlc_restorecancel, (int state) );
-VLC_EXPORT( void, vlc_testcancel, (void) );
+VLC_API int vlc_savecancel(void);
+VLC_API void vlc_restorecancel(int state);
+VLC_API void vlc_testcancel(void);
 
 #if defined (LIBVLC_USE_PTHREAD_CANCEL)
 /**
@@ -433,7 +433,7 @@ enum {
    VLC_MAX_MUTEX
 };
 
-VLC_EXPORT( void, vlc_global_mutex, ( unsigned, bool ) );
+VLC_API void vlc_global_mutex( unsigned, bool );
 #define vlc_global_lock( n ) vlc_global_mutex( n, true )
 #define vlc_global_unlock( n ) vlc_global_mutex( n, false )
 

include/vlc_tls.h

@@ -72,8 +72,8 @@ int tls_ServerSessionHandshake (tls_session_t *, int fd);
 int tls_SessionContinueHandshake (tls_session_t *);
 void tls_ServerSessionClose (tls_session_t *);
 
-VLC_EXPORT( tls_session_t *, tls_ClientCreate, ( vlc_object_t *, int, const char * ) );
-VLC_EXPORT( void, tls_ClientDelete, ( tls_session_t * ) );
+VLC_API tls_session_t * tls_ClientCreate( vlc_object_t *, int, const char * );
+VLC_API void tls_ClientDelete( tls_session_t * );
 
 /* NOTE: It is assumed that a->sock.p_sys = a */
 # define tls_Send( a, b, c ) (((tls_session_t *)a)->sock.pf_send (a, b, c ))

include/vlc_update.h

@@ -55,13 +55,13 @@ struct update_release_t
 
 typedef struct update_release_t update_release_t;
 
-VLC_EXPORT( update_t *, update_New, ( vlc_object_t * ) );
+VLC_API update_t * update_New( vlc_object_t * );
 #define update_New( a ) update_New( VLC_OBJECT( a ) )
-VLC_EXPORT( void, update_Delete, ( update_t * ) );
-VLC_EXPORT( void, update_Check, ( update_t *, void (*callback)( void*, bool ), void * ) );
-VLC_EXPORT( bool, update_NeedUpgrade, ( update_t * ) );
-VLC_EXPORT( void, update_Download, ( update_t *, const char* ) );
-VLC_EXPORT( update_release_t*, update_GetRelease, ( update_t * ) );
+VLC_API void update_Delete( update_t * );
+VLC_API void update_Check( update_t *, void (*callback)( void*, bool ), void * );
+VLC_API bool update_NeedUpgrade( update_t * );
+VLC_API void update_Download( update_t *, const char* );
+VLC_API update_release_t* update_GetRelease( update_t * );
 
 /**
  * @}

include/vlc_url.h

@@ -45,11 +45,11 @@ struct vlc_url_t
     char *psz_buffer; /* to be freed */
 };
 
-VLC_EXPORT( char *, decode_URI_duplicate, ( const char *psz ) );
-VLC_EXPORT( char *, decode_URI, ( char *psz ) );
-VLC_EXPORT( char *, encode_URI_component, ( const char *psz ) );
-VLC_EXPORT( char *, make_URI, ( const char *path, const char *scheme ) );
-VLC_EXPORT( char *, make_path, ( const char *url ) );
+VLC_API char * decode_URI_duplicate( const char *psz );
+VLC_API char * decode_URI( char *psz );
+VLC_API char * encode_URI_component( const char *psz );
+VLC_API char * make_URI( const char *path, const char *scheme );
+VLC_API char * make_path( const char *url );
 
 /*****************************************************************************
  * vlc_UrlParse:

include/vlc_variables.h

@@ -128,36 +128,36 @@ enum {
 /*****************************************************************************
  * Prototypes
  *****************************************************************************/
-VLC_EXPORT( int, var_Create, ( vlc_object_t *, const char *, int ) );
+VLC_API int var_Create( vlc_object_t *, const char *, int );
 #define var_Create(a,b,c) var_Create( VLC_OBJECT(a), b, c )
 
-VLC_EXPORT( int, var_Destroy, ( vlc_object_t *, const char * ) );
+VLC_API int var_Destroy( vlc_object_t *, const char * );
 #define var_Destroy(a,b) var_Destroy( VLC_OBJECT(a), b )
 
-VLC_EXPORT( int, var_Change, ( vlc_object_t *, const char *, int, vlc_value_t *, vlc_value_t * ) );
+VLC_API int var_Change( vlc_object_t *, const char *, int, vlc_value_t *, vlc_value_t * );
 #define var_Change(a,b,c,d,e) var_Change( VLC_OBJECT(a), b, c, d, e )
 
-VLC_EXPORT( int, var_Type, ( vlc_object_t *, const char * ) LIBVLC_USED );
+VLC_API int var_Type( vlc_object_t *, const char * ) LIBVLC_USED;
 #define var_Type(a,b) var_Type( VLC_OBJECT(a), b )
 
-VLC_EXPORT( int, var_Set, ( vlc_object_t *, const char *, vlc_value_t ) );
+VLC_API int var_Set( vlc_object_t *, const char *, vlc_value_t );
 #define var_Set(a,b,c) var_Set( VLC_OBJECT(a), b, c )
 
-VLC_EXPORT( int, var_Get, ( vlc_object_t *, const char *, vlc_value_t * ) );
+VLC_API int var_Get( vlc_object_t *, const char *, vlc_value_t * );
 #define var_Get(a,b,c) var_Get( VLC_OBJECT(a), b, c )
 
-VLC_EXPORT( int, var_SetChecked, ( vlc_object_t *, const char *, int, vlc_value_t ) );
+VLC_API int var_SetChecked( vlc_object_t *, const char *, int, vlc_value_t );
 #define var_SetChecked(o,n,t,v) var_SetChecked(VLC_OBJECT(o),n,t,v)
-VLC_EXPORT( int, var_GetChecked, ( vlc_object_t *, const char *, int, vlc_value_t * ) );
+VLC_API int var_GetChecked( vlc_object_t *, const char *, int, vlc_value_t * );
 #define var_GetChecked(o,n,t,v) var_GetChecked(VLC_OBJECT(o),n,t,v)
-VLC_EXPORT( int, var_GetAndSet, ( vlc_object_t *, const char *, int, vlc_value_t * ) );
+VLC_API int var_GetAndSet( vlc_object_t *, const char *, int, vlc_value_t * );
 
-VLC_EXPORT( int, var_Inherit, ( vlc_object_t *, const char *, int, vlc_value_t * ) );
+VLC_API int var_Inherit( vlc_object_t *, const char *, int, vlc_value_t * );
 
-VLC_EXPORT( int, var_Command, ( vlc_object_t *, const char *, const char *, const char *, char ** ) );
+VLC_API int var_Command( vlc_object_t *, const char *, const char *, const char *, char ** );
 #define var_Command(a,b,c,d,e) var_Command( VLC_OBJECT( a ), b, c, d, e )
 
-VLC_EXPORT( void, var_FreeList, ( vlc_value_t *, vlc_value_t * ) );
+VLC_API void var_FreeList( vlc_value_t *, vlc_value_t * );
 
 
 /*****************************************************************************
@@ -169,9 +169,9 @@ VLC_EXPORT( void, var_FreeList, ( vlc_value_t *, vlc_value_t * ) );
  *                 vlc_value_t newvalue,
  *                 void *p_data);
  *****************************************************************************/
-VLC_EXPORT( int, var_AddCallback, ( vlc_object_t *, const char *, vlc_callback_t, void * ) );
-VLC_EXPORT( int, var_DelCallback, ( vlc_object_t *, const char *, vlc_callback_t, void * ) );
-VLC_EXPORT( int, var_TriggerCallback, ( vlc_object_t *, const char * ) );
+VLC_API int var_AddCallback( vlc_object_t *, const char *, vlc_callback_t, void * );
+VLC_API int var_DelCallback( vlc_object_t *, const char *, vlc_callback_t, void * );
+VLC_API int var_TriggerCallback( vlc_object_t *, const char * );
 
 #define var_AddCallback(a,b,c,d) var_AddCallback( VLC_OBJECT(a), b, c, d )
 #define var_DelCallback(a,b,c,d) var_DelCallback( VLC_OBJECT(a), b, c, d )
@@ -725,7 +725,7 @@ static inline void *var_InheritAddress( vlc_object_t *obj, const char *name )
 }
 #define var_InheritAddress(o, n) var_InheritAddress(VLC_OBJECT(o), n)
 
-VLC_EXPORT( int, var_InheritURational, ( vlc_object_t *, unsigned *num, unsigned *den, const char *var ) );
+VLC_API int var_InheritURational( vlc_object_t *, unsigned *num, unsigned *den, const char *var );
 #define var_InheritURational(a,b,c,d) var_InheritURational(VLC_OBJECT(a), b, c, d)
 
 #define var_GetInteger(a,b)   var_GetInteger( VLC_OBJECT(a),b)
@@ -736,7 +736,7 @@ VLC_EXPORT( int, var_InheritURational, ( vlc_object_t *, unsigned *num, unsigned
 #define var_GetNonEmptyString(a,b)   var_GetNonEmptyString( VLC_OBJECT(a),b)
 #define var_GetAddress(a,b)  var_GetAddress( VLC_OBJECT(a),b)
 
-VLC_EXPORT( int, var_LocationParse, (vlc_object_t *, const char *mrl, const char *prefix) );
+VLC_API int var_LocationParse(vlc_object_t *, const char *mrl, const char *prefix);
 #define var_LocationParse(o, m, p) var_LocationParse(VLC_OBJECT(o), m, p)
 
 /**

include/vlc_video_splitter.h

@@ -133,8 +133,8 @@ static inline void video_splitter_DeletePicture( video_splitter_t *p_splitter,
 }
 
 /* */
-VLC_EXPORT( video_splitter_t *, video_splitter_New, ( vlc_object_t *, const char *psz_name, const video_format_t * ) );
-VLC_EXPORT( void, video_splitter_Delete, ( video_splitter_t * ) );
+VLC_API video_splitter_t * video_splitter_New( vlc_object_t *, const char *psz_name, const video_format_t * );
+VLC_API void video_splitter_Delete( video_splitter_t * );
 
 static inline int video_splitter_Filter( video_splitter_t *p_splitter,
                                          picture_t *pp_dst[], picture_t *p_src )

include/vlc_vlm.h

@@ -184,16 +184,16 @@ struct vlm_message_t
 extern "C" {
 #endif
 
-VLC_EXPORT( vlm_t *, vlm_New, ( vlc_object_t * ) );
+VLC_API vlm_t * vlm_New( vlc_object_t * );
 #define vlm_New( a ) vlm_New( VLC_OBJECT(a) )
-VLC_EXPORT( void,      vlm_Delete, ( vlm_t * ) );
-VLC_EXPORT( int,       vlm_ExecuteCommand, ( vlm_t *, const char *, vlm_message_t ** ) );
-VLC_EXPORT( int,       vlm_Control, ( vlm_t *p_vlm, int i_query, ... ) );
+VLC_API void vlm_Delete( vlm_t * );
+VLC_API int vlm_ExecuteCommand( vlm_t *, const char *, vlm_message_t ** );
+VLC_API int vlm_Control( vlm_t *p_vlm, int i_query, ... );
 
-VLC_EXPORT( vlm_message_t *, vlm_MessageSimpleNew, ( const char * ) );
-VLC_EXPORT( vlm_message_t *, vlm_MessageNew, ( const char *, const char *, ... ) LIBVLC_FORMAT( 2, 3 ) );
-VLC_EXPORT( vlm_message_t *, vlm_MessageAdd, ( vlm_message_t *, vlm_message_t * ) );
-VLC_EXPORT( void,            vlm_MessageDelete, ( vlm_message_t * ) );
+VLC_API vlm_message_t * vlm_MessageSimpleNew( const char * );
+VLC_API vlm_message_t * vlm_MessageNew( const char *, const char *, ... ) LIBVLC_FORMAT( 2, 3 );
+VLC_API vlm_message_t * vlm_MessageAdd( vlm_message_t *, vlm_message_t * );
+VLC_API void vlm_MessageDelete( vlm_message_t * );
 
 /* media helpers */
 
@@ -266,11 +266,11 @@ static inline void vlm_media_Clean( vlm_media_t *p_media )
     free( p_media->psz_name );
 
     for( i = 0; i < p_media->i_input; i++ )
-        free( p_media->ppsz_input[i]) ;
+        free( p_media->ppsz_input[i]);
     TAB_CLEAN(p_media->i_input, p_media->ppsz_input );
 
     for( i = 0; i < p_media->i_option; i++ )
-        free( p_media->ppsz_option[i]) ;
+        free( p_media->ppsz_option[i]);
     TAB_CLEAN(p_media->i_option, p_media->ppsz_option );
 
     free( p_media->psz_output );

include/vlc_vout.h

@@ -103,7 +103,7 @@ struct vout_thread_t {
  * \param cfg the video configuration requested.
  * \return a vout
  */
-VLC_EXPORT( vout_thread_t *, vout_Request, ( vlc_object_t *object, const vout_configuration_t *cfg ) );
+VLC_API vout_thread_t * vout_Request( vlc_object_t *object, const vout_configuration_t *cfg );
 #define vout_Request(a,b) vout_Request(VLC_OBJECT(a),b)
 
 /**
@@ -114,7 +114,7 @@ VLC_EXPORT( vout_thread_t *, vout_Request, ( vlc_object_t *object, const vout_co
  *
  * \param p_vout the vout to close
  */
-VLC_EXPORT( void,            vout_Close,        ( vout_thread_t *p_vout ) );
+VLC_API void vout_Close( vout_thread_t *p_vout );
 
 /**
  * This function will close a vout created by vout_Create
@@ -140,24 +140,24 @@ static inline void vout_CloseAndRelease( vout_thread_t *p_vout )
  * available.
  *
  */
-VLC_EXPORT( int, vout_GetSnapshot, ( vout_thread_t *p_vout,
-                                     block_t **pp_image, picture_t **pp_picture,
-                                     video_format_t *p_fmt,
-                                     const char *psz_format, mtime_t i_timeout ) );
+VLC_API int vout_GetSnapshot( vout_thread_t *p_vout,
+                              block_t **pp_image, picture_t **pp_picture,
+                              video_format_t *p_fmt,
+                              const char *psz_format, mtime_t i_timeout );
 
 /* */
-VLC_EXPORT( picture_t *,     vout_GetPicture,     ( vout_thread_t * ) );
-VLC_EXPORT( void,            vout_PutPicture,     ( vout_thread_t *, picture_t * ) );
+VLC_API picture_t * vout_GetPicture( vout_thread_t * );
+VLC_API void vout_PutPicture( vout_thread_t *, picture_t * );
 
-VLC_EXPORT( void,            vout_HoldPicture,    ( vout_thread_t *, picture_t * ) );
-VLC_EXPORT( void,            vout_ReleasePicture, ( vout_thread_t *, picture_t * ) );
+VLC_API void vout_HoldPicture( vout_thread_t *, picture_t * );
+VLC_API void vout_ReleasePicture( vout_thread_t *, picture_t * );
 
 /* */
-VLC_EXPORT( void, vout_PutSubpicture,             ( vout_thread_t *, subpicture_t * ) );
-VLC_EXPORT( int,  vout_RegisterSubpictureChannel, ( vout_thread_t * ) );
-VLC_EXPORT( void, vout_FlushSubpictureChannel,    ( vout_thread_t *, int ) );
+VLC_API void vout_PutSubpicture( vout_thread_t *, subpicture_t * );
+VLC_API int vout_RegisterSubpictureChannel( vout_thread_t * );
+VLC_API void vout_FlushSubpictureChannel( vout_thread_t *, int );
 
-VLC_EXPORT( void, vout_EnableFilter, ( vout_thread_t *, const char *,bool , bool  ) );
+VLC_API void vout_EnableFilter( vout_thread_t *, const char *,bool , bool  );
 
 /**@}*/
 

include/vlc_vout_display.h

@@ -411,7 +411,7 @@ static inline void vout_display_DeleteWindow(vout_display_t *vd,
  *
  * This asssumes that the picture is already cropped.
  */
-VLC_EXPORT( void, vout_display_GetDefaultDisplaySize, (unsigned *width, unsigned *height, const video_format_t *source, const vout_display_cfg_t *) );
+VLC_API void vout_display_GetDefaultDisplaySize(unsigned *width, unsigned *height, const video_format_t *source, const vout_display_cfg_t *);
 
 
 /**
@@ -434,7 +434,7 @@ typedef struct {
  * \param p_cfg Display configuration
  * \param b_clip If true, prevent the video to go outside the display (break zoom).
  */
-VLC_EXPORT( void, vout_display_PlacePicture, (vout_display_place_t *place, const video_format_t *source, const vout_display_cfg_t *cfg, bool do_clipping) );
+VLC_API void vout_display_PlacePicture(vout_display_place_t *place, const video_format_t *source, const vout_display_cfg_t *cfg, bool do_clipping);
 
 #endif /* VLC_VOUT_DISPLAY_H */
 

include/vlc_vout_osd.h

@@ -50,7 +50,7 @@ enum
 /**********************************************************************
  * Vout text and widget overlays
  **********************************************************************/
-VLC_EXPORT( int, vout_OSDEpg, ( vout_thread_t *, input_item_t * ) );
+VLC_API int vout_OSDEpg( vout_thread_t *, input_item_t * );
 
 /**
  * \brief Write an informative message if the OSD option is enabled.
@@ -60,7 +60,7 @@ VLC_EXPORT( int, vout_OSDEpg, ( vout_thread_t *, input_item_t * ) );
  * \param duration Duration of the text being displayed
  * \param text Text to be displayed
  */
-VLC_EXPORT( void,  vout_OSDText, ( vout_thread_t *vout, int channel, int position, mtime_t duration, const char *text ) );
+VLC_API void vout_OSDText( vout_thread_t *vout, int channel, int position, mtime_t duration, const char *text );
 
 /**
  * \brief Write an informative message at the default location,
@@ -71,7 +71,7 @@ VLC_EXPORT( void,  vout_OSDText, ( vout_thread_t *vout, int channel, int positio
  *
  * Provided for convenience.
  */
-VLC_EXPORT( void,  vout_OSDMessage, ( vout_thread_t *, int, const char *, ... ) LIBVLC_FORMAT( 3, 4 ) );
+VLC_API void vout_OSDMessage( vout_thread_t *, int, const char *, ... ) LIBVLC_FORMAT( 3, 4 );
 
 /**
  * Display a slider on the video output.
@@ -80,7 +80,7 @@ VLC_EXPORT( void,  vout_OSDMessage, ( vout_thread_t *, int, const char *, ... )
  * \param i_postion Current position in the slider
  * \param i_type    Types are: OSD_HOR_SLIDER and OSD_VERT_SLIDER.
  */
-VLC_EXPORT( void, vout_OSDSlider, ( vout_thread_t *, int, int , short ) );
+VLC_API void vout_OSDSlider( vout_thread_t *, int, int , short );
 
 /**
  * Display an Icon on the video output.
@@ -88,7 +88,7 @@ VLC_EXPORT( void, vout_OSDSlider, ( vout_thread_t *, int, int , short ) );
  * \param i_channel Subpicture channel
  * \param i_type    Types are: OSD_PLAY_ICON, OSD_PAUSE_ICON, OSD_SPEAKER_ICON, OSD_MUTE_ICON
  */
-VLC_EXPORT( void, vout_OSDIcon, ( vout_thread_t *, int, short ) );
+VLC_API void vout_OSDIcon( vout_thread_t *, int, short );
 
 #ifdef __cplusplus
 }

include/vlc_vout_window.h

@@ -121,14 +121,14 @@ struct vout_window_t {
  / vout_display_NewWindow() and vout_display_DeleteWindow() instead.
  * This enables recycling windows.
  */
-VLC_EXPORT( vout_window_t *, vout_window_New, (vlc_object_t *, const char *module, const vout_window_cfg_t *) );
+VLC_API vout_window_t * vout_window_New(vlc_object_t *, const char *module, const vout_window_cfg_t *);
 
 /**
  * Deletes a window created by vout_window_New().
  *
  * @note See vout_window_New() about window recycling.
  */
-VLC_EXPORT( void, vout_window_Delete, (vout_window_t *) );
+VLC_API void vout_window_Delete(vout_window_t *);
 
 
 /**
@@ -138,7 +138,7 @@ VLC_EXPORT( void, vout_window_Delete, (vout_window_t *) );
  *
  * @warning The caller must own the window, as vout_window_t is not thread safe.
  */
-VLC_EXPORT( int, vout_window_Control, (vout_window_t *, int query, ...) );
+VLC_API int vout_window_Control(vout_window_t *, int query, ...);
 
 /**
  * Configures the window manager state for this window.

include/vlc_vout_wrapper.h

@@ -72,27 +72,27 @@ typedef struct {
 /**
  * It creates a vout managed display.
  */
-VLC_EXPORT(vout_display_t *, vout_NewDisplay, ( vout_thread_t *, const video_format_t *, const vout_display_state_t *, const char *psz_module, mtime_t i_double_click_timeout, mtime_t i_hide_timeout ));
+VLC_API vout_display_t * vout_NewDisplay( vout_thread_t *, const video_format_t *, const vout_display_state_t *, const char *psz_module, mtime_t i_double_click_timeout, mtime_t i_hide_timeout );
 /**
  * It destroy a vout managed display.
  */
-VLC_EXPORT(void, vout_DeleteDisplay, (vout_display_t *, vout_display_state_t *));
+VLC_API void vout_DeleteDisplay(vout_display_t *, vout_display_state_t *);
 
-VLC_EXPORT(bool, vout_IsDisplayFiltered, (vout_display_t *));
-VLC_EXPORT(picture_t *, vout_FilterDisplay, (vout_display_t *, picture_t *));
-VLC_EXPORT(bool, vout_AreDisplayPicturesInvalid, (vout_display_t *));
+VLC_API bool vout_IsDisplayFiltered(vout_display_t *);
+VLC_API picture_t * vout_FilterDisplay(vout_display_t *, picture_t *);
+VLC_API bool vout_AreDisplayPicturesInvalid(vout_display_t *);
 
-VLC_EXPORT(void, vout_ManageDisplay, (vout_display_t *, bool allow_reset_pictures));
+VLC_API void vout_ManageDisplay(vout_display_t *, bool allow_reset_pictures);
 
-VLC_EXPORT(void, vout_SetDisplayFullscreen, (vout_display_t *, bool is_fullscreen));
-VLC_EXPORT(void, vout_SetDisplayFilled, (vout_display_t *, bool is_filled));
-VLC_EXPORT(void, vout_SetDisplayZoom, (vout_display_t *, int num, int den));
-VLC_EXPORT(void, vout_SetWindowState, (vout_display_t *, unsigned state));
-VLC_EXPORT(void, vout_SetDisplayAspect, (vout_display_t *, unsigned dar_num, unsigned dar_den));
-VLC_EXPORT(void, vout_SetDisplayCrop, (vout_display_t *, unsigned crop_num, unsigned crop_den, unsigned left, unsigned top, int right, int bottom));
+VLC_API void vout_SetDisplayFullscreen(vout_display_t *, bool is_fullscreen);
+VLC_API void vout_SetDisplayFilled(vout_display_t *, bool is_filled);
+VLC_API void vout_SetDisplayZoom(vout_display_t *, int num, int den);
+VLC_API void vout_SetWindowState(vout_display_t *, unsigned state);
+VLC_API void vout_SetDisplayAspect(vout_display_t *, unsigned dar_num, unsigned dar_den);
+VLC_API void vout_SetDisplayCrop(vout_display_t *, unsigned crop_num, unsigned crop_den, unsigned left, unsigned top, int right, int bottom);
 
 struct vlc_gl_t;
-VLC_EXPORT(struct vlc_gl_t *, vout_GetDisplayOpengl, (vout_display_t *));
+VLC_API struct vlc_gl_t * vout_GetDisplayOpengl(vout_display_t *);
 
 #endif /* VLC_VOUT_WRAPPER_H */
 

include/vlc_xml.h

@@ -46,9 +46,9 @@ struct xml_t
                             const char * );
 };
 
-VLC_EXPORT( xml_t *, xml_Create, ( vlc_object_t * ) LIBVLC_USED );
+VLC_API xml_t * xml_Create( vlc_object_t * ) LIBVLC_USED;
 #define xml_Create( a ) xml_Create( VLC_OBJECT(a) )
-VLC_EXPORT( void, xml_Delete, ( xml_t * ) );
+VLC_API void xml_Delete( xml_t * );
 
 static inline void xml_CatalogLoad( xml_t *xml, const char *catalog )
 {
@@ -76,10 +76,10 @@ struct xml_reader_t
     int (*pf_use_dtd) ( xml_reader_t * );
 };
 
-VLC_EXPORT( xml_reader_t *, xml_ReaderCreate, (vlc_object_t *, stream_t *) LIBVLC_USED );
+VLC_API xml_reader_t * xml_ReaderCreate(vlc_object_t *, stream_t *) LIBVLC_USED;
 #define xml_ReaderCreate( a, s ) xml_ReaderCreate(VLC_OBJECT(a), s)
-VLC_EXPORT( void, xml_ReaderDelete, (xml_reader_t *) );
-VLC_EXPORT( xml_reader_t *, xml_ReaderReset, (xml_reader_t *, stream_t *) LIBVLC_USED );
+VLC_API void xml_ReaderDelete(xml_reader_t *);
+VLC_API xml_reader_t * xml_ReaderReset(xml_reader_t *, stream_t *) LIBVLC_USED;
 
 static inline int xml_ReaderNextNode( xml_reader_t *reader, const char **pval )
 {

src/Makefile.am

@@ -553,24 +553,7 @@ stamp-revision:
 # Unit/regression test
 ###############################################################################
 
-dist_check_SCRIPTS = check_symbols check_headers
-TESTS = check_symbols
-
-check_DATA = libvlc-headers.sym libvlc-sorted.sym
-CLEANFILES += $(check_DATA)
-
-libvlc-sorted.sym: libvlccore.sym
-	rm -f libvlc-sorted.sym
-	sort -fdu < "$(srcdir)/libvlccore.sym" > libvlc-sorted.sym
-
-libvlc-headers.sym:
-	rm -f libvlc-headers.sym
-	cat ${srcdir}/../include/vlc_*.h ${srcdir}/control/*.h | \
-	sed -n -e 's/^[ ]*VLC_EXPORT[ ]*([^,]*,\([^,]*\),.*/\1/p' | \
-	sed -e 's/[^a-zA-Z0-9_]*//' | \
-	sort -fdu > libvlc-headers.sym
-
-.PHONY: libvlc-headers.sym
+dist_check_SCRIPTS = check_headers
 
 check-local:
 	for h in `echo $(pkginclude_HEADERS) | sed -e s,\.\./include/,,g`; \

src/check_symbols

-#! /bin/sh
-# Plugin API consistency check for VLC
-# Copyright © 2007 Rémi Denis-Courmont.
-
-if ! diff -u libvlc-headers.sym libvlc-sorted.sym; then
-	echo "Mismatching symbols found!"
-	exit 1
-fi
-
-# TODO: we should pass this:
-#if grep -e "^_" libvlc-headers.sym; then
-#	echo "Illegal symbol name (starting with underscore) found!";
-#	exit 1
-#fi

src/control/libvlc_internal.h

@@ -43,14 +43,14 @@
 /***************************************************************************
  * Internal creation and destruction functions
  ***************************************************************************/
-VLC_EXPORT (libvlc_int_t *, libvlc_InternalCreate, ( void ) );
-VLC_EXPORT (int, libvlc_InternalInit, ( libvlc_int_t *, int, const char *ppsz_argv[] ) );
-VLC_EXPORT (void, libvlc_InternalCleanup, ( libvlc_int_t * ) );
-VLC_EXPORT (void, libvlc_InternalDestroy, ( libvlc_int_t * ) );
-
-VLC_EXPORT (int, libvlc_InternalAddIntf, ( libvlc_int_t *, const char * ) );
-VLC_EXPORT (void, libvlc_InternalWait, ( libvlc_int_t * ) );
-VLC_EXPORT (void, libvlc_SetExitHandler, ( libvlc_int_t *, void (*) (void *), void * ) );
+VLC_API libvlc_int_t *libvlc_InternalCreate( void );
+VLC_API int libvlc_InternalInit( libvlc_int_t *, int, const char *ppsz_argv[] );
+VLC_API void libvlc_InternalCleanup( libvlc_int_t * );
+VLC_API void libvlc_InternalDestroy( libvlc_int_t * );
+
+VLC_API int libvlc_InternalAddIntf( libvlc_int_t *, const char * );
+VLC_API void libvlc_InternalWait( libvlc_int_t * );
+VLC_API void libvlc_SetExitHandler( libvlc_int_t *, void (*) (void *), void * );
 
 typedef void (*libvlc_vlm_release_func_t)( libvlc_instance_t * ) ;