* 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; \
# 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
* 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
* 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
* 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
* 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)
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
}
/* 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)
{
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
* 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)
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)
{
* 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 */
/* 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
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
* 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 */
/*****************************************************************************
* 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 );
* 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
# 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
*****************************************************************************/
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
*****************************************************************************/
*/
#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 )
#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>
# 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 )
/*****************************************************************************
* 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
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 )
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 )
* 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
{
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)
*
* 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 )
/**
*
* 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
* 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
*
* 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
}
# 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.
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 */
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
* 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 { \
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, ...)
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__)
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)
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))
*
* 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
* 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
/**
* 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
*
* 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
#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 */
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 */
* 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
* \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 )
/**
*
* \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
* \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.
* \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.
* \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
* \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.
* \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.
* \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.
* \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.
* \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.
* \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.
* \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.
*
* 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 */
*
* 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
*
* 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.
* 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
*
* 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
*
* 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.
* 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 <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
# 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
} 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 */
};
/* 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 */
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 )
#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
}
* 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
* 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.
}
/* */
-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.
* 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.
* 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
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
*
* 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.
*
* 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 );
/**
/**
* 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 \
#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.
* 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)
/**
/**
* 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;
/******************
/*****************************************************************************
* 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 * );
/*@}*/
#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
#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,
} 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
{
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
* @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) )
/**
* @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
* @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 */
* @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
* @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
* @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 )
* @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 );
* @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 );
/**
* @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 );
/**
/*****************************************************************************
* 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, ... ) \
*/
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)
/*********
* 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 )
/**
*/
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,
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)
* 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)
{
/*****************************************************************************
* 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 */
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_ */
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" {
/* 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)
}
#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)
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)
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
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
# 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
/*****************************************************************************
* 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))
/**}@*/
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) )
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)
{
* 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
* 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 )
/**
* 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)
* 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.
* 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) )
* 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
* 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
* 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
* 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) )
* 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) )
* 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 );
/** @} */
* 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.
* 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.
*
* 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.
* 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.
* 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.
* - 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
*
* 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 );
/**
* - 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 * );
/*****************************************************************************
/**
* 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
*
* 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
*
* 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 */
* 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.
* 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
* 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
* 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 */
#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 */
#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.
* \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
* \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, ... );
********************************************************/
/*************************** 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
* 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__)
* 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
/* 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
}
/* 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() \
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 )
{
};
-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, ... )
{
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 )
{
* 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) \
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
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.
* 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
*
* 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 * );
/** @}*/
* @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 )
* @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 ) )
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
* 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 )
* 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 );
/**
* @}
*/
* @{
*/
-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 * );
/**
* @}
*
* 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
*
* 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
*
* 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 );
/**
*
*
* 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
* 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 );
/**@}*/
/**
* 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
}
/*****************************************************************************
* 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 {
};
#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)
/**
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 )
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 ))
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 * );
/**
* @}
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:
/*****************************************************************************
* 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 * );
/*****************************************************************************
* 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 )
}
#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)
#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)
/**
}
/* */
-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 )
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 */
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 );
* \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)
/**
*
* \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
* 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 );
/**@}*/
*
* 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 *);
/**
* \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 */
/**********************************************************************
* 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.
* \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,
*
* 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.
* \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.
* \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
}
/ 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 *);
/**
*
* @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.
/**
* 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 */
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 )
{
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 )
{
# 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`; \
+++ /dev/null
-#! /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
/***************************************************************************
* 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 * ) ;
projects / vlc / commitdiff