DVDs, or MPEG streams from a network source.
Package: libvlc0-dev
+Section: devel
Architecture: any
Depends: vlc (= ${Source-Version}), ${shlibs:Depends}
Description: development files for the VideoLAN Client
* Declaration and extern access to global program object.
*****************************************************************************
* Copyright (C) 1999, 2000, 2001, 2002 VideoLAN
- * $Id: main.h,v 1.45 2002/08/20 18:08:51 sam Exp $
+ * $Id: main.h,v 1.46 2002/10/03 13:21:54 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
*
*****************************************************************************/
/*****************************************************************************
- * vlc_t, p_vlc (global variable)
+ * libvlc_t (global variable)
*****************************************************************************
- * This structure has an unique instance, declared in main and pointed by the
- * only global variable of the program. It should allow access to any variable
- * of the program, for user-interface purposes or more easier call of interface
- * and common functions (example: the intf_*Msg functions). Please avoid using
- * it when you can access the members you need in an other way. In fact, it
- * should only be used by interface thread.
+ * This structure has an unique instance, statically allocated in main and
+ * never accessed from the outside. It store once-initialized data such as
+ * the CPU capabilities or the global lock.
+ *****************************************************************************/
+struct libvlc_t
+{
+ VLC_COMMON_MEMBERS
+
+ /* Initialization boolean */
+ vlc_bool_t b_ready;
+
+ /* CPU extensions */
+ u32 i_cpu;
+
+ /* Object structure data */
+ int i_counter; /* object counter */
+ int i_objects; /* Attached objects count */
+ vlc_object_t ** pp_objects; /* Array of all objects */
+
+ /* The big, evil global lock */
+ vlc_mutex_t global_lock;
+ void * p_global_data;
+
+ /* Locks */
+ vlc_mutex_t structure_lock; /* lock for the p_vlc tree */
+
+ /* The message bank */
+ msg_bank_t msg_bank;
+
+ /* The module bank */
+ module_bank_t * p_module_bank;
+
+ /* Arch-specific variables */
+#if defined( SYS_BEOS )
+ vlc_object_t * p_appthread;
+#elif defined( WIN32 )
+ SIGNALOBJECTANDWAIT SignalObjectAndWait;
+ vlc_bool_t b_fast_mutex;
+ int i_win9x_cv;
+#endif
+};
+
+/*****************************************************************************
+ * vlc_t, p_vlc
+ *****************************************************************************
+ * This structure is a LibVLC instance.
*****************************************************************************/
struct vlc_t
{
/* The vlc structure status */
int i_status;
- int i_instance; /* p_vlc instance # */
/* Global properties */
int i_argc; /* command line arguments count */
char ** ppsz_argv; /* command line arguments */
char * psz_homedir; /* user's home directory */
- u32 i_cpu; /* CPU extensions */
-
/* Generic settings */
vlc_bool_t b_quiet; /* be quiet ? */
vlc_bool_t b_verbose; /* info messages ? */
vlc_bool_t b_color; /* color messages ? */
mtime_t i_desync; /* relative desync of the audio ouput */
+ /* CPU extensions (inherited from libvlc_t) */
+ u32 i_cpu;
+
/* Fast memcpy plugin used */
module_t * p_memcpy_module;
void* ( *pf_memcpy ) ( void *, const void *, size_t );
void* ( *pf_memset ) ( void *, int, size_t );
- /* The module bank */
- module_bank_t * p_module_bank;
-
- /* The message bank */
- msg_bank_t msg_bank;
-
/* Shared data - these structures are accessed directly from p_vlc by
* several modules */
input_channel_t * p_channel; /* channel library data */
/* Locks */
vlc_mutex_t config_lock; /* lock for the config file */
- vlc_mutex_t structure_lock; /* lock for the p_vlc tree */
-
- /* Object structure data */
- int i_counter; /* object counter */
- int i_objects; /* Attached objects count */
- vlc_object_t ** pp_objects; /* Array of all objects */
-
- /* Pointer to the big, evil global lock */
- vlc_mutex_t * p_global_lock;
- void ** pp_global_data;
-
- /* System-specific variables */
-#if defined( SYS_BEOS )
- vlc_object_t * p_appthread;
-#elif defined( WIN32 )
- SIGNALOBJECTANDWAIT SignalObjectAndWait;
- vlc_bool_t b_fast_mutex;
- int i_win9x_cv;
-#endif
};
* Collection of useful common types and macros definitions
*****************************************************************************
* Copyright (C) 1998, 1999, 2000 VideoLAN
- * $Id: vlc_common.h,v 1.27 2002/09/18 21:21:23 massiot Exp $
+ * $Id: vlc_common.h,v 1.28 2002/10/03 13:21:54 sam Exp $
*
* Authors: Samuel Hocevar <sam@via.ecp.fr>
* Vincent Seguin <seguin@via.ecp.fr>
* Classes declaration
*****************************************************************************/
+/* Internal types */
+typedef struct libvlc_t libvlc_t;
+
/* Messages */
typedef struct msg_bank_t msg_bank_t;
typedef struct msg_subscription_t msg_subscription_t;
volatile vlc_bool_t b_dead; /* set by the object */ \
volatile vlc_bool_t b_attached; /* set by the object */ \
\
- vlc_t * p_vlc; /* root of all evil */ \
+ libvlc_t * p_libvlc; /* root of all evil */ \
+ vlc_t * p_vlc; /* (root of all evil) - 1 */ \
\
volatile int i_refcount; /* usage count */ \
vlc_object_t * p_parent; /* our parent */ \
* cpu.h: CPU type detection
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: vlc_cpu.h,v 1.3 2002/07/31 20:56:50 sam Exp $
+ * $Id: vlc_cpu.h,v 1.4 2002/10/03 13:21:54 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
-#define CPUCapabilities(a) __CPUCapabilities(VLC_OBJECT(a))
-u32 __CPUCapabilities( vlc_object_t * );
+u32 CPUCapabilities( void );
* vlc_objects.h: vlc_object_t definition.
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: vlc_objects.h,v 1.10 2002/08/15 12:11:15 sam Exp $
+ * $Id: vlc_objects.h,v 1.11 2002/10/03 13:21:54 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
/* Object types */
#define VLC_OBJECT_ROOT (-1)
-#define VLC_OBJECT_MODULE (-2)
-#define VLC_OBJECT_INTF (-3)
-#define VLC_OBJECT_PLAYLIST (-4)
-#define VLC_OBJECT_ITEM (-5)
-#define VLC_OBJECT_INPUT (-6)
-#define VLC_OBJECT_DECODER (-7)
-#define VLC_OBJECT_VOUT (-8)
-#define VLC_OBJECT_AOUT (-9)
-#define VLC_OBJECT_SOUT (-10)
+#define VLC_OBJECT_VLC (-2)
+#define VLC_OBJECT_MODULE (-3)
+#define VLC_OBJECT_INTF (-4)
+#define VLC_OBJECT_PLAYLIST (-5)
+#define VLC_OBJECT_ITEM (-6)
+#define VLC_OBJECT_INPUT (-7)
+#define VLC_OBJECT_DECODER (-8)
+#define VLC_OBJECT_VOUT (-9)
+#define VLC_OBJECT_AOUT (-10)
+#define VLC_OBJECT_SOUT (-11)
#define VLC_OBJECT_GENERIC (-666)
/* Object search mode */
* rc.c : remote control stdin/stdout plugin for vlc
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: rc.c,v 1.5 2002/09/30 11:05:37 sam Exp $
+ * $Id: rc.c,v 1.6 2002/10/03 13:21:55 sam Exp $
*
* Authors: Peter Surda <shurdeek@panorama.sth.ac.at>
*
{
p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
FIND_ANYWHERE );
- //if( p_input )
+ if( p_input )
{
p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
FIND_PARENT );
* gtk_main.c : Gtk+ wrapper for gtk_main
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: gtk_main.c,v 1.6 2002/09/30 11:05:39 sam Exp $
+ * $Id: gtk_main.c,v 1.7 2002/10/03 13:21:55 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
- vlc_mutex_lock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->global_lock );
if( i_refcount > 0 )
{
i_refcount++;
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
return VLC_SUCCESS;
}
{
vlc_object_destroy( p_gtk_main );
i_refcount--;
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
return VLC_ETHREAD;
}
i_refcount++;
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
return VLC_SUCCESS;
}
*****************************************************************************/
static void Close( vlc_object_t *p_this )
{
- vlc_mutex_lock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->global_lock );
i_refcount--;
if( i_refcount > 0 )
{
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
return;
}
vlc_object_destroy( p_gtk_main );
p_gtk_main = NULL;
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->global_lock );
}
static gint foo(gpointer foo)
* libvlc.c: main libvlc source
*****************************************************************************
* Copyright (C) 1998-2002 VideoLAN
- * $Id: libvlc.c,v 1.33 2002/09/29 18:19:53 sam Exp $
+ * $Id: libvlc.c,v 1.34 2002/10/03 13:21:55 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
#include "libvlc.h"
/*****************************************************************************
- * The evil global variables. We handle them with care, don't worry.
+ * The evil global variable. We handle it with care, don't worry.
*****************************************************************************/
+static libvlc_t libvlc;
-/* This global lock is used for critical sections - don't abuse it! */
-static vlc_mutex_t global_lock;
-void * p_global_data;
-
-/* A list of all the currently allocated vlc objects */
-static int volatile i_vlc = 0;
-static vlc_t ** volatile pp_vlc = NULL;
+//#define GLOBAL_VLC NULL
+#define GLOBAL_VLC ((vlc_t*)libvlc.pp_children[1])
/*****************************************************************************
* Local prototypes
vlc_t * p_vlc;
vlc_bool_t b_failed = VLC_FALSE;
- /* This gives us a rather good protection against concurrent calls, but
- * an additional check will be necessary for complete thread safety. */
- if( i_vlc )
- {
- return VLC_EGENERIC;
- }
-
+ /* This call should be thread-safe, but an additional check will be
+ * necessary afterwards to check that only one p_vlc is created. */
p_vlc = vlc_create_r();
if( p_vlc == NULL )
/* We have created an object, which ensures us that p_global_lock has
* been properly initialized. We can now atomically check that we are
* the only p_vlc object. */
- vlc_mutex_lock( p_vlc->p_global_lock );
- if( i_vlc != 1 )
+#if 0
+ vlc_mutex_lock( libvlc.p_global_lock );
+ if( libvlc.i_children != 1 ) /* FIXME !!! FIXME */
{
b_failed = VLC_TRUE;
}
- vlc_mutex_unlock( p_vlc->p_global_lock );
+ vlc_mutex_unlock( libvlc.p_global_lock );
+#endif
/* There can be only one */
if( b_failed )
vlc_t * vlc_create_r( void )
{
- static int i_instance = 0;
+ int i_ret;
vlc_t * p_vlc = NULL;
- /* Allocate the main structure */
- p_vlc = vlc_object_create( p_vlc, VLC_OBJECT_ROOT );
+ /* vlc_threads_init *must* be the first internal call! No other call is
+ * allowed before the thread system has been initialized. */
+ i_ret = vlc_threads_init( &libvlc );
+ if( i_ret )
+ {
+ return NULL;
+ }
+
+ /* Now that the thread system is initialized, we don't have much, but
+ * at least we have libvlc.global_lock */
+ vlc_mutex_lock( &libvlc.global_lock );
+ if( !libvlc.b_ready )
+ {
+ vlc_mutex_init( &libvlc, &libvlc.structure_lock );
+ libvlc.p_global_data = NULL;
+ libvlc.b_ready = VLC_TRUE;
+
+ /* Guess what CPU we have */
+ libvlc.i_cpu = CPUCapabilities();
+
+ /* Initialize message queue */
+ msg_Create( &libvlc );
+
+ /* Announce who we are */
+ msg_Dbg( &libvlc, COPYRIGHT_MESSAGE );
+ msg_Dbg( &libvlc, "libvlc was configured with %s", CONFIGURE_LINE );
+
+ /* Initialize the module bank and and load the configuration of the
+ * main module. We need to do this at this stage to be able to display
+ * a short help if required by the user. (short help == main module
+ * options) */
+ module_InitBank( &libvlc );
+ module_LoadMain( &libvlc );
+ }
+ vlc_mutex_unlock( &libvlc.global_lock );
+
+ /* Allocate a vlc object */
+ p_vlc = vlc_object_create( &libvlc, VLC_OBJECT_VLC );
if( p_vlc == NULL )
{
return NULL;
p_vlc->psz_object_name = "root";
- p_vlc->p_global_lock = &global_lock;
- p_vlc->pp_global_data = &p_global_data;
-
- p_vlc->b_verbose = VLC_FALSE;
+ p_vlc->b_verbose = VLC_TRUE;
p_vlc->b_quiet = VLC_FALSE; /* FIXME: delay message queue output! */
- /* Initialize the threads system */
- vlc_threads_init( p_vlc );
-
/* Initialize mutexes */
vlc_mutex_init( p_vlc, &p_vlc->config_lock );
- vlc_mutex_init( p_vlc, &p_vlc->structure_lock );
/* Store our newly allocated structure in the global list */
- vlc_mutex_lock( p_vlc->p_global_lock );
- pp_vlc = realloc( pp_vlc, (i_vlc+1) * sizeof( vlc_t * ) );
- pp_vlc[ i_vlc ] = p_vlc;
- i_vlc++;
- p_vlc->i_instance = i_instance;
- i_instance++;
- vlc_mutex_unlock( p_vlc->p_global_lock );
+ vlc_object_attach( p_vlc, &libvlc );
/* Update the handle status */
p_vlc->i_status = VLC_STATUS_CREATED;
*****************************************************************************/
vlc_error_t vlc_init( int i_argc, char *ppsz_argv[] )
{
- return vlc_init_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL, i_argc, ppsz_argv );
+ return vlc_init_r( GLOBAL_VLC, i_argc, ppsz_argv );
}
vlc_error_t vlc_init_r( vlc_t *p_vlc, int i_argc, char *ppsz_argv[] )
return VLC_ESTATUS;
}
- /* Guess what CPU we have */
- p_vlc->i_cpu = CPUCapabilities( p_vlc );
-
- /*
- * Support for gettext
- */
+ /* Support for gettext */
#if defined( ENABLE_NLS ) && defined ( HAVE_GETTEXT )
# if defined( HAVE_LOCALE_H ) && defined( HAVE_LC_MESSAGES )
if( !setlocale( LC_MESSAGES, "" ) )
textdomain( PACKAGE );
#endif
- /*
- * Initialize message queue
- */
- msg_Create( p_vlc );
-
/*
* System specific initialization code
*/
p_vlc->psz_object_name = "vlc";
}
- /* Announce who we are */
- msg_Dbg( p_vlc, COPYRIGHT_MESSAGE );
- msg_Dbg( p_vlc, "libvlc was configured with %s", CONFIGURE_LINE );
-
- /*
- * Initialize the module bank and and load the configuration of the main
- * module. We need to do this at this stage to be able to display a short
- * help if required by the user. (short help == main module options)
- */
- module_InitBank( p_vlc );
- module_LoadMain( p_vlc );
-
/* Hack: insert the help module here */
p_help_module = vlc_object_create( p_vlc, VLC_OBJECT_MODULE );
if( p_help_module == NULL )
{
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EGENERIC;
}
p_help_module->psz_object_name = "help";
config_Duplicate( p_help_module, p_help_config );
- vlc_object_attach( p_help_module, p_vlc->p_module_bank );
+ vlc_object_attach( p_help_module, libvlc.p_module_bank );
/* End hack */
if( config_LoadCmdLine( p_vlc, &i_argc, ppsz_argv, VLC_TRUE ) )
vlc_object_detach( p_help_module );
config_Free( p_help_module );
vlc_object_destroy( p_help_module );
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EGENERIC;
}
{
config_Free( p_help_module );
vlc_object_destroy( p_help_module );
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EEXIT;
}
* list of configuration options exported by each module and loads their
* default values.
*/
- module_LoadBuiltins( p_vlc );
- module_LoadPlugins( p_vlc );
+ module_LoadBuiltins( &libvlc );
+ module_LoadPlugins( &libvlc );
msg_Dbg( p_vlc, "module bank initialized, found %i modules",
- p_vlc->p_module_bank->i_children );
+ libvlc.p_module_bank->i_children );
/* Hack: insert the help module here */
- vlc_object_attach( p_help_module, p_vlc->p_module_bank );
+ vlc_object_attach( p_help_module, libvlc.p_module_bank );
/* End hack */
/* Check for help on modules */
if( b_exit )
{
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EEXIT;
}
"that they are valid.\nPress the RETURN key to continue..." );
getchar();
#endif
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EGENERIC;
}
/* p_vlc inititalization. FIXME ? */
p_vlc->i_desync = config_GetInt( p_vlc, "desync" ) * (mtime_t)1000;
+
+ p_vlc->i_cpu = libvlc.i_cpu;
+
#if defined( __i386__ )
if( !config_GetInt( p_vlc, "mmx" ) )
p_vlc->i_cpu &= ~CPU_CAPABILITY_MMX;
{
module_Unneed( p_vlc, p_vlc->p_memcpy_module );
}
- module_EndBank( p_vlc );
- msg_Destroy( p_vlc );
+ //module_EndBank( p_vlc );
return VLC_EGENERIC;
}
*****************************************************************************/
vlc_error_t vlc_add_intf( const char *psz_module, vlc_bool_t b_block )
{
- return vlc_add_intf_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL,
+ return vlc_add_intf_r( GLOBAL_VLC,
psz_module, b_block );
}
*****************************************************************************/
vlc_error_t vlc_destroy( void )
{
- return vlc_destroy_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_destroy_r( GLOBAL_VLC );
}
vlc_error_t vlc_destroy_r( vlc_t *p_vlc )
{
- int i_index;
-
/* Check that the handle is valid */
if( !p_vlc || (p_vlc->i_status != VLC_STATUS_STOPPED
&& p_vlc->i_status != VLC_STATUS_CREATED) )
free( p_vlc->psz_homedir );
/*
- * Free module bank
+ * XXX: Free module bank !
*/
- module_EndBank( p_vlc );
+ //module_EndBank( p_vlc );
/*
* System specific cleaning code
*/
system_End( p_vlc );
- /*
- * Terminate messages interface and program
- */
- msg_Destroy( p_vlc );
-
/* Update the handle status */
p_vlc->i_status = VLC_STATUS_CREATED;
}
/* Update the handle status, just in case */
p_vlc->i_status = VLC_STATUS_NONE;
- /* Remove our structure from the global list */
- vlc_mutex_lock( p_vlc->p_global_lock );
- for( i_index = 0 ; i_index < i_vlc ; i_index++ )
- {
- if( pp_vlc[ i_index ] == p_vlc )
- {
- break;
- }
- }
-
- if( i_index == i_vlc )
- {
- fprintf( stderr, "error: trying to unregister %p which is not in "
- "the list\n", (void *)p_vlc );
- vlc_mutex_unlock( p_vlc->p_global_lock );
- vlc_object_destroy( p_vlc );
- return VLC_EGENERIC;
- }
-
- for( i_index++ ; i_index < i_vlc ; i_index++ )
- {
- pp_vlc[ i_index - 1 ] = pp_vlc[ i_index ];
- }
-
- i_vlc--;
- if( i_vlc )
- {
- pp_vlc = realloc( pp_vlc, i_vlc * sizeof( vlc_t * ) );
- }
- else
- {
- free( pp_vlc );
- pp_vlc = NULL;
- }
- vlc_mutex_unlock( p_vlc->p_global_lock );
-
- /* Stop thread system: last one out please shut the door! */
- vlc_threads_end( p_vlc );
-
/* Destroy mutexes */
- vlc_mutex_destroy( &p_vlc->structure_lock );
vlc_mutex_destroy( &p_vlc->config_lock );
+ vlc_object_detach( p_vlc );
+
vlc_object_destroy( p_vlc );
+ /* Stop thread system: last one out please shut the door! */
+ vlc_threads_end( &libvlc );
+
return VLC_SUCCESS;
}
*****************************************************************************/
vlc_error_t vlc_die( void )
{
- return vlc_die_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_die_r( GLOBAL_VLC );
}
vlc_error_t vlc_die_r( vlc_t *p_vlc )
*****************************************************************************/
vlc_status_t vlc_status( void )
{
- return vlc_status_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_status_r( GLOBAL_VLC );
}
vlc_status_t vlc_status_r( vlc_t *p_vlc )
*****************************************************************************/
vlc_error_t vlc_add_target( const char *psz_target, int i_mode, int i_pos )
{
- return vlc_add_target_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL,
+ return vlc_add_target_r( GLOBAL_VLC,
psz_target, i_mode, i_pos );
}
*****************************************************************************/
vlc_error_t vlc_set( const char *psz_var, const char *psz_val )
{
- return vlc_set_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL, psz_var, psz_val );
+ return vlc_set_r( GLOBAL_VLC, psz_var, psz_val );
}
vlc_error_t vlc_set_r( vlc_t *p_vlc, const char *psz_var, const char *psz_val )
*****************************************************************************/
vlc_error_t vlc_play( )
{
- return vlc_play_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_play_r( GLOBAL_VLC );
}
vlc_error_t vlc_play_r( vlc_t *p_vlc )
*****************************************************************************/
vlc_error_t vlc_stop( )
{
- return vlc_stop_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_stop_r( GLOBAL_VLC );
}
vlc_error_t vlc_stop_r( vlc_t *p_vlc )
*****************************************************************************/
vlc_error_t vlc_pause( )
{
- return vlc_pause_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_pause_r( GLOBAL_VLC );
}
vlc_error_t vlc_pause_r( vlc_t *p_vlc )
*****************************************************************************/
vlc_error_t vlc_fullscreen( )
{
- return vlc_fullscreen_r( ( i_vlc == 1 ) ? pp_vlc[0] : NULL );
+ return vlc_fullscreen_r( GLOBAL_VLC );
}
vlc_error_t vlc_fullscreen_r( vlc_t *p_vlc )
* cpu.c: CPU detection code
*****************************************************************************
* Copyright (C) 1998-2002 VideoLAN
- * $Id: cpu.c,v 1.6 2002/08/19 11:37:57 sam Exp $
+ * $Id: cpu.c,v 1.7 2002/10/03 13:21:55 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
* Christophe Massiot <massiot@via.ecp.fr>
* Local prototypes
*****************************************************************************/
static void SigHandler ( int );
-static u32 Capabilities ( vlc_object_t * );
/*****************************************************************************
* Global variables - they're needed for signal handling
/*****************************************************************************
* CPUCapabilities: get the CPU capabilities
*****************************************************************************
- * This function is a wrapper around Capabilities().
- *****************************************************************************/
-u32 __CPUCapabilities( vlc_object_t *p_this )
-{
- u32 i_capabilities;
-
- vlc_mutex_lock( p_this->p_vlc->p_global_lock );
- i_capabilities = Capabilities( p_this );
- vlc_mutex_unlock( p_this->p_vlc->p_global_lock );
-
- return i_capabilities;
-}
-
-/*****************************************************************************
- * Capabilities: list the processors MMX support and other capabilities
- *****************************************************************************
* This function is called to list extensions the CPU may have.
*****************************************************************************/
-static u32 Capabilities( vlc_object_t *p_this )
+u32 CPUCapabilities( void )
{
volatile u32 i_capabilities = CPU_CAPABILITY_NONE;
* modules, especially intf modules. See config.h for output configuration.
*****************************************************************************
* Copyright (C) 1998-2002 VideoLAN
- * $Id: messages.c,v 1.10 2002/08/26 09:12:46 sam Exp $
+ * $Id: messages.c,v 1.11 2002/10/03 13:21:55 sam Exp $
*
* Authors: Vincent Seguin <seguin@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
void __msg_Create( vlc_object_t *p_this )
{
/* Message queue initialization */
- vlc_mutex_init( p_this, &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_init( p_this, &p_this->p_libvlc->msg_bank.lock );
- p_this->p_vlc->msg_bank.b_configured = VLC_FALSE;
- p_this->p_vlc->msg_bank.b_overflow = VLC_FALSE;
+ p_this->p_libvlc->msg_bank.b_configured = VLC_FALSE;
+ p_this->p_libvlc->msg_bank.b_overflow = VLC_FALSE;
- p_this->p_vlc->msg_bank.i_start = 0;
- p_this->p_vlc->msg_bank.i_stop = 0;
+ p_this->p_libvlc->msg_bank.i_start = 0;
+ p_this->p_libvlc->msg_bank.i_stop = 0;
- p_this->p_vlc->msg_bank.i_sub = 0;
- p_this->p_vlc->msg_bank.pp_sub = NULL;
+ p_this->p_libvlc->msg_bank.i_sub = 0;
+ p_this->p_libvlc->msg_bank.pp_sub = NULL;
}
/*****************************************************************************
{
int i_index;
- vlc_mutex_lock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_lock( &p_this->p_libvlc->msg_bank.lock );
- p_this->p_vlc->msg_bank.b_configured = VLC_TRUE;
+ p_this->p_libvlc->msg_bank.b_configured = VLC_TRUE;
- for( i_index = p_this->p_vlc->msg_bank.i_start;
- i_index != p_this->p_vlc->msg_bank.i_stop;
+ for( i_index = p_this->p_libvlc->msg_bank.i_start;
+ i_index != p_this->p_libvlc->msg_bank.i_stop;
i_index = (i_index+1) % VLC_MSG_QSIZE )
{
- PrintMsg( p_this, &p_this->p_vlc->msg_bank.msg[i_index] );
+ PrintMsg( p_this, &p_this->p_libvlc->msg_bank.msg[i_index] );
}
- FlushMsg( &p_this->p_vlc->msg_bank );
+ FlushMsg( &p_this->p_libvlc->msg_bank );
- vlc_mutex_unlock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->msg_bank.lock );
}
/*****************************************************************************
*****************************************************************************/
void __msg_Destroy( vlc_object_t *p_this )
{
- if( p_this->p_vlc->msg_bank.i_sub )
+ if( p_this->p_libvlc->msg_bank.i_sub )
{
msg_Err( p_this, "stale interface subscribers" );
}
/* Flush the queue */
- if( !p_this->p_vlc->msg_bank.b_configured )
+ if( !p_this->p_libvlc->msg_bank.b_configured )
{
msg_Flush( p_this );
}
else
{
- FlushMsg( &p_this->p_vlc->msg_bank );
+ FlushMsg( &p_this->p_libvlc->msg_bank );
}
/* Destroy lock */
- vlc_mutex_destroy( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_destroy( &p_this->p_libvlc->msg_bank.lock );
}
/*****************************************************************************
*****************************************************************************/
msg_subscription_t *__msg_Subscribe( vlc_object_t *p_this )
{
+ msg_bank_t *p_bank = &p_this->p_libvlc->msg_bank;
msg_subscription_t *p_sub = malloc( sizeof( msg_subscription_t ) );
- vlc_mutex_lock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_lock( &p_bank->lock );
/* Add subscription to the list */
- p_this->p_vlc->msg_bank.i_sub++;
- p_this->p_vlc->msg_bank.pp_sub = realloc( p_this->p_vlc->msg_bank.pp_sub,
- p_this->p_vlc->msg_bank.i_sub * sizeof( msg_subscription_t* ) );
+ p_bank->i_sub++;
+ p_bank->pp_sub = realloc( p_bank->pp_sub,
+ p_bank->i_sub * sizeof( msg_subscription_t* ) );
- p_this->p_vlc->msg_bank.pp_sub[ p_this->p_vlc->msg_bank.i_sub - 1 ] = p_sub;
+ p_bank->pp_sub[ p_bank->i_sub - 1 ] = p_sub;
- p_sub->i_start = p_this->p_vlc->msg_bank.i_start;
- p_sub->pi_stop = &p_this->p_vlc->msg_bank.i_stop;
+ p_sub->i_start = p_bank->i_start;
+ p_sub->pi_stop = &p_bank->i_stop;
- p_sub->p_msg = p_this->p_vlc->msg_bank.msg;
- p_sub->p_lock = &p_this->p_vlc->msg_bank.lock;
+ p_sub->p_msg = p_bank->msg;
+ p_sub->p_lock = &p_bank->lock;
- vlc_mutex_unlock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_unlock( &p_bank->lock );
return p_sub;
}
*****************************************************************************/
void __msg_Unsubscribe( vlc_object_t *p_this, msg_subscription_t *p_sub )
{
+ msg_bank_t *p_bank = &p_this->p_libvlc->msg_bank;
int i_index;
- vlc_mutex_lock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_lock( &p_bank->lock );
/* Sanity check */
- if( !p_this->p_vlc->msg_bank.i_sub )
+ if( !p_bank->i_sub )
{
msg_Err( p_this, "no subscriber in the list" );
return;
}
/* Look for the appropriate subscription */
- for( i_index = 0; i_index < p_this->p_vlc->msg_bank.i_sub; i_index++ )
+ for( i_index = 0; i_index < p_bank->i_sub; i_index++ )
{
- if( p_this->p_vlc->msg_bank.pp_sub[ i_index ] == p_sub )
+ if( p_bank->pp_sub[ i_index ] == p_sub )
{
break;
}
}
- if( p_this->p_vlc->msg_bank.pp_sub[ i_index ] != p_sub )
+ if( p_bank->pp_sub[ i_index ] != p_sub )
{
msg_Err( p_this, "subscriber not found" );
- vlc_mutex_unlock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_unlock( &p_bank->lock );
return;
}
/* Remove this subscription */
- for( ; i_index < (p_this->p_vlc->msg_bank.i_sub - 1); i_index++ )
+ for( ; i_index < (p_bank->i_sub - 1); i_index++ )
{
- p_this->p_vlc->msg_bank.pp_sub[ i_index ] = p_this->p_vlc->msg_bank.pp_sub[ i_index+1 ];
+ p_bank->pp_sub[ i_index ] = p_bank->pp_sub[ i_index+1 ];
}
- p_this->p_vlc->msg_bank.i_sub--;
- if( p_this->p_vlc->msg_bank.i_sub )
+ p_bank->i_sub--;
+ if( p_bank->i_sub )
{
- p_this->p_vlc->msg_bank.pp_sub = realloc( p_this->p_vlc->msg_bank.pp_sub,
- p_this->p_vlc->msg_bank.i_sub * sizeof( msg_subscription_t* ) );
+ p_bank->pp_sub = realloc( p_bank->pp_sub, p_bank->i_sub
+ * sizeof( msg_subscription_t* ) );
}
else
{
- free( p_this->p_vlc->msg_bank.pp_sub );
- p_this->p_vlc->msg_bank.pp_sub = NULL;
+ free( p_bank->pp_sub );
+ p_bank->pp_sub = NULL;
}
- vlc_mutex_unlock( &p_this->p_vlc->msg_bank.lock );
+ vlc_mutex_unlock( &p_bank->lock );
}
/*****************************************************************************
static void QueueMsg( vlc_object_t *p_this, int i_type, const char *psz_module,
const char *psz_format, va_list args )
{
- msg_bank_t * p_bank = &p_this->p_vlc->msg_bank; /* message bank */
- char * psz_str = NULL; /* formatted message string */
- msg_item_t * p_item = NULL; /* pointer to message */
- msg_item_t item; /* message in case of a full queue */
+ msg_bank_t * p_bank = &p_this->p_libvlc->msg_bank; /* message bank */
+ char * psz_str = NULL; /* formatted message string */
+ msg_item_t * p_item = NULL; /* pointer to message */
+ msg_item_t item; /* message in case of a full queue */
#ifdef WIN32
- char * psz_temp;
+ char * psz_temp;
#endif
#ifndef HAVE_VASPRINTF
- int i_size = strlen(psz_format) + INTF_MAX_MSG_SIZE;
+ int i_size = strlen(psz_format) + INTF_MAX_MSG_SIZE;
#endif
/*
/* Check there is room in the queue for our message */
if( p_bank->b_overflow )
{
- FlushMsg( &p_this->p_vlc->msg_bank );
+ FlushMsg( p_bank );
if( ((p_bank->i_stop - p_bank->i_start + 1) % VLC_MSG_QSIZE) == 0 )
{
}
else if( ((p_bank->i_stop - p_bank->i_start + 2) % VLC_MSG_QSIZE) == 0 )
{
- FlushMsg( &p_this->p_vlc->msg_bank );
+ FlushMsg( p_bank );
if( ((p_bank->i_stop - p_bank->i_start + 2) % VLC_MSG_QSIZE) == 0 )
{
char *psz_object = "private";
int i_type = p_item->i_type;
- if( p_this->p_vlc->b_quiet || !p_this->p_vlc->msg_bank.b_configured )
+ if( /*p_this->p_vlc->b_quiet ||*/ !p_this->p_libvlc->msg_bank.b_configured )
{
return;
}
- if( !p_this->p_vlc->b_verbose &&
+ if( /*!p_this->p_vlc->b_verbose && */
( (i_type == VLC_MSG_WARN) || (i_type == VLC_MSG_DBG) ) )
{
return;
switch( p_item->i_object_type )
{
case VLC_OBJECT_ROOT: psz_object = "root"; break;
+ case VLC_OBJECT_VLC: psz_object = "vlc"; break;
case VLC_OBJECT_MODULE: psz_object = "module"; break;
case VLC_OBJECT_INTF: psz_object = "interface"; break;
case VLC_OBJECT_PLAYLIST: psz_object = "playlist"; break;
}
/* Send the message to stderr */
- if( p_this->p_vlc->b_color )
+ if( /*p_this->p_vlc->b_color*/1 )
{
- fprintf( stderr, "[" GREEN "%.2x" GRAY ":" GREEN "%.6x" GRAY "] "
- "%s %s%s: %s%s" GRAY "\n", p_this->p_vlc->i_instance,
+ fprintf( stderr, "[" GREEN "%.6x" GRAY "] %s %s%s: %s%s" GRAY "\n",
p_item->i_object_id, p_item->psz_module, psz_object,
ppsz_type[i_type], ppsz_color[i_type],
p_item->psz_msg );
}
else
{
- fprintf( stderr, "[%.2x:%.6x] %s %s%s: %s\n",
- p_this->p_vlc->i_instance, p_item->i_object_id,
+ fprintf( stderr, "[%.6x] %s %s%s: %s\n", p_item->i_object_id,
p_item->psz_module, psz_object, ppsz_type[i_type],
p_item->psz_msg );
}
* modules.c : Builtin and plugin modules management functions
*****************************************************************************
* Copyright (C) 2001 VideoLAN
- * $Id: modules.c,v 1.93 2002/09/30 11:05:42 sam Exp $
+ * $Id: modules.c,v 1.94 2002/10/03 13:21:55 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
* Ethan C. Baldridge <BaldridgeE@cadmus.com>
#endif
/* Everything worked, attach the object */
- p_this->p_vlc->p_module_bank = p_bank;
- vlc_object_attach( p_bank, p_this->p_vlc );
+ p_this->p_libvlc->p_module_bank = p_bank;
+ vlc_object_attach( p_bank, p_this->p_libvlc );
return;
}
{
module_t * p_next;
- vlc_object_detach( p_this->p_vlc->p_module_bank );
+ vlc_object_detach( p_this->p_libvlc->p_module_bank );
- while( p_this->p_vlc->p_module_bank->i_children )
+ while( p_this->p_libvlc->p_module_bank->i_children )
{
- p_next = (module_t *)p_this->p_vlc->p_module_bank->pp_children[0];
+ p_next = (module_t *)p_this->p_libvlc->p_module_bank->pp_children[0];
if( DeleteModule( p_next ) )
{
}
}
- vlc_object_destroy( p_this->p_vlc->p_module_bank );
+ vlc_object_destroy( p_this->p_libvlc->p_module_bank );
return;
}
/* We need to fill these since they may be needed by CallEntry() */
p_module->psz_filename = psz_file;
p_module->handle = handle;
- p_module->p_symbols = &p_this->p_vlc->p_module_bank->symbols;
+ p_module->p_symbols = &p_this->p_libvlc->p_module_bank->symbols;
/* Initialize the module: fill p_module->psz_object_name, default config */
if( CallEntry( p_module ) != 0 )
/* msg_Dbg( p_this, "plugin \"%s\", %s",
p_module->psz_object_name, p_module->psz_longname ); */
- vlc_object_attach( p_module, p_this->p_vlc->p_module_bank );
+ vlc_object_attach( p_module, p_this->p_libvlc->p_module_bank );
return 0;
}
/* msg_Dbg( p_this, "builtin \"%s\", %s",
p_module->psz_object_name, p_module->psz_longname ); */
- vlc_object_attach( p_module, p_this->p_vlc->p_module_bank );
+ vlc_object_attach( p_module, p_this->p_libvlc->p_module_bank );
return 0;
}
* objects.c: vlc_object_t handling
*****************************************************************************
* Copyright (C) 2002 VideoLAN
- * $Id: objects.c,v 1.20 2002/08/24 17:04:36 gbazin Exp $
+ * $Id: objects.c,v 1.21 2002/10/03 13:21:55 sam Exp $
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
switch( i_type )
{
case VLC_OBJECT_ROOT:
- i_size = sizeof(vlc_t);
+ i_size = sizeof(libvlc_t);
psz_type = "root";
break;
+ case VLC_OBJECT_VLC:
+ i_size = sizeof(vlc_t);
+ psz_type = "vlc";
+ break;
case VLC_OBJECT_MODULE:
i_size = sizeof(module_t);
psz_type = "module";
break;
}
- p_new = malloc( i_size );
-
- if( !p_new )
+ if( i_type == VLC_OBJECT_ROOT )
{
- return NULL;
+ p_new = p_this;
}
+ else
+ {
+ p_new = malloc( i_size );
+
+ if( !p_new )
+ {
+ return NULL;
+ }
- memset( p_new, 0, i_size );
+ memset( p_new, 0, i_size );
+ }
p_new->i_object_type = i_type;
p_new->psz_object_type = psz_type;
p_new->b_dead = VLC_FALSE;
p_new->b_attached = VLC_FALSE;
- /* If i_type is root, then p_new is our own p_vlc */
+ /* If i_type is root, then p_new is our own p_libvlc */
if( i_type == VLC_OBJECT_ROOT )
{
/* We are the first object ... no need to lock. */
- p_new->p_vlc = (vlc_t*)p_new;
+ p_new->p_libvlc = (libvlc_t*)p_new;
+ p_new->p_vlc = NULL;
- p_new->p_vlc->i_counter = 0;
+ p_new->p_libvlc->i_counter = 0;
p_new->i_object_id = 0;
- p_new->p_vlc->i_objects = 1;
- p_new->p_vlc->pp_objects = malloc( sizeof(vlc_object_t *) );
- p_new->p_vlc->pp_objects[0] = p_new;
+ p_new->p_libvlc->i_objects = 1;
+ p_new->p_libvlc->pp_objects = malloc( sizeof(vlc_object_t *) );
+ p_new->p_libvlc->pp_objects[0] = p_new;
p_new->b_attached = VLC_TRUE;
}
else
{
- p_new->p_vlc = p_this->p_vlc;
+ p_new->p_libvlc = p_this->p_libvlc;
+ p_new->p_vlc = ( i_type == VLC_OBJECT_VLC ) ? (vlc_t*)p_new
+ : p_this->p_vlc;
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
- p_new->p_vlc->i_counter++;
- p_new->i_object_id = p_new->p_vlc->i_counter;
+ p_new->p_libvlc->i_counter++;
+ p_new->i_object_id = p_new->p_libvlc->i_counter;
/* Wooohaa! If *this* fails, we're in serious trouble! Anyway it's
* useless to try and recover anything if pp_objects gets smashed. */
- p_new->p_vlc->i_objects++;
- p_new->p_vlc->pp_objects =
- realloc( p_new->p_vlc->pp_objects,
- p_new->p_vlc->i_objects * sizeof(vlc_object_t *) );
- p_new->p_vlc->pp_objects[ p_new->p_vlc->i_objects - 1 ] = p_new;
+ p_new->p_libvlc->i_objects++;
+ p_new->p_libvlc->pp_objects =
+ realloc( p_new->p_libvlc->pp_objects,
+ p_new->p_libvlc->i_objects * sizeof(vlc_object_t *) );
+ p_new->p_libvlc->pp_objects[ p_new->p_libvlc->i_objects - 1 ] = p_new;
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
p_new->p_parent = NULL;
{
int i_index;
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
- i_index = FindIndex( p_this, p_this->p_vlc->pp_objects,
- p_this->p_vlc->i_objects );
- memmove( p_this->p_vlc->pp_objects + i_index,
- p_this->p_vlc->pp_objects + i_index + 1,
- (p_this->p_vlc->i_objects - i_index - 1)
+ i_index = FindIndex( p_this, p_this->p_libvlc->pp_objects,
+ p_this->p_libvlc->i_objects );
+ memmove( p_this->p_libvlc->pp_objects + i_index,
+ p_this->p_libvlc->pp_objects + i_index + 1,
+ (p_this->p_libvlc->i_objects - i_index - 1)
* sizeof( vlc_object_t *) );
- p_this->p_vlc->pp_objects =
- realloc( p_this->p_vlc->pp_objects,
- (p_this->p_vlc->i_objects - 1) * sizeof(vlc_object_t *) );
+ p_this->p_libvlc->pp_objects =
+ realloc( p_this->p_libvlc->pp_objects,
+ (p_this->p_libvlc->i_objects - 1) * sizeof(vlc_object_t *) );
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
else
{
/* We are the root object ... no need to lock. */
- free( p_this->p_vlc->pp_objects );
- p_this->p_vlc->pp_objects = NULL;
+ free( p_this->p_libvlc->pp_objects );
+ p_this->p_libvlc->pp_objects = NULL;
}
- p_this->p_vlc->i_objects--;
+ p_this->p_libvlc->i_objects--;
vlc_mutex_destroy( &p_this->object_lock );
vlc_cond_destroy( &p_this->object_wait );
{
vlc_object_t *p_found;
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
/* If we are of the requested type ourselves, don't look further */
if( !(i_mode & FIND_STRICT) && p_this->i_object_type == i_type )
{
p_this->i_refcount++;
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
return p_this;
}
p_found = FindObject( p_this, i_type, i_mode );
}
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
return p_found;
}
*****************************************************************************/
void __vlc_object_yield( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
p_this->i_refcount++;
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_release( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
p_this->i_refcount--;
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_attach( vlc_object_t *p_this, vlc_object_t *p_parent )
{
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
/* Attach the parent to its child */
p_this->p_parent = p_parent;
SetAttachment( p_this, VLC_TRUE );
}
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
*****************************************************************************/
void __vlc_object_detach( vlc_object_t *p_this )
{
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
if( !p_this->p_parent )
{
msg_Err( p_this, "object is not attached" );
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
return;
}
}
DetachObject( p_this );
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
{
vlc_list_t *p_list = NewList();
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
/* Look for the objects */
if( (i_mode & 0x000f) == FIND_ANYWHERE )
{
vlc_object_t **pp_current, **pp_end;
- pp_current = p_this->p_vlc->pp_objects;
- pp_end = pp_current + p_this->p_vlc->i_objects;
+ pp_current = p_this->p_libvlc->pp_objects;
+ pp_end = pp_current + p_this->p_libvlc->i_objects;
for( ; pp_current < pp_end ; pp_current++ )
{
msg_Err( p_this, "unimplemented!" );
}
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
return p_list;
}
{
vlc_object_t **pp_current, **pp_end;
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
- pp_current = p_this->p_vlc->pp_objects;
- pp_end = pp_current + p_this->p_vlc->i_objects;
+ pp_current = p_this->p_libvlc->pp_objects;
+ pp_end = pp_current + p_this->p_libvlc->i_objects;
for( ; pp_current < pp_end ; pp_current++ )
{
}
else
{
- msg_Info( p_this->p_vlc, "o %.6x %s (not attached)",
+ vlc_object_t *p_me = p_this->p_vlc
+ ? (vlc_object_t *)p_this->p_vlc
+ : (vlc_object_t *)p_this->p_libvlc;
+ msg_Info( p_me, "o %.6x %s (not attached)",
(*pp_current)->i_object_id,
(*pp_current)->psz_object_type );
}
}
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
{
char psz_foo[2 * MAX_DUMPSTRUCTURE_DEPTH + 1];
- vlc_mutex_lock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_lock( &p_this->p_libvlc->structure_lock );
psz_foo[0] = '|';
DumpStructure( p_this, 0, psz_foo );
- vlc_mutex_unlock( &p_this->p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_this->p_libvlc->structure_lock );
}
/*****************************************************************************
{
if( p_list->i_count )
{
- vlc_t * p_vlc = p_list->pp_objects[0]->p_vlc;
+ libvlc_t * p_libvlc = p_list->pp_objects[0]->p_libvlc;
vlc_object_t ** pp_current = p_list->pp_objects;
- vlc_mutex_lock( &p_vlc->structure_lock );
+ vlc_mutex_lock( &p_libvlc->structure_lock );
while( pp_current[0] )
{
pp_current++;
}
- vlc_mutex_unlock( &p_vlc->structure_lock );
+ vlc_mutex_unlock( &p_libvlc->structure_lock );
}
free( p_list );
static void PrintObject( vlc_object_t *p_this, const char *psz_prefix )
{
char psz_children[20], psz_refcount[20], psz_thread[20], psz_name[50];
+ vlc_object_t *p_me;
psz_name[0] = '\0';
if( p_this->psz_object_name )
psz_thread[19] = '\0';
}
- msg_Info( p_this->p_vlc, "%so %.6x %s%s%s%s%s", psz_prefix,
+ p_me = p_this->p_vlc ? (vlc_object_t *)p_this->p_vlc
+ : (vlc_object_t *)p_this->p_libvlc;
+ msg_Info( p_me, "%so %.6x %s%s%s%s%s", psz_prefix,
p_this->i_object_id, p_this->psz_object_type,
psz_name, psz_thread, psz_refcount, psz_children );
}
* threads.c : threads implementation for the VideoLAN client
*****************************************************************************
* Copyright (C) 1999, 2000, 2001, 2002 VideoLAN
- * $Id: threads.c,v 1.17 2002/09/29 18:16:04 sam Exp $
+ * $Id: threads.c,v 1.18 2002/10/03 13:21:55 sam Exp $
*
* Authors: Jean-Marc Dressler <polux@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
#define VLC_THREADS_READY 3
/*****************************************************************************
- * Prototype for GPROF wrapper
- *****************************************************************************/
-#ifdef GPROF
-/* Wrapper function for profiling */
-static void * vlc_thread_wrapper ( void *p_wrapper );
-
-# ifdef WIN32
-
-# define ITIMER_REAL 1
-# define ITIMER_PROF 2
-
-struct itimerval
-{
- struct timeval it_value;
- struct timeval it_interval;
-};
-
-int setitimer(int kind, const struct itimerval* itnew, struct itimerval* itold);
-# endif /* WIN32 */
-
-typedef struct wrapper_t
-{
- /* Data lock access */
- vlc_mutex_t lock;
- vlc_cond_t wait;
-
- /* Data used to spawn the real thread */
- vlc_thread_func_t func;
- void *p_data;
-
- /* Profiling timer passed to the thread */
- struct itimerval itimer;
-
-} wrapper_t;
-
-#endif /* GPROF */
-
-/*****************************************************************************
- * Global mutexes for lazy initialization of the threads system
+ * Global mutex for lazy initialization of the threads system
*****************************************************************************/
static volatile int i_initializations = 0;
#if defined( PTH_INIT_IN_PTH_H )
- /* Unimplemented */
#elif defined( ST_INIT_IN_ST_H )
- /* Unimplemented */
#elif defined( WIN32 )
- /* Unimplemented */
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
static pthread_mutex_t once_mutex = PTHREAD_MUTEX_INITIALIZER;
#elif defined( HAVE_CTHREADS_H )
- /* Unimplemented */
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- /* Unimplemented */
#endif
/*****************************************************************************
int __vlc_threads_init( vlc_object_t *p_this )
{
static volatile int i_status = VLC_THREADS_UNINITIALIZED;
- int i_ret = 0;
+ libvlc_t *p_libvlc = (libvlc_t *)p_this;
+ int i_ret = VLC_SUCCESS;
+
+ /* If we have lazy mutex initialization, use it. Otherwise, we just
+ * hope nothing wrong happens. */
#if defined( PTH_INIT_IN_PTH_H )
- /* Unimplemented */
#elif defined( ST_INIT_IN_ST_H )
- /* Unimplemented */
#elif defined( WIN32 )
HINSTANCE hInstLib;
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
pthread_mutex_lock( &once_mutex );
#elif defined( HAVE_CTHREADS_H )
- /* Unimplemented */
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- /* Unimplemented */
#endif
if( i_status == VLC_THREADS_UNINITIALIZED )
{
i_status = VLC_THREADS_PENDING;
+ /* We should be safe now. Do all the initialization stuff we want. */
+ vlc_object_create( p_libvlc, VLC_OBJECT_ROOT );
+ p_libvlc->b_ready = VLC_FALSE;
+
#if defined( PTH_INIT_IN_PTH_H )
i_ret = pth_init();
+
#elif defined( ST_INIT_IN_ST_H )
i_ret = st_init();
+
#elif defined( WIN32 )
- /* dynamically get the address of SignalObjectAndWait */
+ /* Dynamically get the address of SignalObjectAndWait */
if( GetVersion() < 0x80000000 )
{
/* We are running on NT/2K/XP, we can use SignalObjectAndWait */
hInstLib = LoadLibrary( "kernel32" );
if( hInstLib )
{
- p_this->p_vlc->SignalObjectAndWait =
+ p_libvlc->SignalObjectAndWait =
(SIGNALOBJECTANDWAIT)GetProcAddress( hInstLib,
"SignalObjectAndWait" );
}
}
else
{
- p_this->p_vlc->SignalObjectAndWait = NULL;
+ p_libvlc->SignalObjectAndWait = NULL;
}
- p_this->p_vlc->b_fast_mutex = 0;
- p_this->p_vlc->i_win9x_cv = 0;
+ p_libvlc->b_fast_mutex = 0;
+ p_libvlc->i_win9x_cv = 0;
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
- /* Unimplemented */
#elif defined( HAVE_CTHREADS_H )
- /* Unimplemented */
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- /* Unimplemented */
#endif
+ vlc_mutex_init( p_libvlc, &p_libvlc->global_lock );
+
if( i_ret )
{
i_status = VLC_THREADS_ERROR;
}
else
{
- vlc_mutex_init( p_this, p_this->p_vlc->p_global_lock );
+ i_initializations++;
i_status = VLC_THREADS_READY;
}
}
else
{
- i_ret = ( i_status == VLC_THREADS_READY );
+ /* Just increment the initialization count */
+ i_initializations++;
}
- i_initializations++;
-
+ /* If we have lazy mutex initialization support, unlock the mutex;
+ * otherwize, do a naive wait loop. */
#if defined( PTH_INIT_IN_PTH_H )
- /* Unimplemented */
+ while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( ST_INIT_IN_ST_H )
- /* Unimplemented */
+ while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( WIN32 )
- /* Unimplemented */
+ while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
pthread_mutex_unlock( &once_mutex );
- return i_ret;
#elif defined( HAVE_CTHREADS_H )
- /* Unimplemented */
+ while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#elif defined( HAVE_KERNEL_SCHEDULER_H )
- /* Unimplemented */
+ while( i_status == VLC_THREADS_PENDING ) msleep( THREAD_SLEEP );
#endif
- /* Wait until the other thread has initialized the thread library */
- while( i_status == VLC_THREADS_PENDING )
+ if( i_status != VLC_THREADS_READY )
{
- msleep( THREAD_SLEEP );
+ return VLC_ETHREAD;
}
- return i_status == VLC_THREADS_READY;
+ return i_ret;
}
/*****************************************************************************
{
return pth_kill();
}
- return 0;
#elif defined( ST_INIT_IN_ST_H )
i_initializations--;
- return 0;
#elif defined( WIN32 )
i_initializations--;
- return 0;
#elif defined( PTHREAD_COND_T_IN_PTHREAD_H )
pthread_mutex_lock( &once_mutex );
i_initializations--;
pthread_mutex_unlock( &once_mutex );
- return 0;
#elif defined( HAVE_CTHREADS_H )
i_initializations--;
- return 0;
#elif defined( HAVE_KERNEL_SCHEDULER_H )
i_initializations--;
- return 0;
#endif
+ return VLC_SUCCESS;
}
+/*****************************************************************************
+ * Prototype for GPROF wrapper
+ *****************************************************************************/
+#ifdef GPROF
+/* Wrapper function for profiling */
+static void * vlc_thread_wrapper ( void *p_wrapper );
+
+# ifdef WIN32
+
+# define ITIMER_REAL 1
+# define ITIMER_PROF 2
+
+struct itimerval
+{
+ struct timeval it_value;
+ struct timeval it_interval;
+};
+
+int setitimer(int kind, const struct itimerval* itnew, struct itimerval* itold);
+# endif /* WIN32 */
+
+typedef struct wrapper_t
+{
+ /* Data lock access */
+ vlc_mutex_t lock;
+ vlc_cond_t wait;
+
+ /* Data used to spawn the real thread */
+ vlc_thread_func_t func;
+ void *p_data;
+
+ /* Profiling timer passed to the thread */
+ struct itimerval itimer;
+
+} wrapper_t;
+
+#endif /* GPROF */
+
/*****************************************************************************
* vlc_mutex_init: initialize a mutex
*****************************************************************************/
projects / vlc / commitdiff