/*****************************************************************************
- * common.h: common definitions
+ * vlc_common.h: common definitions
* Collection of useful common types and macros definitions
*****************************************************************************
- * Copyright (C) 1998-2011 the VideoLAN team
+ * Copyright (C) 1998-2011 VLC authors and VideoLAN
*
* 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
- * the Free Software Foundation; either version 2 of the License, or
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/**
# include <stdbool.h>
#endif
+/* Helper for GCC version checks */
+#ifdef __GNUC__
+# define VLC_GCC_VERSION(maj,min) \
+ ((__GNUC__ > (maj)) || (__GNUC__ == (maj) && __GNUC_MINOR__ >= (min)))
+#else
+# define VLC_GCC_VERSION(maj,min) (0)
+#endif
+
/* Try to fix format strings for all versions of mingw and mingw64 */
#if defined( _WIN32 ) && defined( __USE_MINGW_ANSI_STDIO )
#undef PRId64
#define PRIo64 "llo"
#undef PRIx64
#define PRIx64 "llx"
- #define snprintf __mingw_snprintf
- #define vsnprintf __mingw_vsnprintf
+ #define snprintf __mingw_snprintf
+ #define vsnprintf __mingw_vsnprintf
#endif
-/* Format string sanity checks */
+/* Function attributes for compiler warnings */
#ifdef __GNUC__
-# if defined( _WIN32 ) && (__GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 4 ) )
-# define VLC_FORMAT(x,y) __attribute__ ((format(gnu_printf,x,y)))
-# else
-# define VLC_FORMAT(x,y) __attribute__ ((format(printf,x,y)))
-# endif
-# define VLC_FORMAT_ARG(x) __attribute__ ((format_arg(x)))
-# if __GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ >= 4))
-# define VLC_USED __attribute__ ((warn_unused_result))
-# else
-# define VLC_USED
-# endif
-# define VLC_MALLOC __attribute__ ((malloc))
+# define VLC_DEPRECATED __attribute__((deprecated))
+
+# if defined( _WIN32 ) && VLC_GCC_VERSION(4,4)
+# define VLC_FORMAT(x,y) __attribute__ ((format(gnu_printf,x,y)))
+# else
+# define VLC_FORMAT(x,y) __attribute__ ((format(printf,x,y)))
+# endif
+# define VLC_FORMAT_ARG(x) __attribute__ ((format_arg(x)))
+
+# define VLC_MALLOC __attribute__ ((malloc))
+# define VLC_NORETURN __attribute__ ((noreturn))
+
+# if VLC_GCC_VERSION(3,4)
+# define VLC_USED __attribute__ ((warn_unused_result))
+# else
+# define VLC_USED
+# endif
+
#else
-# define VLC_FORMAT(x,y)
-# define VLC_FORMAT_ARG(x)
-# define VLC_USED
-# define VLC_MALLOC
+# define VLC_DEPRECATED
+# define VLC_FORMAT(x,y)
+# define VLC_FORMAT_ARG(x)
+# define VLC_MALLOC
+# define VLC_NORETURN
+# define VLC_USED
#endif
+
/* Branch prediction */
#ifdef __GNUC__
# define likely(p) __builtin_expect(!!(p), 1)
# define unlikely(p) (!!(p))
#endif
-#if defined(__GNUC__) && !defined __cplusplus
-# define VLC_DEPRECATED __attribute__((deprecated))
-#else
-# define VLC_DEPRECATED
-#endif
-
/* Linkage */
#ifdef __cplusplus
# define VLC_EXTERN extern "C"
#if defined (WIN32) && defined (DLL_EXPORT)
# define VLC_EXPORT __declspec(dllexport)
-#elif defined (__GNUC__) && (__GNUC__ >= 4)
+#elif VLC_GCC_VERSION(4,0)
# define VLC_EXPORT __attribute__((visibility("default")))
#else
# define VLC_EXPORT
#include <sys/syslimits.h>
#endif
-/* Counter for statistics and profiling */
-typedef unsigned long count_t;
-
/* Audio volume */
typedef uint16_t audio_volume_t;
typedef struct video_palette_t video_palette_t;
/* Audio */
-typedef struct aout_instance_t aout_instance_t;
+typedef struct audio_output audio_output_t;
typedef struct aout_sys_t aout_sys_t;
typedef struct aout_fifo_t aout_fifo_t;
typedef struct aout_input_t aout_input_t;
typedef struct block_t aout_buffer_t;
typedef audio_format_t audio_sample_format_t;
-typedef struct aout_filter_t aout_filter_t;
/* Video */
typedef struct vout_thread_t vout_thread_t;
typedef struct httpd_redirect_t httpd_redirect_t;
typedef struct httpd_stream_t httpd_stream_t;
-/* TLS support */
-typedef struct tls_server_t tls_server_t;
-typedef struct tls_session_t tls_session_t;
-
/* Hashing */
typedef struct md5_s md5_t;
/* misc */
typedef struct vlc_meta_t vlc_meta_t;
-
-/* Stats */
-typedef struct counter_t counter_t;
-typedef struct counter_sample_t counter_sample_t;
-typedef struct stats_handler_t stats_handler_t;
typedef struct input_stats_t input_stats_t;
/* Update */
/* stat/lstat/fstat */
#ifdef WIN32
-#include <sys/stat.h>
+# include <sys/stat.h>
# ifndef UNDER_CE
struct _stati64;
-#define stat _stati64
-#define fstat _fstati64
+# define stat _stati64
+# define fstat _fstati64
#endif
/* You should otherwise use vlc_stat and vlc_lstat. */
};
-/**
- * \defgroup var_type Variable types
- * These are the different types a vlc variable can have.
- * @{
- */
-#define VLC_VAR_VOID 0x0010
-#define VLC_VAR_BOOL 0x0020
-#define VLC_VAR_INTEGER 0x0030
-#define VLC_VAR_HOTKEY 0x0031
-#define VLC_VAR_STRING 0x0040
-#define VLC_VAR_VARIABLE 0x0044
-#define VLC_VAR_FLOAT 0x0050
-#define VLC_VAR_TIME 0x0060
-#define VLC_VAR_ADDRESS 0x0070
-#define VLC_VAR_MUTEX 0x0080
-#define VLC_VAR_COORDS 0x00A0
-/**@}*/
-
/*****************************************************************************
* Error values (shouldn't be exposed)
*****************************************************************************/
* OS-specific headers and thread types
*****************************************************************************/
#if defined( WIN32 ) || defined( UNDER_CE )
-# define WIN32_LEAN_AND_MEAN
-# include <windows.h>
+/* WIN32_LEAN_AND_MEAN is needed to be able to include winsock2.h because else,
+ * windows.h will also include winsock.h and declarations will conflict */
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#endif
+
+#ifdef __OS2__
+# define OS2EMX_PLAIN_CHAR
+# define INCL_BASE
+# define INCL_PM
+# include <os2.h>
#endif
#include "vlc_mtime.h"
/**@}*/ \
/* VLC_OBJECT: attempt at doing a clever cast */
-#if defined( __GNUC__ ) && __GNUC__ > 3
+#if VLC_GCC_VERSION(4,0)
# ifndef __cplusplus
# define VLC_OBJECT( x ) \
__builtin_choose_expr( \
# define __MIN(a, b) ( ((a) < (b)) ? (a) : (b) )
#endif
+/* clip v in [min, max] */
+#define VLC_CLIP(v, min, max) __MIN(__MAX((v), (min)), (max))
+
VLC_USED
static inline int64_t GCD ( int64_t a, int64_t b )
{
else return a;
}
-/* Count leading zeroes */
+/** Count leading zeroes */
VLC_USED
static inline unsigned clz (unsigned x)
{
-#ifdef __GNUC_
+#if VLC_GCC_VERSION(3,4)
return __builtin_clz (x);
#else
unsigned i = sizeof (x) * 8;
/* XXX: this assumes that int is 32-bits or more */
#define clz32( x ) (clz(x) - ((sizeof(unsigned) - sizeof (uint32_t)) * 8))
-/* Bit weight */
+/** Bit weight */
VLC_USED
static inline unsigned popcount (unsigned x)
{
-#ifdef __GNUC_
+#if VLC_GCC_VERSION(3,4)
return __builtin_popcount (x);
#else
unsigned count = 0;
#endif
}
+#ifdef __OS2__
+# undef bswap16
+# undef bswap32
+# undef bswap64
+#endif
+
+/** Byte swap (16 bits) */
+VLC_USED
+static inline uint16_t bswap16 (uint16_t x)
+{
+ return (x << 8) | (x >> 8);
+}
+
+/** Byte swap (32 bits) */
+VLC_USED
+static inline uint32_t bswap32 (uint32_t x)
+{
+#if VLC_GCC_VERSION(4,3)
+ return __builtin_bswap32 (x);
+#else
+ return ((x & 0x000000FF) << 24)
+ | ((x & 0x0000FF00) << 8)
+ | ((x & 0x00FF0000) >> 8)
+ | ((x & 0xFF000000) >> 24);
+#endif
+}
+
+/** Byte swap (64 bits) */
+VLC_USED
+static inline uint64_t bswap64 (uint64_t x)
+{
+#if VLC_GCC_VERSION(4,3)
+ return __builtin_bswap64 (x);
+#elif !defined (__cplusplus)
+ return ((x & 0x00000000000000FF) << 56)
+ | ((x & 0x000000000000FF00) << 40)
+ | ((x & 0x0000000000FF0000) << 24)
+ | ((x & 0x00000000FF000000) << 8)
+ | ((x & 0x000000FF00000000) >> 8)
+ | ((x & 0x0000FF0000000000) >> 24)
+ | ((x & 0x00FF000000000000) >> 40)
+ | ((x & 0xFF00000000000000) >> 56);
+#else
+ return ((x & 0x00000000000000FFLLU) << 56)
+ | ((x & 0x000000000000FF00LLU) << 40)
+ | ((x & 0x0000000000FF0000LLU) << 24)
+ | ((x & 0x00000000FF000000LLU) << 8)
+ | ((x & 0x000000FF00000000LLU) >> 8)
+ | ((x & 0x0000FF0000000000LLU) >> 24)
+ | ((x & 0x00FF000000000000LLU) >> 40)
+ | ((x & 0xFF00000000000000LLU) >> 56);
+#endif
+}
+
+
/* Free and set set the variable to NULL */
#define FREENULL(a) do { free( a ); a = NULL; } while(0)
/* MSB (big endian)/LSB (little endian) conversions - network order is always
* MSB, and should be used for both network communications and files. */
+
+#ifdef WORDS_BIGENDIAN
+# define hton16(i) ((uint16_t)(i))
+# define hton32(i) ((uint32_t)(i))
+# define hton64(i) ((uint64_t)(i))
+#else
+# define hton16(i) bswap16(i)
+# define hton32(i) bswap32(i)
+# define hton64(i) bswap64(i)
+#endif
+#define ntoh16(i) hton16(i)
+#define ntoh32(i) hton32(i)
+#define ntoh64(i) hton64(i)
+
+/** Reads 16 bits in network byte order */
VLC_USED
-static inline uint16_t U16_AT( const void * _p )
+static inline uint16_t U16_AT (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint16_t)p[0] << 8) | p[1] );
+ uint16_t x;
+
+ memcpy (&x, p, sizeof (x));
+ return ntoh16 (x);
}
+/** Reads 32 bits in network byte order */
VLC_USED
-static inline uint32_t U32_AT( const void * _p )
+static inline uint32_t U32_AT (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16)
- | ((uint32_t)p[2] << 8) | p[3] );
+ uint32_t x;
+
+ memcpy (&x, p, sizeof (x));
+ return ntoh32 (x);
}
+/** Reads 64 bits in network byte order */
VLC_USED
-static inline uint64_t U64_AT( const void * _p )
+static inline uint64_t U64_AT (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48)
- | ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32)
- | ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16)
- | ((uint64_t)p[6] << 8) | p[7] );
+ uint64_t x;
+
+ memcpy (&x, p, sizeof (x));
+ return ntoh64 (x);
}
+#define GetWBE(p) U16_AT(p)
+#define GetDWBE(p) U32_AT(p)
+#define GetQWBE(p) U64_AT(p)
+
+/** Reads 16 bits in little-endian order */
VLC_USED
-static inline uint16_t GetWLE( const void * _p )
+static inline uint16_t GetWLE (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint16_t)p[1] << 8) | p[0] );
+ uint16_t x;
+
+ memcpy (&x, p, sizeof (x));
+#ifdef WORDS_BIGENDIAN
+ x = bswap16 (x);
+#endif
+ return x;
}
+/** Reads 32 bits in little-endian order */
VLC_USED
-static inline uint32_t GetDWLE( const void * _p )
+static inline uint32_t GetDWLE (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint32_t)p[3] << 24) | ((uint32_t)p[2] << 16)
- | ((uint32_t)p[1] << 8) | p[0] );
+ uint32_t x;
+
+ memcpy (&x, p, sizeof (x));
+#ifdef WORDS_BIGENDIAN
+ x = bswap32 (x);
+#endif
+ return x;
}
+/** Reads 64 bits in little-endian order */
VLC_USED
-static inline uint64_t GetQWLE( const void * _p )
+static inline uint64_t GetQWLE (const void *p)
{
- const uint8_t * p = (const uint8_t *)_p;
- return ( ((uint64_t)p[7] << 56) | ((uint64_t)p[6] << 48)
- | ((uint64_t)p[5] << 40) | ((uint64_t)p[4] << 32)
- | ((uint64_t)p[3] << 24) | ((uint64_t)p[2] << 16)
- | ((uint64_t)p[1] << 8) | p[0] );
-}
+ uint64_t x;
-#define GetWBE( p ) U16_AT( p )
-#define GetDWBE( p ) U32_AT( p )
-#define GetQWBE( p ) U64_AT( p )
-
-/* Helper writer functions */
-#define SetWLE( p, v ) _SetWLE( (uint8_t*)(p), v)
-static inline void _SetWLE( uint8_t *p, uint16_t i_dw )
-{
- p[1] = ( i_dw >> 8 )&0xff;
- p[0] = ( i_dw )&0xff;
+ memcpy (&x, p, sizeof (x));
+#ifdef WORDS_BIGENDIAN
+ x = bswap64 (x);
+#endif
+ return x;
}
-#define SetDWLE( p, v ) _SetDWLE( (uint8_t*)(p), v)
-static inline void _SetDWLE( uint8_t *p, uint32_t i_dw )
+/** Writes 16 bits in network byte order */
+static inline void SetWBE (void *p, uint16_t w)
{
- p[3] = ( i_dw >> 24 )&0xff;
- p[2] = ( i_dw >> 16 )&0xff;
- p[1] = ( i_dw >> 8 )&0xff;
- p[0] = ( i_dw )&0xff;
+ w = hton16 (w);
+ memcpy (p, &w, sizeof (w));
}
-#define SetQWLE( p, v ) _SetQWLE( (uint8_t*)(p), v)
-static inline void _SetQWLE( uint8_t *p, uint64_t i_qw )
+
+/** Writes 32 bits in network byte order */
+static inline void SetDWBE (void *p, uint32_t dw)
{
- SetDWLE( p, i_qw&0xffffffff );
- SetDWLE( p+4, ( i_qw >> 32)&0xffffffff );
+ dw = hton32 (dw);
+ memcpy (p, &dw, sizeof (dw));
}
-#define SetWBE( p, v ) _SetWBE( (uint8_t*)(p), v)
-static inline void _SetWBE( uint8_t *p, uint16_t i_dw )
+
+/** Writes 64 bits in network byte order */
+static inline void SetQWBE (void *p, uint64_t qw)
{
- p[0] = ( i_dw >> 8 )&0xff;
- p[1] = ( i_dw )&0xff;
+ qw = hton64 (qw);
+ memcpy (p, &qw, sizeof (qw));
}
-#define SetDWBE( p, v ) _SetDWBE( (uint8_t*)(p), v)
-static inline void _SetDWBE( uint8_t *p, uint32_t i_dw )
+/** Writes 16 bits in little endian order */
+static inline void SetWLE (void *p, uint16_t w)
{
- p[0] = ( i_dw >> 24 )&0xff;
- p[1] = ( i_dw >> 16 )&0xff;
- p[2] = ( i_dw >> 8 )&0xff;
- p[3] = ( i_dw )&0xff;
+#ifdef WORDS_BIGENDIAN
+ w = bswap16 (w);
+#endif
+ memcpy (p, &w, sizeof (w));
}
-#define SetQWBE( p, v ) _SetQWBE( (uint8_t*)(p), v)
-static inline void _SetQWBE( uint8_t *p, uint64_t i_qw )
+
+/** Writes 32 bits in little endian order */
+static inline void SetDWLE (void *p, uint32_t dw)
{
- SetDWBE( p+4, i_qw&0xffffffff );
- SetDWBE( p, ( i_qw >> 32)&0xffffffff );
+#ifdef WORDS_BIGENDIAN
+ dw = bswap32 (dw);
+#endif
+ memcpy (p, &dw, sizeof (dw));
}
-#define hton16(i) htons(i)
-#define hton32(i) htonl(i)
-#define ntoh16(i) ntohs(i)
-#define ntoh32(i) ntohl(i)
-
-VLC_USED
-static inline uint64_t ntoh64 (uint64_t ll)
+/** Writes 64 bits in little endian order */
+static inline void SetQWLE (void *p, uint64_t qw)
{
- union { uint64_t qw; uint8_t b[16]; } v = { ll };
- return ((uint64_t)v.b[0] << 56)
- | ((uint64_t)v.b[1] << 48)
- | ((uint64_t)v.b[2] << 40)
- | ((uint64_t)v.b[3] << 32)
- | ((uint64_t)v.b[4] << 24)
- | ((uint64_t)v.b[5] << 16)
- | ((uint64_t)v.b[6] << 8)
- | ((uint64_t)v.b[7] << 0);
+#ifdef WORDS_BIGENDIAN
+ qw = bswap64 (qw);
+#endif
+ memcpy (p, &qw, sizeof (qw));
}
-#define hton64(i) ntoh64(i)
/* */
#define VLC_UNUSED(x) (void)(x)
# endif
# endif
-# if defined( _MSC_VER ) && !defined( __WXMSW__ )
+# if defined( _MSC_VER )
# if !defined( _OFF_T_DEFINED )
typedef __int64 off_t;
# define _OFF_T_DEFINED
VLC_API bool vlc_ureduce( unsigned *, unsigned *, uint64_t, uint64_t, uint64_t );
-VLC_API void * vlc_memalign( void **base, size_t alignment, size_t size ) VLC_USED;
+/* Aligned memory allocator */
+#ifdef __APPLE__
+#include <AvailabilityMacros.h>
+#endif
+
+#ifdef WIN32
+# include <malloc.h>
+# define vlc_memalign(align, size) (__mingw_aligned_malloc(size, align))
+# define vlc_free(base) (__mingw_aligned_free(base))
+#elif defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_6)
+static inline void *vlc_memalign(size_t align, size_t size)
+{
+ long diff;
+ void *ptr;
+
+ ptr = malloc(size+align);
+ if(!ptr)
+ return ptr;
+ diff = ((-(long)ptr - 1)&(align-1)) + 1;
+ ptr = (char*)ptr + diff;
+ ((char*)ptr)[-1]= diff;
+ return ptr;
+}
-/* execve wrapper (defined in src/extras/libc.c) */
-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 ) VLC_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)
+static void vlc_free(void *ptr)
+{
+ if (ptr)
+ free((char*)ptr - ((char*)ptr)[-1]);
+}
+#elif defined(__ANDROID__)
+# define vlc_memalign(align, size) memalign(align, size)
+# define vlc_free(base) free(base)
+#else
+static inline void *vlc_memalign(size_t align, size_t size)
+{
+ void *base;
+ if (unlikely(posix_memalign(&base, align, size)))
+ base = NULL;
+ return base;
+}
+# define vlc_free(base) free(base)
+#endif
VLC_API void vlc_tdestroy( void *, void (*)(void *) );
/* Fast large memory copy and memory set */
VLC_API void * vlc_memcpy( void *, const void *, size_t );
-VLC_API void * vlc_memset( void *, int, size_t );
+#define vlc_memset memset
/*****************************************************************************
* I18n stuff
return nptr;
}
+static inline void *xcalloc (size_t n, size_t size)
+{
+ void *ptr = calloc (n, size);
+ if (unlikely (ptr == NULL))
+ abort ();
+ return ptr;
+}
+
/*****************************************************************************
* libvlc features
*****************************************************************************/