videolan
/
vlc
mirror of https://gitea.goldendeliverer.com/videolan/vlc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Replace VLC_EXPORT macro with a simple prefix, VLC_API 

This should help Doxygen parse VLC headers, and generally makes headers
easier to read. LibVLC already uses a similar approach.
pull/2/head
Rémi Denis-Courmont 15 years ago
parent
9a46b63e12
commit
6f258887aa
69 changed files with 741 additions and 775 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      include/vlc_access.h
  2. 12
      include/vlc_acl.h
  3. 46
      include/vlc_aout.h
  4. 10
      include/vlc_atomic.h
  5. 30
      include/vlc_block.h
  6. 40
      include/vlc_charset.h
  7. 22
      include/vlc_codec.h
  8. 18
      include/vlc_codec_synchro.h
  9. 70
      include/vlc_common.h
  10. 4
      include/vlc_config_cat.h
  11. 48
      include/vlc_configuration.h
  12. 6
      include/vlc_cpu.h
  13. 8
      include/vlc_demux.h
  14. 18
      include/vlc_dialog.h
  15. 14
      include/vlc_epg.h
  16. 22
      include/vlc_es.h
  17. 31
      include/vlc_events.h
  18. 2
      include/vlc_extensions.h
  19. 38
      include/vlc_filter.h
  20. 18
      include/vlc_fourcc.h
  21. 30
      include/vlc_fs.h
  22. 16
      include/vlc_http.h
  23. 46
      include/vlc_httpd.h
  24. 10
      include/vlc_image.h
  25. 34
      include/vlc_input.h
  26. 58
      include/vlc_input_item.h
  27. 6
      include/vlc_interface.h
  28. 6
      include/vlc_iso_lang.h
  29. 6
      include/vlc_keys.h
  30. 6
      include/vlc_md5.h
  31. 34
      include/vlc_media_library.h
  32. 26
      include/vlc_messages.h
  33. 26
      include/vlc_meta.h
  34. 38
      include/vlc_modules.h
  35. 26
      include/vlc_mtime.h
  36. 40
      include/vlc_network.h
  37. 18
      include/vlc_objects.h
  38. 4
      include/vlc_opengl.h
  39. 32
      include/vlc_osd.h
  40. 20
      include/vlc_picture.h
  41. 14
      include/vlc_picture_fifo.h
  42. 16
      include/vlc_picture_pool.h
  43. 76
      include/vlc_playlist.h
  44. 2
      include/vlc_plugin.h
  45. 8
      include/vlc_rand.h
  46. 20
      include/vlc_services_discovery.h
  47. 42
      include/vlc_sout.h
  48. 16
      include/vlc_spu.h
  49. 6
      include/vlc_sql.h
  50. 24
      include/vlc_stream.h
  51. 24
      include/vlc_strings.h
  52. 14
      include/vlc_subpicture.h
  53. 8
      include/vlc_text_style.h
  54. 88
      include/vlc_threads.h
  55. 4
      include/vlc_tls.h
  56. 12
      include/vlc_update.h
  57. 10
      include/vlc_url.h
  58. 34
      include/vlc_variables.h
  59. 4
      include/vlc_video_splitter.h
  60. 20
      include/vlc_vlm.h
  61. 28
      include/vlc_vout.h
  62. 4
      include/vlc_vout_display.h
  63. 10
      include/vlc_vout_osd.h
  64. 6
      include/vlc_vout_window.h
  65. 26
      include/vlc_vout_wrapper.h
  66. 10
      include/vlc_xml.h
  67. 19
      src/Makefile.am
  68. 14
      src/check_symbols
  69. 16
      src/control/libvlc_internal.h

2
include/vlc_access.h
View File

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

12
include/vlc_acl.h
View File

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

46
include/vlc_aout.h
View File

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

10
include/vlc_atomic.h
View File

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

30
include/vlc_block.h
View File

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

40
include/vlc_charset.h
View File

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

22
include/vlc_codec.h
View File

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

18
include/vlc_codec_synchro.h
View File

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

70
include/vlc_common.h
View File

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

4
include/vlc_config_cat.h
View File

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

48
include/vlc_configuration.h
View File

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

6
include/vlc_cpu.h
View File

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

8
include/vlc_demux.h
View File

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

18
include/vlc_dialog.h
View File

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

14
include/vlc_epg.h
View File

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

22
include/vlc_es.h
View File

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

31
include/vlc_events.h
View File

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

2
include/vlc_extensions.h
View File

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

38
include/vlc_filter.h
View File

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

18
include/vlc_fourcc.h
View File

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

30
include/vlc_fs.h
View File

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

16
include/vlc_http.h
View File

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

46
include/vlc_httpd.h
View File

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

10
include/vlc_image.h
View File

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

34
include/vlc_input.h
View File

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

58
include/vlc_input_item.h
View File

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

6
include/vlc_interface.h
View File

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

6
include/vlc_iso_lang.h
View File

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

6
include/vlc_keys.h
View File

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

6
include/vlc_md5.h
View File

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

34
include/vlc_media_library.h
View File

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

26
include/vlc_messages.h
View File

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

26
include/vlc_meta.h
View File

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

38
include/vlc_modules.h
View File

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

26
include/vlc_mtime.h
View File

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

40
include/vlc_network.h
View File

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

18
include/vlc_objects.h
View File

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

4
include/vlc_opengl.h
View File

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

32
include/vlc_osd.h
View File

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

20
include/vlc_picture.h
View File

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

14
include/vlc_picture_fifo.h
View File

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

16
include/vlc_picture_pool.h
View File

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

76
include/vlc_playlist.h
View File

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

2
include/vlc_plugin.h
View File

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

8
include/vlc_rand.h
View File

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

20
include/vlc_services_discovery.h
View File

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

42
include/vlc_sout.h
View File

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

16
include/vlc_spu.h
View File

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

6
include/vlc_sql.h
View File

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

24
include/vlc_stream.h
View File

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

24
include/vlc_strings.h
View File

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

14
include/vlc_subpicture.h
View File

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

8
include/vlc_text_style.h
View File

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

88
include/vlc_threads.h
View File

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

4
include/vlc_tls.h
View File

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

12
include/vlc_update.h
View File

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

10
include/vlc_url.h
View File

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

34
include/vlc_variables.h
View File

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

4
include/vlc_video_splitter.h
View File

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

20
include/vlc_vlm.h
View File

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

28
include/vlc_vout.h
View File

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

4
include/vlc_vout_display.h
View File

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

10
include/vlc_vout_osd.h
View File

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

6
include/vlc_vout_window.h
View File

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

26
include/vlc_vout_wrapper.h
View File

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

10
include/vlc_xml.h
View File

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

19
src/Makefile.am
View File

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

14
src/check_symbols
View File

@ -1,14 +0,0 @@
#! /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

16
src/control/libvlc_internal.h
View File

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

Write Preview
Loading…
Cancel
Save