and mipspro doesn't know about __inline__).
* Collection of useful common types and macros definitions
*****************************************************************************
* Copyright (C) 1998, 1999, 2000 VideoLAN
- * $Id: common.h,v 1.106 2002/05/15 13:07:18 marcari Exp $
+ * $Id: common.h,v 1.107 2002/05/18 17:47:46 sam Exp $
*
* Authors: Samuel Hocevar <sam@via.ecp.fr>
* Vincent Seguin <seguin@via.ecp.fr>
#else
# define hton16 htons
# define hton32 htonl
- static __inline__ u64 __hton64( u64 i )
+ static inline u64 __hton64( u64 i )
{
return ((u64)(htonl((i) & 0xffffffff)) << 32)
| htonl(((i) >> 32) & 0xffffffff );
* input_ext-dec.h: structures exported to the VideoLAN decoders
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: input_ext-dec.h,v 1.57 2002/05/13 21:55:30 fenrir Exp $
+ * $Id: input_ext-dec.h,v 1.58 2002/05/18 17:47:46 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
* Michel Kaempf <maxx@via.ecp.fr>
* on a word boundary (XXX: there must be at least sizeof(WORD_TYPE) - 1
* empty bytes in the bit buffer)
*****************************************************************************/
-static __inline__ void AlignWord( bit_stream_t * p_bit_stream )
+static inline void AlignWord( bit_stream_t * p_bit_stream )
{
while( (ptrdiff_t)p_bit_stream->p_byte
& (sizeof(WORD_TYPE) - 1) )
/*****************************************************************************
* ShowBits : return i_bits bits from the bit stream
*****************************************************************************/
-static __inline__ u32 ShowBits( bit_stream_t * p_bit_stream,
- unsigned int i_bits )
+static inline u32 ShowBits( bit_stream_t * p_bit_stream,
+ unsigned int i_bits )
{
if( p_bit_stream->fifo.i_available >= i_bits )
{
* ShowSignedBits : return i_bits bits from the bit stream, using signed
* arithmetic
*****************************************************************************/
-static __inline__ s32 ShowSignedBits( bit_stream_t * p_bit_stream,
- unsigned int i_bits )
+static inline s32 ShowSignedBits( bit_stream_t * p_bit_stream,
+ unsigned int i_bits )
{
if( p_bit_stream->fifo.i_available >= i_bits )
{
* RemoveBits : removes i_bits bits from the bit buffer
* XXX: do not use for 32 bits, see RemoveBits32
*****************************************************************************/
-static __inline__ void RemoveBits( bit_stream_t * p_bit_stream,
- unsigned int i_bits )
+static inline void RemoveBits( bit_stream_t * p_bit_stream,
+ unsigned int i_bits )
{
p_bit_stream->fifo.i_available -= i_bits;
* refill it)
*****************************************************************************/
#if (WORD_TYPE == u32)
-static __inline__ void RemoveBits32( bit_stream_t * p_bit_stream )
+static inline void RemoveBits32( bit_stream_t * p_bit_stream )
{
if( p_bit_stream->p_byte <= p_bit_stream->p_end - sizeof(WORD_TYPE) )
{
* GetBits : returns i_bits bits from the bit stream and removes them
* XXX: do not use for 32 bits, see GetBits32
*****************************************************************************/
-static __inline__ u32 GetBits( bit_stream_t * p_bit_stream,
- unsigned int i_bits )
+static inline u32 GetBits( bit_stream_t * p_bit_stream,
+ unsigned int i_bits )
{
u32 i_result;
* using signed arithmetic
* XXX: do not use for 32 bits
*****************************************************************************/
-static __inline__ s32 GetSignedBits( bit_stream_t * p_bit_stream,
- unsigned int i_bits )
+static inline s32 GetSignedBits( bit_stream_t * p_bit_stream,
+ unsigned int i_bits )
{
if( p_bit_stream->fifo.i_available >= i_bits )
{
* GetBits32 : returns 32 bits from the bit stream and removes them
*****************************************************************************/
#if (WORD_TYPE == u32)
-static __inline__ u32 GetBits32( bit_stream_t * p_bit_stream )
+static inline u32 GetBits32( bit_stream_t * p_bit_stream )
{
u32 i_result;
/*****************************************************************************
* RealignBits : realigns the bit buffer on an 8-bit boundary
*****************************************************************************/
-static __inline__ void RealignBits( bit_stream_t * p_bit_stream )
+static inline void RealignBits( bit_stream_t * p_bit_stream )
{
p_bit_stream->fifo.buffer <<= (p_bit_stream->fifo.i_available & 0x7);
p_bit_stream->fifo.i_available &= ~0x7;
* RealignBits(). p_buffer must point to a buffer at least as big as i_buf_len
* otherwise your code will crash.
*****************************************************************************/
-static __inline__ void GetChunk( bit_stream_t * p_bit_stream,
- byte_t * p_buffer, size_t i_buf_len )
+static inline void GetChunk( bit_stream_t * p_bit_stream,
+ byte_t * p_buffer, size_t i_buf_len )
{
ptrdiff_t i_available;
* but exported to plug-ins
*****************************************************************************
* Copyright (C) 1999-2002 VideoLAN
- * $Id: input_ext-plugins.h,v 1.27 2002/05/15 13:07:18 marcari Exp $
+ * $Id: input_ext-plugins.h,v 1.28 2002/05/18 17:47:46 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
/*****************************************************************************
* Create a NULL packet for padding in case of a data loss
*****************************************************************************/
-static __inline__ void input_NullPacket( input_thread_t * p_input,
- es_descriptor_t * p_es )
+static inline void input_NullPacket( input_thread_t * p_input,
+ es_descriptor_t * p_es )
{
data_packet_t * p_pad_data;
pes_packet_t * p_pes;
* readv_*: readv() replacements for iovec-impaired C libraries
*****************************************************************************/
#if defined( WIN32 )
-static __inline__ int readv( int i_fd, struct iovec *p_iovec, int i_count )
+static inline int readv( int i_fd, struct iovec *p_iovec, int i_count )
{
int i_index, i_len, i_total = 0;
unsigned char *p_base;
* modules.h : Module management functions.
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: modules.h,v 1.49 2002/05/15 00:02:27 sam Exp $
+ * $Id: modules.h,v 1.50 2002/05/18 17:47:46 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
/*****************************************************************************
* Module capabilities.
*****************************************************************************/
-static __inline__ char *GetCapabilityName( unsigned int i_capa )
+static inline char *GetCapabilityName( unsigned int i_capa )
{
/* The sole purpose of this inline function and the ugly #defines
* around it is to avoid having two places to modify when adding a
* This header provides a portable threads implementation.
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: threads_funcs.h,v 1.2 2002/04/29 23:57:38 massiot Exp $
+ * $Id: threads_funcs.h,v 1.3 2002/05/18 17:47:46 sam Exp $
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@via.ecp.fr>
/*****************************************************************************
* vlc_threads_init: initialize threads system
*****************************************************************************/
-static __inline__ int vlc_threads_init( void )
+static inline int vlc_threads_init( void )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_init();
/*****************************************************************************
* vlc_threads_end: stop threads system
*****************************************************************************/
-static __inline__ int vlc_threads_end( void )
+static inline int vlc_threads_end( void )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_kill();
/*****************************************************************************
* vlc_mutex_init: initialize a mutex
*****************************************************************************/
-static __inline__ int vlc_mutex_init( vlc_mutex_t *p_mutex )
+static inline int vlc_mutex_init( vlc_mutex_t *p_mutex )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_mutex_init( p_mutex );
_vlc_mutex_lock( "(unknown)", 0, P_MUTEX )
#endif
-static __inline__ int _vlc_mutex_lock( char * psz_file, int i_line,
- vlc_mutex_t *p_mutex )
+static inline int _vlc_mutex_lock( char * psz_file, int i_line,
+ vlc_mutex_t *p_mutex )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_mutex_acquire( p_mutex, TRUE, NULL );
_vlc_mutex_unlock( "(unknown)", 0, P_MUTEX )
#endif
-static __inline__ int _vlc_mutex_unlock( char * psz_file, int i_line,
- vlc_mutex_t *p_mutex )
+static inline int _vlc_mutex_unlock( char * psz_file, int i_line,
+ vlc_mutex_t *p_mutex )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_mutex_release( p_mutex );
_vlc_mutex_destroy( "(unknown)", 0, P_MUTEX )
#endif
-static __inline__ int _vlc_mutex_destroy( char * psz_file, int i_line,
- vlc_mutex_t *p_mutex )
+static inline int _vlc_mutex_destroy( char * psz_file, int i_line,
+ vlc_mutex_t *p_mutex )
{
#if defined( PTH_INIT_IN_PTH_H )
return 0;
/*****************************************************************************
* vlc_cond_init: initialize a condition
*****************************************************************************/
-static __inline__ int vlc_cond_init( vlc_cond_t *p_condvar )
+static inline int vlc_cond_init( vlc_cond_t *p_condvar )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_cond_init( p_condvar );
/*****************************************************************************
* vlc_cond_signal: start a thread on condition completion
*****************************************************************************/
-static __inline__ int vlc_cond_signal( vlc_cond_t *p_condvar )
+static inline int vlc_cond_signal( vlc_cond_t *p_condvar )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_cond_notify( p_condvar, FALSE );
* Only works with pthreads, you need to adapt it for others
* FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME FIXME
*/
-static __inline__ int vlc_cond_broadcast( vlc_cond_t *p_condvar )
+static inline int vlc_cond_broadcast( vlc_cond_t *p_condvar )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_cond_notify( p_condvar, FALSE );
_vlc_cond_wait( "(unknown)", 0, P_COND, P_MUTEX )
#endif
-static __inline__ int _vlc_cond_wait( char * psz_file, int i_line,
- vlc_cond_t *p_condvar,
- vlc_mutex_t *p_mutex )
+static inline int _vlc_cond_wait( char * psz_file, int i_line,
+ vlc_cond_t *p_condvar,
+ vlc_mutex_t *p_mutex )
{
#if defined( PTH_INIT_IN_PTH_H )
return pth_cond_await( p_condvar, p_mutex, NULL );
_vlc_cond_destroy( "(unknown)", 0, P_COND )
#endif
-static __inline__ int _vlc_cond_destroy( char * psz_file, int i_line,
- vlc_cond_t *p_condvar )
+static inline int _vlc_cond_destroy( char * psz_file, int i_line,
+ vlc_cond_t *p_condvar )
{
#if defined( PTH_INIT_IN_PTH_H )
return 0;
#define vlc_thread_create( P_THREAD, PSZ_NAME, FUNC, P_DATA ) \
_vlc_thread_create( __FILE__, __LINE__, P_THREAD, PSZ_NAME, FUNC, P_DATA )
-static __inline__ int _vlc_thread_create( char * psz_file, int i_line,
- vlc_thread_t *p_thread,
- char *psz_name,
- vlc_thread_func_t func,
- void *p_data )
+static inline int _vlc_thread_create( char * psz_file, int i_line,
+ vlc_thread_t *p_thread, char *psz_name,
+ vlc_thread_func_t func, void *p_data )
{
int i_ret;
/*****************************************************************************
* vlc_thread_exit: terminate a thread
*****************************************************************************/
-static __inline__ void vlc_thread_exit( void )
+static inline void vlc_thread_exit( void )
{
#if defined( PTH_INIT_IN_PTH_H )
pth_exit( 0 );
_vlc_thread_join( "(unknown)", 0, THREAD )
#endif
-static __inline__ void _vlc_thread_join( char * psz_file, int i_line,
- vlc_thread_t thread )
+static inline void _vlc_thread_join( char * psz_file, int i_line,
+ vlc_thread_t thread )
{
int i_ret = 0;
* (http://liba52.sf.net/).
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: a52.c,v 1.9 2002/05/01 19:59:42 gbazin Exp $
+ * $Id: a52.c,v 1.10 2002/05/18 17:47:46 sam Exp $
*
* Authors: Gildas Bazin <gbazin@netcourrier.com>
*
static void BitstreamCallback ( bit_stream_t *, boolean_t );
static void float2s16_2 ( float *, int16_t * );
-static __inline__ int16_t convert ( int32_t );
+static inline int16_t convert ( int32_t );
/*****************************************************************************
* Capabilities
* float2s16_2 : converts floats to ints using a trick based on the IEEE
* floating-point format
*****************************************************************************/
-static __inline__ int16_t convert (int32_t i)
+static inline int16_t convert (int32_t i)
{
if (i > 0x43c07fff)
return 32767;
* ac3_bit_allocate.c: ac3 allocation tables
*****************************************************************************
* Copyright (C) 2000-2001 VideoLAN
- * $Id: ac3_bit_allocate.c,v 1.6 2001/12/30 07:09:54 sam Exp $
+ * $Id: ac3_bit_allocate.c,v 1.7 2002/05/18 17:47:46 sam Exp $
*
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Aaron Holtzman <aholtzma@engr.uvic.ca>
10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
-static __inline__ u16 max_value (s16 a, s16 b)
+static inline u16 max_value (s16 a, s16 b)
{
return (a > b ? a : b);
}
-static __inline__ u16 min_value (s16 a, s16 b)
+static inline u16 min_value (s16 a, s16 b)
{
return (a < b ? a : b);
}
-static __inline__ s16 logadd (s16 a, s16 b)
+static inline s16 logadd (s16 a, s16 b)
{
s16 c;
}
}
-static __inline__ s16 calc_lowcomp (s16 a, s16 b0, s16 b1, s16 bin)
+static inline s16 calc_lowcomp (s16 a, s16 b0, s16 b1, s16 bin)
{
if (bin < 7) {
if ((b0 + 256) == b1)
* ac3_exponent.h: ac3 exponent calculations
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: ac3_exponent.h,v 1.1 2001/11/13 12:09:17 henri Exp $
+ * $Id: ac3_exponent.h,v 1.2 2002/05/18 17:47:46 sam Exp $
*
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Michel Lespinasse <walken@zoy.org>
#define UNPACK_CPL 2
#define UNPACK_LFE 4
-static __inline__ int exp_unpack_ch (ac3dec_t * p_ac3dec, u16 type,
- u16 expstr, u16 ngrps, u16 initial_exp,
- u16 exps[], u16 * dest)
+static inline int exp_unpack_ch (ac3dec_t * p_ac3dec, u16 type,
+ u16 expstr, u16 ngrps, u16 initial_exp,
+ u16 exps[], u16 * dest)
{
u16 i,j;
s16 exp_acc;
* ac3_mantissa.h: ac3 mantissa computation
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: ac3_mantissa.h,v 1.1 2001/11/13 12:09:17 henri Exp $
+ * $Id: ac3_mantissa.h,v 1.2 2002/05/18 17:47:46 sam Exp $
*
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Aaron Holtzman <aholtzma@engr.uvic.ca>
0x8bf4, 0x2be5, 0x6bc7, 0xcbd6, 0xeb83, 0x4b92, 0x0bb0, 0xaba1
};
-static __inline__ u16 dither_gen (mantissa_t * p_mantissa)
+static inline u16 dither_gen (mantissa_t * p_mantissa)
{
s16 state;
/* Fetch an unpacked, left justified, and properly biased/dithered mantissa value */
-static __inline__ float coeff_get_float (ac3dec_t * p_ac3dec, u16 bap, u16 dithflag,
- u16 exp)
+static inline float coeff_get_float (ac3dec_t * p_ac3dec, u16 bap, u16 dithflag,
+ u16 exp)
{
u16 group_code = 0;
}
/* Uncouple the coupling channel into a fbw channel */
-static __inline__ void uncouple_channel (ac3dec_t * p_ac3dec, u32 ch)
+static inline void uncouple_channel (ac3dec_t * p_ac3dec, u32 ch)
{
u32 bnd = 0;
u32 sub_bnd = 0;
* ac3_rematrix.c: ac3 audio rematrixing
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: ac3_rematrix.c,v 1.6 2001/12/30 07:09:54 sam Exp $
+ * $Id: ac3_rematrix.c,v 1.7 2002/05/18 17:47:46 sam Exp $
*
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Aaron Holtzman <aholtzma@engr.uvic.ca>
static const struct rematrix_band_s rematrix_band[] = { {13,24}, {25,36}, {37 ,60}, {61,252}};
-static __inline__ u32 min_value (u32 a, u32 b)
+static inline u32 min_value (u32 a, u32 b)
{
return (a < b ? a : b);
}
* avi.c : AVI file Stream input module for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: avi.c,v 1.18 2002/05/17 15:47:01 fenrir Exp $
+ * $Id: avi.c,v 1.19 2002/05/18 17:47:46 sam Exp $
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
return( 0 );
}
-static __inline__ int __AVIGetESTypeFromTwoCC( u16 i_type )
+static inline int __AVIGetESTypeFromTwoCC( u16 i_type )
{
switch( i_type )
{
* Function to convert pts to chunk or byte
*****************************************************************************/
-static __inline__ mtime_t __AVI_PTSToChunk( AVIStreamInfo_t *p_info,
- mtime_t i_pts )
+static inline mtime_t __AVI_PTSToChunk( AVIStreamInfo_t *p_info,
+ mtime_t i_pts )
{
return( (mtime_t)((double)i_pts *
(double)p_info->header.i_rate /
(double)1000000.0 ) );
}
-static __inline__ mtime_t __AVI_PTSToByte( AVIStreamInfo_t *p_info,
- mtime_t i_pts )
+static inline mtime_t __AVI_PTSToByte( AVIStreamInfo_t *p_info,
+ mtime_t i_pts )
{
return( (mtime_t)((double)i_pts *
(double)p_info->header.i_samplesize *
*****************************************************************************
* Handle multiple pes, and set pts to the good value
*****************************************************************************/
-static __inline__ void AVI_DecodePES( input_thread_t *p_input,
- AVIStreamInfo_t *p_info,
- pes_packet_t *p_pes )
+static inline void AVI_DecodePES( input_thread_t *p_input,
+ AVIStreamInfo_t *p_info,
+ pes_packet_t *p_pes )
{
pes_packet_t *p_pes_next;
/* input_decode want only one pes, but AVI_GetFrameInPES give
* ffmpeg.c: video decoder using ffmpeg library
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: ffmpeg.c,v 1.9 2002/05/13 21:55:30 fenrir Exp $
+ * $Id: ffmpeg.c,v 1.10 2002/05/18 17:47:46 sam Exp $
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
MODULE_DEACTIVATE_STOP
-static __inline__ u16 __GetWordLittleEndianFromBuff( byte_t *p_buff )
+static inline u16 __GetWordLittleEndianFromBuff( byte_t *p_buff )
{
u16 i;
i = (*p_buff) + ( *(p_buff + 1) <<8 );
return ( i );
}
-static __inline__ u32 __GetDoubleWordLittleEndianFromBuff( byte_t *p_buff )
+static inline u32 __GetDoubleWordLittleEndianFromBuff( byte_t *p_buff )
{
u32 i;
i = (*p_buff) + ( *(p_buff + 1) <<8 ) +
vlc_mutex_unlock( &p_fifo->data_lock );
}
-static __inline__ void __GetFrame( videodec_thread_t *p_vdec )
+static inline void __GetFrame( videodec_thread_t *p_vdec )
{
pes_packet_t *p_pes;
data_packet_t *p_data;
} while( p_data );
}
-static __inline__ void __NextFrame( videodec_thread_t *p_vdec )
+static inline void __NextFrame( videodec_thread_t *p_vdec )
{
pes_packet_t *p_pes;
* gtk_common.h: private Gtk+ interface description
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: gtk_common.h,v 1.7 2002/03/25 20:37:00 lool Exp $
+ * $Id: gtk_common.h,v 1.8 2002/05/18 17:47:46 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
/*****************************************************************************
* Useful inline function
****************************************************************************/
-static __inline__ intf_thread_t * GetIntf( GtkWidget *item, char * psz_parent )
+static inline intf_thread_t * GetIntf( GtkWidget *item, char * psz_parent )
{
return( gtk_object_get_data( GTK_OBJECT( lookup_widget(item, psz_parent) ),
"p_intf" ) );
* block_c.h: Macroblock copy functions in C
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: block_c.h,v 1.1 2001/09/05 16:07:49 massiot Exp $
+ * $Id: block_c.h,v 1.2 2002/05/18 17:47:46 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
/*****************************************************************************
* AddBlock: add a block
*****************************************************************************/
-static __inline__ void AddBlock( dctelem_t * p_block, yuv_data_t * p_data,
- int i_incr )
+static inline void AddBlock( dctelem_t * p_block, yuv_data_t * p_data,
+ int i_incr )
{
int i = 8;
/*****************************************************************************
* CopyBlock: copy a block
*****************************************************************************/
-static __inline__ void CopyBlock( dctelem_t * p_block, yuv_data_t * p_data,
- int i_incr )
+static inline void CopyBlock( dctelem_t * p_block, yuv_data_t * p_data,
+ int i_incr )
{
int i = 8;
* block_mmx.h: Macroblock copy functions in MMX assembly
*****************************************************************************
* Copyright (C) 1999, 2000, 2001 VideoLAN
- * $Id: block_mmx.h,v 1.1 2001/09/05 16:07:49 massiot Exp $
+ * $Id: block_mmx.h,v 1.2 2002/05/18 17:47:46 sam Exp $
*
* Authors: Michel Lespinasse <walken@zoy.org>
* Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
/*****************************************************************************
* InitBlock: placeholder because we don't need a crop table, MMX does it for us
*****************************************************************************/
-static __inline__ void InitBlock( )
+static inline void InitBlock( )
{
;
}
punpckhbw_r2r (mm0, r2); \
paddsw_m2r (*(p_block+offset+4), r2);
-static __inline__ void AddBlock( dctelem_t * p_block, yuv_data_t * p_data,
- int i_incr )
+static inline void AddBlock( dctelem_t * p_block, yuv_data_t * p_data,
+ int i_incr )
{
movq_m2r (*p_data, mm1);
pxor_r2r (mm0, mm0);
movq_r2m (r2, *p_data); \
packuswb_r2r (r1, r0);
-static __inline__ void CopyBlock( dctelem_t * p_block, yuv_data_t * p_data,
- int i_incr )
+static inline void CopyBlock( dctelem_t * p_block, yuv_data_t * p_data,
+ int i_incr )
{
movq_m2r (*(p_block+0*8), mm0);
movq_m2r (*(p_block+0*8+4), mm1);
* idct.c : C IDCT module
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: idct.c,v 1.22 2002/04/21 11:23:03 gbazin Exp $
+ * $Id: idct.c,v 1.23 2002/05/18 17:47:46 sam Exp $
*
* Author: Gaël Hendryckx <jimmy@via.ecp.fr>
*
/*****************************************************************************
* IDCT : IDCT function for normal matrices
*****************************************************************************/
-static __inline__ void IDCT( dctelem_t * p_block )
+static inline void IDCT( dctelem_t * p_block )
{
s32 tmp0, tmp1, tmp2, tmp3;
s32 tmp10, tmp11, tmp12, tmp13;
}
}
-static __inline__ void RestoreCPUState( )
+static inline void RestoreCPUState( )
{
;
}
* idct_sparse.h : Sparse IDCT functions (must be include at the end)
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: idct_sparse.h,v 1.2 2002/04/21 11:23:03 gbazin Exp $
+ * $Id: idct_sparse.h,v 1.3 2002/05/18 17:47:46 sam Exp $
*
* Author: Gaël Hendryckx <jimmy@via.ecp.fr>
*
/*****************************************************************************
* SparseIDCT : IDCT function for sparse matrices
*****************************************************************************/
-static __inline__ void SparseIDCT( dctelem_t * p_block, void * p_idct_data,
- int i_sparse_pos )
+static inline void SparseIDCT( dctelem_t * p_block, void * p_idct_data,
+ int i_sparse_pos )
{
short int val;
int * dp;
* idctclassic.c : Classic IDCT module
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: idctclassic.c,v 1.23 2002/04/21 11:23:03 gbazin Exp $
+ * $Id: idctclassic.c,v 1.24 2002/05/18 17:47:46 sam Exp $
*
* Authors: Gaël Hendryckx <jimmy@via.ecp.fr>
*
/*****************************************************************************
* IDCT : IDCT function for normal matrices
*****************************************************************************/
-static __inline__ void IDCT( dctelem_t * p_block )
+static inline void IDCT( dctelem_t * p_block )
{
s32 tmp0, tmp1, tmp2, tmp3;
s32 tmp10, tmp11, tmp12, tmp13;
}
}
-static __inline__ void RestoreCPUState( )
+static inline void RestoreCPUState( )
{
;
}
* idctmmx.c : MMX IDCT module
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: idctmmx.c,v 1.25 2002/04/21 11:23:03 gbazin Exp $
+ * $Id: idctmmx.c,v 1.26 2002/05/18 17:47:46 sam Exp $
*
* Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
* Michel Lespinasse <walken@zoy.org>
c5, -c1, c7, -c5, \
c7, c3, c3, -c1 }
-static __inline__ void RowHead( dctelem_t * row, int offset, dctelem_t * table )
+static inline void RowHead( dctelem_t * row, int offset, dctelem_t * table )
{
movq_m2r (*(row+offset), mm2); // mm2 = x6 x4 x2 x0
punpckhdq_r2r (mm2, mm2); // mm2 = x6 x4 x6 x4
}
-static __inline__ void Row( dctelem_t * table, s32 * rounder )
+static inline void Row( dctelem_t * table, s32 * rounder )
{
pmaddwd_r2r (mm2, mm4); // mm4 = -C4*x4-C2*x6 C4*x4+C6*x6
punpckldq_r2r (mm5, mm5); // mm5 = x3 x1 x3 x1
psubd_r2r (mm5, mm7); // mm7 = a3-b3 a2-b2 + rounder
}
-static __inline__ void RowTail( dctelem_t * row, int store )
+static inline void RowTail( dctelem_t * row, int store )
{
psrad_i2r (ROW_SHIFT, mm0); // mm0 = y3 y2
movq_r2m (mm7, *(row+store+4)); // save y7 y6 y5 y4
}
-static __inline__ void RowMid( dctelem_t * row, int store,
- int offset, dctelem_t * table )
+static inline void RowMid( dctelem_t * row, int store,
+ int offset, dctelem_t * table )
{
movq_m2r (*(row+offset), mm2); // mm2 = x6 x4 x2 x0
psrad_i2r (ROW_SHIFT, mm0); // mm0 = y3 y2
pmaddwd_r2r (mm0, mm3); // mm3 = C4*x0+C6*x2 C4*x0+C2*x2
}
-static __inline__ void Col( dctelem_t * col, int offset )
+static inline void Col( dctelem_t * col, int offset )
{
#define T1 13036
#define T2 27146
Col( p_block, 4 );
}
-static __inline__ void RestoreCPUState( )
+static inline void RestoreCPUState( )
{
/* reenables the FPU */
__asm__ __volatile__ ("emms");
* idctmmxext.c : MMX EXT IDCT module
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: idctmmxext.c,v 1.22 2002/04/21 11:23:03 gbazin Exp $
+ * $Id: idctmmxext.c,v 1.23 2002/05/18 17:47:46 sam Exp $
*
* Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
* Michel Lespinasse <walken@zoy.org>
c5, -c1, c3, -c1, \
c7, c3, c7, -c5 }
-static __inline__ void RowHead( dctelem_t * row, int offset, dctelem_t * table )
+static inline void RowHead( dctelem_t * row, int offset, dctelem_t * table )
{
movq_m2r (*(row+offset), mm2); // mm2 = x6 x4 x2 x0
pshufw_r2r (mm2, mm2, 0x4e); // mm2 = x2 x0 x6 x4
}
-static __inline__ void Row( dctelem_t * table, s32 * rounder )
+static inline void Row( dctelem_t * table, s32 * rounder )
{
movq_m2r (*(table+8), mm1); // mm1 = -C5 -C1 C3 C1
pmaddwd_r2r (mm2, mm4); // mm4 = C4*x0+C6*x2 C4*x4+C6*x6
psubd_r2r (mm5, mm4); // mm4 = a3-b3 a2-b2 + rounder
}
-static __inline__ void RowTail( dctelem_t * row, int store )
+static inline void RowTail( dctelem_t * row, int store )
{
psrad_i2r (ROW_SHIFT, mm0); // mm0 = y3 y2
movq_r2m (mm4, *(row+store+4)); // save y7 y6 y5 y4
}
-static __inline__ void RowMid( dctelem_t * row, int store,
- int offset, dctelem_t * table)
+static inline void RowMid( dctelem_t * row, int store,
+ int offset, dctelem_t * table)
{
movq_m2r (*(row+offset), mm2); // mm2 = x6 x4 x2 x0
psrad_i2r (ROW_SHIFT, mm0); // mm0 = y3 y2
pshufw_r2r (mm2, mm2, 0x4e); // mm2 = x2 x0 x6 x4
}
-static __inline__ void Col( dctelem_t * col, int offset )
+static inline void Col( dctelem_t * col, int offset )
{
#define T1 13036
#define T2 27146
Col( p_block, 4 );
}
-static __inline__ void RestoreCPUState( )
+static inline void RestoreCPUState( )
{
/* reenables the FPU */
__asm__ __volatile__ ("emms");
* NAME: prng()
* DESCRIPTION: 32-bit pseudo-random number generator
*/
-static __inline__ unsigned long prng(unsigned long state)
+static inline unsigned long prng(unsigned long state)
{
return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
}
* NAME: mpg321_s24_to_s16_pcm()
* DESCRIPTION: generic linear sample quantize and dither routine
*/
-static __inline__ signed int mpg321_s24_to_s16_pcm(unsigned int bits, mad_fixed_t sample,
+static inline signed int mpg321_s24_to_s16_pcm(unsigned int bits, mad_fixed_t sample,
struct audio_dither *dither)
{
unsigned int scalebits;
/*****************************************************************************
* s24_to_s16_pcm: Scale a 24 bit pcm sample to a 16 bit pcm sample.
*****************************************************************************/
-static __inline__ mad_fixed_t s24_to_s16_pcm(mad_fixed_t sample)
+static inline mad_fixed_t s24_to_s16_pcm(mad_fixed_t sample)
{
/* round */
sample += (1L << (MAD_F_FRACBITS - 16));
* xmga.c : X11 MGA plugin for vlc
*****************************************************************************
* Copyright (C) 1998-2001 VideoLAN
- * $Id: xmga.c,v 1.13 2002/05/06 21:05:26 gbazin Exp $
+ * $Id: xmga.c,v 1.14 2002/05/18 17:47:47 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
/*****************************************************************************
* Seeking function TODO: put this in a generic location !
*****************************************************************************/
-static __inline__ void vout_Seek( off_t i_seek )
+static inline void vout_Seek( off_t i_seek )
{
off_t i_tell;
* motion3dnow.c : 3D Now! motion compensation module for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: motion3dnow.c,v 1.9 2002/04/21 10:32:20 sam Exp $
+ * $Id: motion3dnow.c,v 1.10 2002/05/18 17:47:47 sam Exp $
*
* Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
* Michel Lespinasse <walken@zoy.org>
//CPU_MMXEXT code
-static __inline__ void MC_put1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride)
{
do {
} while (--height);
}
-static __inline__ void MC_put1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride)
{
do {
} while (--height);
}
-static __inline__ void MC_avg1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_put2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_put2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
static mmx_t mask_one = {0x0101010101010101LL};
-static __inline__ void MC_put4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
movq_m2r (*ref, mm0);
} while (--height);
}
-static __inline__ void MC_put4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
* motionmmx.c : MMX motion compensation module for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: motionmmx.c,v 1.16 2002/04/19 13:56:11 sam Exp $
+ * $Id: motionmmx.c,v 1.17 2002/05/18 17:47:47 sam Exp $
*
* Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
* Michel Lespinasse <walken@zoy.org>
* unrolling will help
*/
-static __inline__ void mmx_zero_reg ()
+static inline void mmx_zero_reg ()
{
// load 0 into mm0
pxor_r2r (mm0, mm0);
}
-static __inline__ void mmx_average_2_U8 (yuv_data_t * dest,
+static inline void mmx_average_2_U8 (yuv_data_t * dest,
yuv_data_t * src1, yuv_data_t * src2)
{
//
movq_r2m (mm1, *dest); // store result in dest
}
-static __inline__ void mmx_interp_average_2_U8 (yuv_data_t * dest,
+static inline void mmx_interp_average_2_U8 (yuv_data_t * dest,
yuv_data_t * src1, yuv_data_t * src2)
{
//
movq_r2m (mm1, *dest); // store result in dest
}
-static __inline__ void mmx_average_4_U8 (yuv_data_t * dest,
+static inline void mmx_average_4_U8 (yuv_data_t * dest,
yuv_data_t * src1, yuv_data_t * src2,
yuv_data_t * src3, yuv_data_t * src4)
{
movq_r2m (mm1, *dest); // store result in dest
}
-static __inline__ void mmx_interp_average_4_U8 (yuv_data_t * dest,
+static inline void mmx_interp_average_4_U8 (yuv_data_t * dest,
yuv_data_t * src1, yuv_data_t * src2,
yuv_data_t * src3, yuv_data_t * src4)
{
//-----------------------------------------------------------------------
-static __inline__ void MC_avg_mmx (int width, int height,
+static inline void MC_avg_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
mmx_zero_reg ();
//-----------------------------------------------------------------------
-static __inline__ void MC_put_mmx (int width, int height,
+static inline void MC_put_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
mmx_zero_reg ();
//-----------------------------------------------------------------------
// Half pixel interpolation in the x direction
-static __inline__ void MC_avg_x_mmx (int width, int height,
+static inline void MC_avg_x_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
mmx_zero_reg ();
//-----------------------------------------------------------------------
-static __inline__ void MC_put_x_mmx (int width, int height,
+static inline void MC_put_x_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
mmx_zero_reg ();
//-----------------------------------------------------------------------
-static __inline__ void MC_avg_xy_mmx (int width, int height,
+static inline void MC_avg_xy_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
yuv_data_t * ref_next = ref+stride;
//-----------------------------------------------------------------------
-static __inline__ void MC_put_xy_mmx (int width, int height,
+static inline void MC_put_xy_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
yuv_data_t * ref_next = ref+stride;
//-----------------------------------------------------------------------
-static __inline__ void MC_avg_y_mmx (int width, int height,
+static inline void MC_avg_y_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
yuv_data_t * ref_next = ref+stride;
//-----------------------------------------------------------------------
-static __inline__ void MC_put_y_mmx (int width, int height,
+static inline void MC_put_y_mmx (int width, int height,
yuv_data_t * dest, yuv_data_t * ref, int stride)
{
yuv_data_t * ref_next = ref+stride;
* motionmmxext.c : MMX EXT motion compensation module for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: motionmmxext.c,v 1.17 2002/04/19 13:56:11 sam Exp $
+ * $Id: motionmmxext.c,v 1.18 2002/05/18 17:47:47 sam Exp $
*
* Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
* Michel Lespinasse <walken@zoy.org>
//CPU_MMXEXT code
-static __inline__ void MC_put1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride)
{
do {
} while (--height);
}
-static __inline__ void MC_put1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride)
{
do {
} while (--height);
}
-static __inline__ void MC_avg1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg1_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg1_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_put2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_put2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg2_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg2_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int offset, int cpu)
{
do {
static mmx_t mask_one = {0x0101010101010101LL};
-static __inline__ void MC_put4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
movq_m2r (*ref, mm0);
} while (--height);
}
-static __inline__ void MC_put4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_put4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg4_8 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
} while (--height);
}
-static __inline__ void MC_avg4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
+static inline void MC_avg4_16 (int height, yuv_data_t * dest, yuv_data_t * ref,
int stride, int cpu)
{
do {
* mpeg_audio.c : mpeg_audio Stream input module for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: mpeg_audio.c,v 1.7 2002/05/17 23:01:02 fenrir Exp $
+ * $Id: mpeg_audio.c,v 1.8 2002/05/18 17:47:47 sam Exp $
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
* This program is free software; you can redistribute it and/or modify
"stereo", "joint stereo", "dual channel", "mono"
};
-static __inline__ u32 __GetDWBE( byte_t *p_buff )
+static inline u32 __GetDWBE( byte_t *p_buff )
{
return( ( (*(p_buff)) << 24 ) + ( (*(p_buff+1)) << 16 ) +
( (*(p_buff+2)) << 8 ) + ( (*(p_buff+3)) ) );
* video_decoder.c : video decoder thread
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: video_decoder.c,v 1.8 2002/05/13 23:15:43 massiot Exp $
+ * $Id: video_decoder.c,v 1.9 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
* Michel Lespinasse <walken@zoy.org>
/*****************************************************************************
* MotionBlock: does one component of the motion compensation
*****************************************************************************/
-static __inline__ void MotionBlock( vdec_pool_t * p_pool,
- boolean_t b_average,
- int i_x_pred, int i_y_pred,
- yuv_data_t * pp_dest[3], int i_dest_offset,
- yuv_data_t * pp_src[3], int i_src_offset,
- int i_stride, int i_height,
- boolean_t b_second_half,
- int i_chroma_format )
+static inline void MotionBlock( vdec_pool_t * p_pool, boolean_t b_average,
+ int i_x_pred, int i_y_pred,
+ yuv_data_t * pp_dest[3], int i_dest_offset,
+ yuv_data_t * pp_src[3], int i_src_offset,
+ int i_stride, int i_height,
+ boolean_t b_second_half, int i_chroma_format )
{
int i_xy_half;
yuv_data_t * p_src1;
* video_parser.h : video parser thread
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: video_parser.h,v 1.4 2002/04/15 23:04:08 massiot Exp $
+ * $Id: video_parser.h,v 1.5 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
* Jean-Marc Dressler <polux@via.ecp.fr>
/*****************************************************************************
* NextStartCode : Find the next start code
*****************************************************************************/
-static __inline__ void NextStartCode( bit_stream_t * p_bit_stream )
+static inline void NextStartCode( bit_stream_t * p_bit_stream )
{
/* Re-align the buffer on an 8-bit boundary */
RealignBits( p_bit_stream );
*****************************************************************************
* Quantizer scale factor (ISO/IEC 13818-2 7.4.2.2)
*****************************************************************************/
-static __inline__ void LoadQuantizerScale( struct vpar_thread_s * p_vpar )
+static inline void LoadQuantizerScale( struct vpar_thread_s * p_vpar )
{
/* Quantization coefficient table */
static u8 pi_non_linear_quantizer_scale[32] =
* vpar_blocks.c : blocks parsing
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: vpar_blocks.c,v 1.8 2002/04/15 23:04:08 massiot Exp $
+ * $Id: vpar_blocks.c,v 1.9 2002/05/18 17:47:47 sam Exp $
*
* Authors: Michel Lespinasse <walken@zoy.org>
* Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
/*****************************************************************************
* GetLumaDCDiff : Get the luminance DC coefficient difference
*****************************************************************************/
-static __inline__ int GetLumaDCDiff( vpar_thread_t * p_vpar )
+static inline int GetLumaDCDiff( vpar_thread_t * p_vpar )
{
lookup_t * p_tab;
int i_size, i_dc_diff, i_code;
/*****************************************************************************
* GetChromaDCDiff : Get the chrominance DC coefficient difference
*****************************************************************************/
-static __inline__ int GetChromaDCDiff( vpar_thread_t * p_vpar )
+static inline int GetChromaDCDiff( vpar_thread_t * p_vpar )
{
lookup_t * p_tab;
int i_size, i_dc_diff, i_code;
p_vpar->sequence.chroma_intra_quant.pi_matrix );
#define DECLARE_INTRAMB( PSZ_NAME, PF_MBFUNC ) \
-static __inline__ void PSZ_NAME( vpar_thread_t * p_vpar, \
- macroblock_t * p_mb ) \
+static inline void PSZ_NAME( vpar_thread_t * p_vpar, macroblock_t * p_mb ) \
{ \
idct_inner_t * p_idct; \
int i_b = 4; \
}
#define DECLARE_NONINTRAMB( PSZ_NAME, PF_MBFUNC ) \
-static __inline__ void PSZ_NAME( vpar_thread_t * p_vpar, \
- macroblock_t * p_mb ) \
+static inline void PSZ_NAME( vpar_thread_t * p_vpar, macroblock_t * p_mb ) \
{ \
idct_inner_t * p_idct; \
int i_b = 4; \
/****************************************************************************
* MotionDelta : Parse the next motion delta
****************************************************************************/
-static __inline__ int MotionDelta( vpar_thread_t * p_vpar, int i_f_code )
+static inline int MotionDelta( vpar_thread_t * p_vpar, int i_f_code )
{
int i_delta, i_sign, i_code;
lookup_t * p_tab;
/****************************************************************************
* BoundMotionVector : Bound a motion_vector :-)
****************************************************************************/
-static __inline__ int BoundMotionVector( int i_vector, int i_f_code )
+static inline int BoundMotionVector( int i_vector, int i_f_code )
{
int i_limit;
/****************************************************************************
* GetDMV : Decode a differential motion vector (Dual Prime Arithmetic)
****************************************************************************/
-static __inline__ int GetDMV( vpar_thread_t * p_vpar )
+static inline int GetDMV( vpar_thread_t * p_vpar )
{
dmv_lookup_t * p_tab;
/*****************************************************************************
* MacroblockAddressIncrement : Get the macroblock_address_increment field
*****************************************************************************/
-static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
+static inline int MacroblockAddressIncrement( vpar_thread_t * p_vpar )
{
lookup_t * p_tab;
int i_code;
/*****************************************************************************
* CodedPattern : coded_block_pattern
*****************************************************************************/
-static __inline__ int CodedPattern( vpar_thread_t * p_vpar )
+static inline int CodedPattern( vpar_thread_t * p_vpar )
{
lookup_t * p_tab;
int i_code;
/*****************************************************************************
* MacroblockModes : Get the macroblock_modes structure
*****************************************************************************/
-static __inline__ int MacroblockModes( vpar_thread_t * p_vpar,
- macroblock_t * p_mb,
- int i_coding_type,
- int i_structure )
+static inline int MacroblockModes( vpar_thread_t * p_vpar, macroblock_t * p_mb,
+ int i_coding_type, int i_structure )
{
int i_mb_modes;
lookup_t * p_tab;
return; \
}
-static __inline__ void ParseSlice( vpar_thread_t * p_vpar,
- u32 i_vert_code, boolean_t b_mpeg2,
- int i_coding_type, int i_structure )
+static inline void ParseSlice( vpar_thread_t * p_vpar,
+ u32 i_vert_code, boolean_t b_mpeg2,
+ int i_coding_type, int i_structure )
{
int i_lum_offset, i_chrom_offset, i_offset, i_lum_vsize, i_chrom_vsize;
picture_t * pp_forward_ref[2];
/*****************************************************************************
* PictureData : Parse off all macroblocks (ISO/IEC 13818-2 6.2.3.7)
*****************************************************************************/
-static __inline__ void vpar_PictureData( vpar_thread_t * p_vpar,
- boolean_t b_mpeg2,
- int i_coding_type, int i_structure )
+static inline void vpar_PictureData( vpar_thread_t * p_vpar, boolean_t b_mpeg2,
+ int i_coding_type, int i_structure )
{
u32 i_dummy;
* vpar_headers.c : headers parsing
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: vpar_headers.c,v 1.19 2002/05/17 18:12:59 stef Exp $
+ * $Id: vpar_headers.c,v 1.20 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
* Stéphane Borel <stef@via.ecp.fr>
/*
* Local prototypes
*/
-static __inline__ void NextStartCode( bit_stream_t * );
+static inline void NextStartCode( bit_stream_t * );
static void SequenceHeader( vpar_thread_t * p_vpar );
static void GroupHeader( vpar_thread_t * p_vpar );
static void PictureHeader( vpar_thread_t * p_vpar );
/*****************************************************************************
* ReferenceUpdate : Update the reference pointers when we have a new picture
*****************************************************************************/
-static void __inline__ ReferenceUpdate( vpar_thread_t * p_vpar,
- int i_coding_type,
- picture_t * p_newref )
+static void inline ReferenceUpdate( vpar_thread_t * p_vpar,
+ int i_coding_type,
+ picture_t * p_newref )
{
if( i_coding_type != B_CODING_TYPE )
{
* ReferenceReplace : Replace the last reference pointer when we destroy
* a picture
*****************************************************************************/
-static void __inline__ ReferenceReplace( vpar_thread_t * p_vpar,
- int i_coding_type,
- picture_t * p_newref )
+static void inline ReferenceReplace( vpar_thread_t * p_vpar, int i_coding_type,
+ picture_t * p_newref )
{
if( i_coding_type != B_CODING_TYPE )
{
/*****************************************************************************
* LoadMatrix : Load a quantization matrix
*****************************************************************************/
-static __inline__ void LoadMatrix( vpar_thread_t * p_vpar,
- quant_matrix_t * p_matrix )
+static inline void LoadMatrix( vpar_thread_t * p_vpar,
+ quant_matrix_t * p_matrix )
{
int i_dummy;
/*****************************************************************************
* LinkMatrix : Link a quantization matrix to another
*****************************************************************************/
-static __inline__ void LinkMatrix( quant_matrix_t * p_matrix, u8 * pi_array )
+static inline void LinkMatrix( quant_matrix_t * p_matrix, u8 * pi_array )
{
if( p_matrix->b_allocated )
{
/*****************************************************************************
* ChromaToFourCC: Return a FourCC value used by the video output.
*****************************************************************************/
-static __inline__ u64 ChromaToFourCC( int i_chroma )
+static inline u64 ChromaToFourCC( int i_chroma )
{
switch( i_chroma )
{
* vpar_pool.h : video parser/video decoders communication
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: vpar_pool.h,v 1.1 2001/11/13 12:09:18 henri Exp $
+ * $Id: vpar_pool.h,v 1.2 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
/*****************************************************************************
* vpar_GetMacroblock: In a vdec thread, get the next available macroblock
*****************************************************************************/
-static __inline__ macroblock_t * vpar_GetMacroblock( vdec_pool_t * p_pool,
- boolean_t * pb_die )
+static inline macroblock_t * vpar_GetMacroblock( vdec_pool_t * p_pool,
+ boolean_t * pb_die )
{
macroblock_t * p_mb;
* vout_sdl.c: SDL video output display method
*****************************************************************************
* Copyright (C) 1998-2001 VideoLAN
- * $Id: vout_sdl.c,v 1.90 2002/05/14 17:31:40 sam Exp $
+ * $Id: vout_sdl.c,v 1.91 2002/05/18 17:47:47 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
* Pierre Baillet <oct@zoy.org>
/*****************************************************************************
* Seeking function TODO: put this in a generic location !
*****************************************************************************/
-static __inline__ void vout_Seek( off_t i_seek )
+static inline void vout_Seek( off_t i_seek )
{
off_t i_tell;
* spu_decoder.h : sub picture unit decoder thread interface
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
- * $Id: spu_decoder.h,v 1.3 2002/03/15 18:20:27 sam Exp $
+ * $Id: spu_decoder.h,v 1.4 2002/05/18 17:47:47 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
/*****************************************************************************
* AddNibble: read a nibble from a source packet and add it to our integer.
*****************************************************************************/
-static __inline__ unsigned int AddNibble( unsigned int i_code,
- u8 *p_src, int *pi_index )
+static inline unsigned int AddNibble( unsigned int i_code,
+ u8 *p_src, int *pi_index )
{
if( *pi_index & 0x1 )
{
* xcommon.c: Functions common to the X11 and XVideo plugins
*****************************************************************************
* Copyright (C) 1998-2001 VideoLAN
- * $Id: xcommon.c,v 1.32 2002/05/13 17:58:08 sam Exp $
+ * $Id: xcommon.c,v 1.33 2002/05/18 17:47:47 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
/*****************************************************************************
* Seeking function TODO: put this in a generic location !
*****************************************************************************/
-static __inline__ void vout_Seek( off_t i_seek )
+static inline void vout_Seek( off_t i_seek )
{
off_t i_tell;
* aout_pcm.c: PCM audio output functions
*****************************************************************************
* Copyright (C) 1999-2002 VideoLAN
- * $Id: aout_pcm.c,v 1.5 2002/05/18 15:51:37 gbazin Exp $
+ * $Id: aout_pcm.c,v 1.6 2002/05/18 17:47:47 sam Exp $
*
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Cyril Deguet <asmax@via.ecp.fr>
/*****************************************************************************
* InitializeIncrement: change i_x/i_y to i_a+i_b/i_c
*****************************************************************************/
-static __inline__ void InitializeIncrement( aout_increment_t * p_inc,
- int i_x, int i_y )
+static inline void InitializeIncrement( aout_increment_t * p_inc,
+ int i_x, int i_y )
{
p_inc->i_r = -i_y;
p_inc->i_a = 0;
/*****************************************************************************
* UpdateIncrement
*****************************************************************************/
-static __inline__ void UpdateIncrement( aout_increment_t * p_inc,
- int * pi_integer )
+static inline void UpdateIncrement( aout_increment_t * p_inc, int * pi_integer )
{
if( (p_inc->i_r += p_inc->i_b) >= 0 )
{
* input_ext-dec.c: services to the decoders
*****************************************************************************
* Copyright (C) 1998-2001 VideoLAN
- * $Id: input_ext-dec.c,v 1.30 2002/03/01 00:33:18 massiot Exp $
+ * $Id: input_ext-dec.c,v 1.31 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
* NextDataPacket: go to the data packet after *pp_data, return 1 if we
* changed PES
*****************************************************************************/
-static __inline__ boolean_t _NextDataPacket( decoder_fifo_t * p_fifo,
- data_packet_t ** pp_data )
+static inline boolean_t _NextDataPacket( decoder_fifo_t * p_fifo,
+ data_packet_t ** pp_data )
{
boolean_t b_new_pes;
* BitstreamNextDataPacket: go to the next data packet, and update bitstream
* context
*****************************************************************************/
-static __inline__ void _BitstreamNextDataPacket( bit_stream_t * p_bit_stream )
+static inline void _BitstreamNextDataPacket( bit_stream_t * p_bit_stream )
{
decoder_fifo_t * p_fifo = p_bit_stream->p_decoder_fifo;
boolean_t b_new_pes;
* input_ext-plugins.c: useful functions for access and demux plug-ins
*****************************************************************************
* Copyright (C) 2001, 2002 VideoLAN
- * $Id: input_ext-plugins.c,v 1.8 2002/05/15 13:36:40 marcari Exp $
+ * $Id: input_ext-plugins.c,v 1.9 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
*
/*****************************************************************************
* input_NewBuffer: return a pointer to a data buffer of the appropriate size
*****************************************************************************/
-static __inline__ data_buffer_t * NewBuffer( input_buffers_t * p_buffers,
- size_t i_size )
+static inline data_buffer_t * NewBuffer( input_buffers_t * p_buffers,
+ size_t i_size )
{
data_buffer_t * p_buf;
/*****************************************************************************
* input_ReleaseBuffer: put a buffer back into the cache
*****************************************************************************/
-static __inline__ void ReleaseBuffer( input_buffers_t * p_buffers,
- data_buffer_t * p_buf )
+static inline void ReleaseBuffer( input_buffers_t * p_buffers,
+ data_buffer_t * p_buf )
{
/* Decrement refcount */
if( --p_buf->i_refcount > 0 )
/*****************************************************************************
* input_ShareBuffer: allocate a data_packet_t pointing to a given buffer
*****************************************************************************/
-static __inline__ data_packet_t * ShareBuffer( input_buffers_t * p_buffers,
- data_buffer_t * p_buf )
+static inline data_packet_t * ShareBuffer( input_buffers_t * p_buffers,
+ data_buffer_t * p_buf )
{
data_packet_t * p_data;
/*****************************************************************************
* input_NewPacket: allocate a packet along with a buffer
*****************************************************************************/
-static __inline__ data_packet_t * NewPacket( input_buffers_t * p_buffers,
- size_t i_size )
+static inline data_packet_t * NewPacket( input_buffers_t * p_buffers,
+ size_t i_size )
{
data_buffer_t * p_buf = NewBuffer( p_buffers, i_size );
data_packet_t * p_data;
/*****************************************************************************
* input_DeletePacket: deallocate a packet and its buffers
*****************************************************************************/
-static __inline__ void DeletePacket( input_buffers_t * p_buffers,
- data_packet_t * p_data )
+static inline void DeletePacket( input_buffers_t * p_buffers,
+ data_packet_t * p_data )
{
while( p_data != NULL )
{
/*****************************************************************************
* input_NewPES: return a pointer to a new PES packet
*****************************************************************************/
-static __inline__ pes_packet_t * NewPES( input_buffers_t * p_buffers )
+static inline pes_packet_t * NewPES( input_buffers_t * p_buffers )
{
pes_packet_t * p_pes;
* input_DeletePES: put a pes and all data packets and all buffers back into
* the cache
*****************************************************************************/
-static __inline__ void DeletePES( input_buffers_t * p_buffers,
- pes_packet_t * p_pes )
+static inline void DeletePES( input_buffers_t * p_buffers,
+ pes_packet_t * p_pes )
{
while( p_pes != NULL )
{
/*****************************************************************************
* NetworkSelect: Checks whether data is available on a file descriptor
*****************************************************************************/
-static __inline__ int NetworkSelect( input_thread_t * p_input )
+static inline int NetworkSelect( input_thread_t * p_input )
{
input_socket_t * p_access_data = (input_socket_t *)p_input->p_access_data;
struct timeval timeout;
* mpeg_system.c: TS, PS and PES management
*****************************************************************************
* Copyright (C) 1998-2001 VideoLAN
- * $Id: mpeg_system.c,v 1.95 2002/05/14 20:54:52 jobi Exp $
+ * $Id: mpeg_system.c,v 1.96 2002/05/18 17:47:47 sam Exp $
*
* Authors: Christophe Massiot <massiot@via.ecp.fr>
* Michel Lespinasse <walken@via.ecp.fr>
* It also solves some alignment problems on non-IA-32, non-PPC processors.
* This is a variation on the theme of input_ext-dec.h:GetChunk().
*****************************************************************************/
-static __inline__ size_t MoveChunk( byte_t * p_dest,
- data_packet_t ** pp_data_src,
- byte_t ** pp_src,
- size_t i_buf_len )
+static inline size_t MoveChunk( byte_t * p_dest, data_packet_t ** pp_data_src,
+ byte_t ** pp_src, size_t i_buf_len )
{
ptrdiff_t i_available;
projects / vlc / commitdiff