Skip to content

V
vlc-1.1
Commit f8da8c95 authored by Sam Hocevar's avatar Sam Hocevar
Browse files
Options

. all plugins now compile with -fPIC. 

 . made the audio_output API a bit simpler.

 . got rid of modules_config.h.

 . fixed `make install' rule.

 . fixed warnings in the MMX YUV compilation.

 . probably fixed a bug in the input : pp_foo structures were free()d at
   the end, but this was useless since the last call to realloc() is
   equivalent to free(), and two consecutive calls to free() aren't a
   goo idea.

 . we check that the version number match and that we don't already have
   a module by that name when loading a new module.

 . all public module_* functions now properly lock the module bank.

 . the audio_output now uses the new module API ; EsounD and DSP modules
   have been ported, which should be enough for Henri to port the ALSA one.


   The new plugin API is now much simpler ; it's now just a matter of
calling module_Need( p_main->p_module_bank, MODULE_CAPABILITY_FOO, p_data );
and if successful we get the best module. Capabilities can be ORed, so that
one can ask for a plugin that does VOUT _and_ INTF actions for instance.

   It's not complete yet though -- by making it generic I had to do a few
ugly casts here and there, which I am going to fix ASAP. Also, command line
selection of a plugin does not work yet.

   The switch to the new plugin API has probably broken the BeOS audio
output ; we can either wait until the whole vlc has switched to the new
plugins, or create a separate beos_sound.so that conforms to the new API.
parent b7b3386b
Show whitespace changes
Inline Side-by-side
Showing with 695 additions and 610 deletions
Makefile.in
View file @ f8da8c95
......@@ -150,9 +150,7 @@ endif
#
# C compiler flags: plugin compilation
#
ifneq (,$(findstring solaris,$(SYS)))
PCFLAGS += -fPIC
endif
#
# C compiler flags: dependancies
......@@ -407,9 +405,9 @@ install:
mkdir -p $(prefix)/bin
$(INSTALL) vlc $(prefix)/bin
# ugly
for alias in "" @ALIASES@ ; do if test $$alias ; then ln -s vlc $(prefix)/bin/$$alias ; fi ; done
for alias in "" @ALIASES@ ; do if test $$alias ; then rm -f $(prefix)/bin/$$alias && ln -s vlc $(prefix)/bin/$$alias ; fi ; done
mkdir -p $(prefix)/lib/videolan/vlc
$(INSTALL) -m 644 $(PLUGINS) $(prefix)/lib/videolan/vlc
$(INSTALL) -m 644 $(PLUGINS:%=lib/%.so) $(prefix)/lib/videolan/vlc
mkdir -p $(prefix)/share/videolan
$(INSTALL) -m 644 share/*.psf $(prefix)/share/videolan
$(INSTALL) -m 644 share/*.png $(prefix)/share/videolan
......@@ -478,11 +476,11 @@ $(STD_PLUGIN_OBJ): %.o: %.c
$(PLUGIN_GNOME): %.o: Makefile.dep
$(PLUGIN_GNOME): %.o: %.c
$(CC) $(CFLAGS) `gnome-config --cflags gnomeui` -c -o $@ $<
$(CC) $(CFLAGS) $(PCFLAGS) `gnome-config --cflags gnomeui` -c -o $@ $<
$(PLUGIN_GLIDE): %.o: Makefile.dep
$(PLUGIN_GLIDE): %.o: %.c
$(CC) $(CFLAGS) -I/usr/include/glide -c -o $@ $<
$(CC) $(CFLAGS) $(PCFLAGS) -I/usr/include/glide -c -o $@ $<
#
# Real targets
......@@ -501,56 +499,56 @@ lib/beos.so: $(PLUGIN_BEOS)
lib/esd.so: $(PLUGIN_ESD)
ifneq (,$(findstring bsd,$(SYS)))
$(CC) $(LCFLAGS) -shared -lesd -o $@ $^
$(CC) -shared -lesd -o $@ $^ $(LCFLAGS) -lesd
else
$(CC) $(LCFLAGS) -shared -laudiofile -lesd -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS) -laudiofile -lesd
endif
lib/dsp.so: $(PLUGIN_DSP)
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
lib/alsa.so: $(PLUGIN_ALSA)
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
lib/null.so: $(PLUGIN_NULL)
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
lib/dummy.so: $(PLUGIN_DUMMY)
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
lib/fb.so: $(PLUGIN_FB)
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
lib/x11.so: $(PLUGIN_X11)
$(CC) $(LCFLAGS) -shared -L/usr/X11R6/lib -lX11 -lXext -o $@ $^
$(CC) -shared -L/usr/X11R6/lib -o $@ $^ $(LCFLAGS) -lX11 -lXext
lib/mga.so: $(PLUGIN_MGA)
$(CC) $(LCFLAGS) -shared -L/usr/X11R6/lib -lX11 -lXext -o $@ $^
$(CC) -shared -L/usr/X11R6/lib -o $@ $^ $(LCFLAGS) -lX11 -lXext
lib/gnome.so: $(PLUGIN_GNOME)
$(CC) $(LCFLAGS) -shared `gnome-config --libs gnomeui | sed 's,-rdynamic,,'` -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS) `gnome-config --libs gnomeui | sed 's,-rdynamic,,'`
lib/glide.so: $(PLUGIN_GLIDE)
$(CC) $(LCFLAGS) -shared $(LIB_GLIDE) -o $@ $^
$(CC) -shared $(LIB_GLIDE) -o $@ $^ $(LCFLAGS)
lib/ggi.so: $(PLUGIN_GGI)
$(CC) $(LCFLAGS) -shared $(LIB_GGI) -o $@ $^
$(CC) -shared $(LIB_GGI) -o $@ $^ $(LCFLAGS)
lib/sdl.so: $(PLUGIN_SDL)
$(CC) $(LCFLAGS) -shared $(LIB_SDL) -o $@ $^
$(CC) -shared $(LIB_SDL) -o $@ $^ $(LCFLAGS)
lib/yuv.so: $(PLUGIN_YUV)
ifeq ($(SYS),beos)
$(CC) $(CFLAGS) -nostart -Xlinker -soname=$@ -o $@ $^ plugins/_APP_
else
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
endif
lib/yuvmmx.so: $(PLUGIN_YUVMMX)
ifeq ($(SYS),beos)
$(CC) $(CFLAGS) -nostart -Xlinker -soname=$@ -o $@ $^ plugins/_APP_
else
$(CC) $(LCFLAGS) -shared -o $@ $^
$(CC) -shared -o $@ $^ $(LCFLAGS)
endif
################################################################################
......
debian/rules
View file @ f8da8c95
......@@ -6,7 +6,7 @@
#export DH_VERBOSE=1
# This is the debhelper compatability version to use.
export DH_COMPAT=1
export DH_COMPAT=3
build: build-stamp
build-stamp:
......@@ -15,9 +15,9 @@ build-stamp:
./configure --prefix=/usr \
--mandir=\$${prefix}/share/man \
--infodir=\$${prefix}/share/info \
--enable-mmx --enable-gnome --enable-fb \
--enable-ggi --enable-esd --enable-glide \
--enable-sdl
--enable-gnome --enable-fb \
--with-ggi --enable-esd --with-glide \
--with-sdl
$(MAKE)
touch build-stamp
......
include/audio_output.h
View file @ f8da8c95
......@@ -120,16 +120,13 @@ typedef struct
/*****************************************************************************
* aout_thread_t : audio output thread descriptor
*****************************************************************************/
typedef int (aout_sys_open_t) ( p_aout_thread_t p_aout );
typedef int (aout_sys_reset_t) ( p_aout_thread_t p_aout );
typedef int (aout_sys_setformat_t) ( p_aout_thread_t p_aout );
typedef int (aout_sys_setchannels_t) ( p_aout_thread_t p_aout );
typedef int (aout_sys_setrate_t) ( p_aout_thread_t p_aout );
typedef long (aout_sys_getbufinfo_t) ( p_aout_thread_t p_aout,
typedef int (aout_open_t) ( p_aout_thread_t p_aout );
typedef int (aout_setformat_t) ( p_aout_thread_t p_aout );
typedef long (aout_getbufinfo_t) ( p_aout_thread_t p_aout,
long l_buffer_limit );
typedef void (aout_sys_playsamples_t) ( p_aout_thread_t p_aout,
typedef void (aout_play_t) ( p_aout_thread_t p_aout,
byte_t *buffer, int i_size );
typedef void (aout_sys_close_t) ( p_aout_thread_t p_aout );
typedef void (aout_close_t) ( p_aout_thread_t p_aout );
typedef struct aout_thread_s
{
......@@ -140,15 +137,13 @@ typedef struct aout_thread_s
vlc_mutex_t fifos_lock;
aout_fifo_t fifo[ AOUT_MAX_FIFOS ];
/* Plugins */
aout_sys_open_t * p_sys_open;
aout_sys_reset_t * p_sys_reset;
aout_sys_setformat_t * p_sys_setformat;
aout_sys_setchannels_t * p_sys_setchannels;
aout_sys_setrate_t * p_sys_setrate;
aout_sys_getbufinfo_t * p_sys_getbufinfo;
aout_sys_playsamples_t * p_sys_playsamples;
aout_sys_close_t * p_sys_close;
/* Plugin used and shortcuts to access its capabilities */
struct module_s * p_module;
aout_open_t * p_open;
aout_setformat_t * p_setformat;
aout_getbufinfo_t * p_getbufinfo;
aout_play_t * p_play;
aout_close_t * p_close;
void * buffer;
/* The s32 buffer is used to mix all the audio fifos together before
......
include/modules.h
View file @ f8da8c95
......@@ -31,8 +31,90 @@ typedef void * module_handle_t;
#endif
/*****************************************************************************
* Configuration structure
* Module capabilities.
*****************************************************************************/
#define MODULE_CAPABILITY_NULL 0 /* The Module can't do anything */
#define MODULE_CAPABILITY_INTF 1<<0 /* Interface */
#define MODULE_CAPABILITY_INPUT 1<<1 /* Input */
#define MODULE_CAPABILITY_DECAPS 1<<2 /* Decaps */
#define MODULE_CAPABILITY_ADEC 1<<3 /* Audio decoder */
#define MODULE_CAPABILITY_VDEC 1<<4 /* Video decoder */
#define MODULE_CAPABILITY_AOUT 1<<5 /* Audio output */
#define MODULE_CAPABILITY_VOUT 1<<6 /* Video output */
#define MODULE_CAPABILITY_YUV 1<<7 /* YUV colorspace conversion */
#define MODULE_CAPABILITY_AFX 1<<8 /* Audio effects */
#define MODULE_CAPABILITY_VFX 1<<9 /* Video effects */
/* FIXME: not yet used */
typedef struct probedata_s
{
struct
{
char * psz_data;
} aout;
} probedata_t;
/* FIXME: find a nicer way to do this. */
typedef struct function_list_s
{
int ( * p_probe ) ( probedata_t * p_data );
union
{
struct
{
int ( * p_open ) ( struct aout_thread_s * p_aout );
int ( * p_setformat ) ( struct aout_thread_s * p_aout );
long ( * p_getbufinfo ) ( struct aout_thread_s * p_aout,
long l_buffer_info );
void ( * p_play ) ( struct aout_thread_s * p_aout,
byte_t *buffer, int i_size );
void ( * p_close ) ( struct aout_thread_s * p_aout );
} aout;
} functions;
} function_list_t;
typedef struct module_functions_s
{
/* The order here has to be the same as above for the #defines */
function_list_t intf;
function_list_t input;
function_list_t decaps;
function_list_t adec;
function_list_t vdec;
function_list_t aout;
function_list_t vout;
function_list_t yuv;
function_list_t afx;
function_list_t vfx;
} module_functions_t;
typedef struct module_functions_s * p_module_functions_t;
/*****************************************************************************
* Macros used to build the configuration structure.
*****************************************************************************/
/* Mandatory first and last parts of the structure */
#define MODULE_CONFIG_ITEM_START 0x01 /* The main window */
#define MODULE_CONFIG_ITEM_END 0x00 /* End of the window */
/* Configuration widgets */
#define MODULE_CONFIG_ITEM_PANE 0x02 /* A notebook pane */
#define MODULE_CONFIG_ITEM_FRAME 0x03 /* A frame */
#define MODULE_CONFIG_ITEM_COMMENT 0x04 /* A comment text */
#define MODULE_CONFIG_ITEM_STRING 0x05 /* A string */
#define MODULE_CONFIG_ITEM_FILE 0x06 /* A file selector */
#define MODULE_CONFIG_ITEM_CHECK 0x07 /* A checkbox */
#define MODULE_CONFIG_ITEM_CHOOSE 0x08 /* A choose box */
#define MODULE_CONFIG_ITEM_RADIO 0x09 /* A radio box */
#define MODULE_CONFIG_ITEM_SCALE 0x0a /* A horizontal ruler */
#define MODULE_CONFIG_ITEM_SPIN 0x0b /* A numerical selector */
typedef struct module_config_s
{
int i_type; /* Configuration widget type */
......@@ -46,7 +128,16 @@ typedef struct module_config_s
* Bank and module description structures
*****************************************************************************/
/* The main module structure */
/* The module bank structure */
typedef struct module_bank_s
{
struct module_s * first; /* First module of the bank */
vlc_mutex_t lock; /* Global lock -- you can't imagine how awful it
is to design thread-safe linked lists. */
} module_bank_t;
/* The module description structure */
typedef struct module_s
{
boolean_t b_builtin; /* Set to true if the module is built in */
......@@ -64,20 +155,12 @@ typedef struct module_s
struct module_s * next; /* Next module */
struct module_s * prev; /* Previous module */
u32 i_capabilities; /* Capability list */
module_config_t * p_config; /* Module configuration structure table */
} module_t;
/* The module bank structure */
typedef struct module_bank_s
{
module_t * first; /* First module of the bank */
u32 i_capabilities; /* Capability list */
p_module_functions_t p_functions; /* Capability functions */
vlc_mutex_t lock; /* Global lock -- you can't imagine how awful it
is to design thread-safe linked lists. */
} module_bank_t;
} module_t;
/*****************************************************************************
* Exported functions.
......@@ -88,6 +171,8 @@ void module_DestroyBank ( module_bank_t * p_bank );
void module_ResetBank ( module_bank_t * p_bank );
void module_ManageBank ( module_bank_t * p_bank );
int module_Need ( module_t * p_module );
int module_Unneed ( module_t * p_module );
module_t * module_Need ( module_bank_t *p_bank,
int i_capabilities, void *p_data );
void module_Unneed ( module_bank_t * p_bank,
module_t * p_module );
include/modules_config.h deleted 100644 → 0
View file @ b7b3386b
/*****************************************************************************
* modules_config.h : Module configuration tools.
*****************************************************************************
* Copyright (C) 2001 VideoLAN
*
* Authors: Samuel Hocevar <sam@zoy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
/*****************************************************************************
* Module capabilities.
*****************************************************************************/
#define MODULE_CAPABILITY_NULL 0 /* The Module can't do anything */
#define MODULE_CAPABILITY_INTF 1<<0 /* Interface */
#define MODULE_CAPABILITY_INPUT 1<<1 /* Input */
#define MODULE_CAPABILITY_DECAPS 1<<2 /* Decaps */
#define MODULE_CAPABILITY_ADEC 1<<3 /* Audio decoder */
#define MODULE_CAPABILITY_VDEC 1<<4 /* Video decoder */
#define MODULE_CAPABILITY_AOUT 1<<5 /* Audio output */
#define MODULE_CAPABILITY_VOUT 1<<6 /* Video output */
#define MODULE_CAPABILITY_YUV 1<<7 /* YUV colorspace conversion */
#define MODULE_CAPABILITY_AFX 1<<8 /* Audio effects */
#define MODULE_CAPABILITY_VFX 1<<9 /* Video effects */
/*****************************************************************************
* Macros used to build the configuration structure.
*****************************************************************************/
/* Mandatory first and last parts of the structure */
#define MODULE_CONFIG_ITEM_START 0x01 /* The main window */
#define MODULE_CONFIG_ITEM_END 0x00 /* End of the window */
/* Configuration widgets */
#define MODULE_CONFIG_ITEM_PANE 0x02 /* A notebook pane */
#define MODULE_CONFIG_ITEM_FRAME 0x03 /* A frame */
#define MODULE_CONFIG_ITEM_COMMENT 0x04 /* A comment text */
#define MODULE_CONFIG_ITEM_STRING 0x05 /* A string */
#define MODULE_CONFIG_ITEM_FILE 0x06 /* A file selector */
#define MODULE_CONFIG_ITEM_CHECK 0x07 /* A checkbox */
#define MODULE_CONFIG_ITEM_CHOOSE 0x08 /* A choose box */
#define MODULE_CONFIG_ITEM_RADIO 0x09 /* A radio box */
#define MODULE_CONFIG_ITEM_SCALE 0x0a /* A horizontal ruler */
#define MODULE_CONFIG_ITEM_SPIN 0x0b /* A numerical selector */
plugins/alsa/alsa.c
View file @ f8da8c95
......@@ -52,12 +52,9 @@ static void aout_GetPlugin( p_aout_thread_t p_aout );
/* Audio output */
int aout_AlsaOpen ( aout_thread_t *p_aout );
int aout_AlsaReset ( aout_thread_t *p_aout );
int aout_AlsaSetFormat ( aout_thread_t *p_aout );
int aout_AlsaSetChannels ( aout_thread_t *p_aout );
int aout_AlsaSetRate ( aout_thread_t *p_aout );
long aout_AlsaGetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
void aout_AlsaPlaySamples ( aout_thread_t *p_aout, byte_t *buffer,
void aout_AlsaPlay ( aout_thread_t *p_aout, byte_t *buffer,
int i_size );
void aout_AlsaClose ( aout_thread_t *p_aout );
......@@ -96,12 +93,9 @@ plugin_info_t * GetConfig( void )
static void aout_GetPlugin( p_aout_thread_t p_aout )
{
p_aout->p_sys_open = aout_AlsaOpen;
p_aout->p_sys_reset = aout_AlsaReset;
p_aout->p_sys_setformat = aout_AlsaSetFormat;
p_aout->p_sys_setchannels = aout_AlsaSetChannels;
p_aout->p_sys_setrate = aout_AlsaSetRate;
p_aout->p_sys_getbufinfo = aout_AlsaGetBufInfo;
p_aout->p_sys_playsamples = aout_AlsaPlaySamples;
p_aout->p_sys_close = aout_AlsaClose;
p_aout->p_open = aout_AlsaOpen;
p_aout->p_setformat = aout_AlsaSetFormat;
p_aout->p_getbufinfo = aout_AlsaGetBufInfo;
p_aout->p_play = aout_AlsaPlay;
p_aout->p_close = aout_AlsaClose;
}
plugins/alsa/aout_alsa.c
View file @ f8da8c95
......@@ -204,39 +204,6 @@ int aout_AlsaSetFormat ( aout_thread_t *p_aout )
return ( 0 );
}
/*****************************************************************************
* aout_AlsaReset: resets the dsp
*****************************************************************************/
int aout_AlsaReset ( aout_thread_t *p_aout )
{
/* TODO : put something in here, such as close and open again
* or check status, drain, flush, .... */
return ( 0 );
}
/*****************************************************************************
* aout_AlsaSetChannels: sets mono, stereo and other modes
*****************************************************************************/
int aout_AlsaSetChannels ( aout_thread_t *p_aout )
{
/* TODO : normally, nothing
* everything should be done in the AlsaSetFormat, as far a I understand
* the alsa documentation
*/
return ( 0 );
}
/*****************************************************************************
* aout_AlsaSetRate: sets the audio output rate
*****************************************************************************
* As in the previous function, the rate is supposed to be set in the
* AlsaSetFormat function
*****************************************************************************/
int aout_AlsaSetRate ( aout_thread_t *p_aout )
{
return ( 0 );
}
/*****************************************************************************
* aout_AlsaGetBufInfo: buffer status query
*****************************************************************************/
......@@ -286,9 +253,9 @@ long aout_AlsaGetBufInfo ( aout_thread_t *p_aout, long l_buffer_limit )
}
/*****************************************************************************
* aout_AlsaPlaySamples
* aout_AlsaPlay
*****************************************************************************/
void aout_AlsaPlaySamples ( aout_thread_t *p_aout, byte_t *buffer, int i_size )
void aout_AlsaPlay ( aout_thread_t *p_aout, byte_t *buffer, int i_size )
{
int i_write_returns;
......
plugins/beos/aout_beos.cpp
View file @ f8da8c95
......@@ -2,7 +2,7 @@
* aout_beos.cpp: beos interface
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
* $Id: aout_beos.cpp,v 1.7 2001/01/05 18:46:43 massiot Exp $
* $Id: aout_beos.cpp,v 1.8 2001/01/07 16:17:58 sam Exp $
*
* Authors:
* Samuel Hocevar <sam@via.ecp.fr>
......@@ -135,13 +135,6 @@ int aout_BeOpen( aout_thread_t *p_aout )
return( 0 );
}
/*****************************************************************************
* aout_BeReset: resets the dsp
*****************************************************************************/
int aout_BeReset( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_BeSetFormat: sets the dsp output format
......@@ -151,22 +144,6 @@ int aout_BeSetFormat( aout_thread_t *p_aout )
return( 0 );
}
/*****************************************************************************
* aout_BeSetChannels: sets the dsp's stereo or mono mode
*****************************************************************************/
int aout_BeSetChannels( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_BeSetRate: sets the dsp's audio output rate
*****************************************************************************/
int aout_BeSetRate( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_BeGetBufInfo: buffer status query
*****************************************************************************/
......@@ -185,11 +162,11 @@ long aout_BeGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
}
/*****************************************************************************
* aout_BePlaySamples: plays a sound samples buffer
* aout_BePlay: plays a sound samples buffer
*****************************************************************************
* This function writes a buffer of i_length bytes in the dsp
*****************************************************************************/
void aout_BePlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
void aout_BePlay( aout_thread_t *p_aout, byte_t *buffer, int i_size )
{
long i_newbuf_pos;
......
plugins/beos/beos.cpp
View file @ f8da8c95
......@@ -54,7 +54,7 @@ int aout_BeSetFormat ( aout_thread_t *p_aout );
int aout_BeSetChannels ( aout_thread_t *p_aout );
int aout_BeSetRate ( aout_thread_t *p_aout );
long aout_BeGetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
void aout_BePlaySamples ( aout_thread_t *p_aout, byte_t *buffer,
void aout_BePlay ( aout_thread_t *p_aout, byte_t *buffer,
int i_size );
void aout_BeClose ( aout_thread_t *p_aout );
......@@ -102,14 +102,11 @@ plugin_info_t * GetConfig( void )
static void aout_GetPlugin( p_aout_thread_t p_aout )
{
p_aout->p_sys_open = aout_BeOpen;
p_aout->p_sys_reset = aout_BeReset;
p_aout->p_sys_setformat = aout_BeSetFormat;
p_aout->p_sys_setchannels = aout_BeSetChannels;
p_aout->p_sys_setrate = aout_BeSetRate;
p_aout->p_sys_getbufinfo = aout_BeGetBufInfo;
p_aout->p_sys_playsamples = aout_BePlaySamples;
p_aout->p_sys_close = aout_BeClose;
p_aout->p_open = aout_BeOpen;
p_aout->p_setformat = aout_BeSetFormat;
p_aout->p_getbufinfo = aout_BeGetBufInfo;
p_aout->p_play = aout_BePlay;
p_aout->p_close = aout_BeClose;
}
static void vout_GetPlugin( p_vout_thread_t p_vout )
......
plugins/dsp/aout_dsp.c
View file @ f8da8c95
......@@ -3,7 +3,8 @@
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
*
* Authors:
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
......@@ -22,10 +23,9 @@
/* TODO:
*
* - an aout_DspGetFormats() function
* - an aout_GetFormats() function
* - dsp inline/static
* - make this library portable (see mpg123)
* - macroify aout_DspPlaySamples &/| aout_DspGetBufInfo ?
*
*/
......@@ -61,8 +61,10 @@
#include "intf_msg.h" /* intf_DbgMsg(), intf_ErrMsg() */
#include "main.h"
#include "modules.h"
/*****************************************************************************
* vout_dsp_t: dsp audio output method descriptor
* aout_sys_t: dsp audio output method descriptor
*****************************************************************************
* This structure is part of the audio output thread descriptor.
* It describes the dsp specific properties of an audio device.
......@@ -74,31 +76,82 @@ typedef struct aout_sys_s
} aout_sys_t;
/*****************************************************************************
* aout_DspOpen: opens the audio device (the digital sound processor)
* Local prototypes.
*****************************************************************************/
static int aout_Probe ( probedata_t *p_data );
static int aout_Open ( aout_thread_t *p_aout );
static int aout_SetFormat ( aout_thread_t *p_aout );
static long aout_GetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
static void aout_Play ( aout_thread_t *p_aout,
byte_t *buffer, int i_size );
static void aout_Close ( aout_thread_t *p_aout );
/*****************************************************************************
* Functions exported as capabilities. They are declared as static so that
* we don't pollute the namespace too much.
*****************************************************************************/
void dsp_aout_getfunctions( function_list_t * p_function_list )
{
p_function_list->p_probe = aout_Probe;
p_function_list->functions.aout.p_open = aout_Open;
p_function_list->functions.aout.p_setformat = aout_SetFormat;
p_function_list->functions.aout.p_getbufinfo = aout_GetBufInfo;
p_function_list->functions.aout.p_play = aout_Play;
p_function_list->functions.aout.p_close = aout_Close;
}
/*****************************************************************************
* aout_Probe: probes the audio device and return a score
*****************************************************************************
* - This function opens the dsp as an usual non-blocking write-only file, and
* modifies the p_aout->p_sys->i_fd with the file's descriptor.
* This function tries to open the dps and returns a score to the plugin
* manager so that it can
*****************************************************************************/
int aout_DspOpen( aout_thread_t *p_aout )
static int aout_Probe( probedata_t *p_data )
{
char * psz_device = main_GetPszVariable( AOUT_DSP_VAR, AOUT_DSP_DEFAULT );
int i_fd = open( psz_device, O_WRONLY|O_NONBLOCK );
/* If we were unable to open the device, there is no way we can use
* the plugin. Return a score of 0. */
if( i_fd < 0 )
{
return( 0 );
}
/* Otherwise, there are good chances we can use this plugin, return 100. */
close( i_fd );
return( 100 );
}
/*****************************************************************************
* aout_Open: opens the audio device (the digital sound processor)
*****************************************************************************
* This function opens the dsp as a usual non-blocking write-only file, and
* modifies the p_aout->i_fd with the file's descriptor.
*****************************************************************************/
static int aout_Open( aout_thread_t *p_aout )
{
/* Allocate structure */
p_aout->p_sys = malloc( sizeof( aout_sys_t ) );
if( p_aout->p_sys == NULL )
{
intf_ErrMsg("error: %s", strerror(ENOMEM) );
intf_ErrMsg("aout error: %s", strerror(ENOMEM) );
return( 1 );
}
/* Initialize some variables */
p_aout->i_format = AOUT_FORMAT_DEFAULT;
p_aout->psz_device = main_GetPszVariable( AOUT_DSP_VAR, AOUT_DSP_DEFAULT );
p_aout->i_channels = 1 + main_GetIntVariable( AOUT_STEREO_VAR, AOUT_STEREO_DEFAULT );
p_aout->l_rate = main_GetIntVariable( AOUT_RATE_VAR, AOUT_RATE_DEFAULT );
p_aout->i_format = AOUT_FORMAT_DEFAULT;
p_aout->i_channels = 1 + main_GetIntVariable( AOUT_STEREO_VAR,
AOUT_STEREO_DEFAULT );
p_aout->l_rate = main_GetIntVariable( AOUT_RATE_VAR,
AOUT_RATE_DEFAULT );
/* Open the sound device */
if ( (p_aout->i_fd = open( p_aout->psz_device, O_WRONLY|O_NONBLOCK )) < 0 )
if( (p_aout->i_fd = open( p_aout->psz_device, O_WRONLY|O_NONBLOCK )) < 0 )
{
intf_ErrMsg( "aout error: can't open audio device (%s)", p_aout->psz_device );
intf_ErrMsg( "aout error: can't open audio device (%s)",
p_aout->psz_device );
return( -1 );
}
......@@ -106,92 +159,72 @@ int aout_DspOpen( aout_thread_t *p_aout )
}
/*****************************************************************************
* aout_DspReset: resets the dsp
* aout_SetFormat: resets the dsp and sets its format
*****************************************************************************
* This functions resets the DSP device, tries to initialize the output
* format with the value contained in the dsp structure, and if this value
* could not be set, the default value returned by ioctl is set. It then
* does the same for the stereo mode, and for the output rate.
*****************************************************************************/
int aout_DspReset( aout_thread_t *p_aout )
static int aout_SetFormat( aout_thread_t *p_aout )
{
if ( ioctl( p_aout->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 )
int i_format;
long l_rate;
boolean_t b_stereo = p_aout->b_stereo;
/* Reset the DSP device */
if( ioctl( p_aout->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 )
{
intf_ErrMsg( "aout error: can't reset audio device (%s)", p_aout->psz_device );
intf_ErrMsg( "aout error: can't reset audio device (%s)",
p_aout->psz_device );
return( -1 );
}
return( 0 );
}
/*****************************************************************************
* aout_DspSetFormat: sets the dsp output format
*****************************************************************************
* This functions tries to initialize the dsp output format with the value
* contained in the dsp structure, and if this value could not be set, the
* default value returned by ioctl is set.
*****************************************************************************/
int aout_DspSetFormat( aout_thread_t *p_aout )
{
int i_format;
/* Set the output format */
i_format = p_aout->i_format;
if ( ioctl( p_aout->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
if( ioctl( p_aout->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
{
intf_ErrMsg( "aout error: can't set audio output format (%i)", p_aout->i_format );
intf_ErrMsg( "aout error: can't set audio output format (%i)",
p_aout->i_format );
return( -1 );
}
if ( i_format != p_aout->i_format )
if( i_format != p_aout->i_format )
{
intf_DbgMsg( "aout debug: audio output format not supported (%i)", p_aout->i_format );
intf_DbgMsg( "aout debug: audio output format not supported (%i)",
p_aout->i_format );
p_aout->i_format = i_format;
}
return( 0 );
}
/*****************************************************************************
* aout_DspSetChannels: sets the dsp's stereo or mono mode
*****************************************************************************
* This function acts just like the previous one...
*****************************************************************************/
int aout_DspSetChannels( aout_thread_t *p_aout )
{
boolean_t b_stereo = p_aout->b_stereo;
if ( ioctl( p_aout->i_fd, SNDCTL_DSP_STEREO, &b_stereo ) < 0 )
/* Set the number of channels */
if( ioctl( p_aout->i_fd, SNDCTL_DSP_STEREO, &b_stereo ) < 0 )
{
intf_ErrMsg( "aout error: can't set number of audio channels (%i)", p_aout->i_channels );
intf_ErrMsg( "aout error: can't set number of audio channels (%i)",
p_aout->i_channels );
return( -1 );
}
if ( b_stereo != p_aout->b_stereo )
if( b_stereo != p_aout->b_stereo )
{
intf_DbgMsg( "aout debug: number of audio channels not supported (%i)", p_aout->i_channels );
intf_DbgMsg( "aout debug: number of audio channels not supported (%i)",
p_aout->i_channels );
p_aout->b_stereo = b_stereo;
p_aout->i_channels = 1 + b_stereo;
}
return( 0 );
}
/*****************************************************************************
* aout_DspSetRate: sets the dsp's audio output rate
*****************************************************************************
* This function tries to initialize the dsp with the rate contained in the
* dsp structure, but if the dsp doesn't support this value, the function uses
* the value returned by ioctl...
*****************************************************************************/
int aout_DspSetRate( aout_thread_t *p_aout )
{
long l_rate;
/* Set the output rate */
l_rate = p_aout->l_rate;
if ( ioctl( p_aout->i_fd, SNDCTL_DSP_SPEED, &l_rate ) < 0 )
if( ioctl( p_aout->i_fd, SNDCTL_DSP_SPEED, &l_rate ) < 0 )
{
intf_ErrMsg( "aout error: can't set audio output rate (%li)", p_aout->l_rate );
intf_ErrMsg( "aout error: can't set audio output rate (%li)",
p_aout->l_rate );
return( -1 );
}
if ( l_rate != p_aout->l_rate )
if( l_rate != p_aout->l_rate )
{
intf_DbgMsg( "aout debug: audio output rate not supported (%li)", p_aout->l_rate );
intf_DbgMsg( "aout debug: audio output rate not supported (%li)",
p_aout->l_rate );
p_aout->l_rate = l_rate;
}
......@@ -199,7 +232,7 @@ int aout_DspSetRate( aout_thread_t *p_aout )
}
/*****************************************************************************
* aout_DspGetBufInfo: buffer status query
* aout_GetBufInfo: buffer status query
*****************************************************************************
* This function fills in the audio_buf_info structure :
* - int fragments : number of available fragments (partially usend ones not
......@@ -209,7 +242,7 @@ int aout_DspSetRate( aout_thread_t *p_aout )
* - int bytes : available space in bytes (includes partially used fragments)
* Note! 'bytes' could be more than fragments*fragsize
*****************************************************************************/
long aout_DspGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
static long aout_GetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
{
ioctl( p_aout->i_fd, SNDCTL_DSP_GETOSPACE, &p_aout->p_sys->audio_buf );
......@@ -220,11 +253,11 @@ long aout_DspGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
}
/*****************************************************************************
* aout_DspPlaySamples: plays a sound samples buffer
* aout_Play: plays a sound samples buffer
*****************************************************************************
* This function writes a buffer of i_length bytes in the dsp
*****************************************************************************/
void aout_DspPlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
static void aout_Play( aout_thread_t *p_aout, byte_t *buffer, int i_size )
{
if( p_aout->b_active )
{
......@@ -233,9 +266,9 @@ void aout_DspPlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
}
/*****************************************************************************
* aout_DspClose: closes the dsp audio device
* aout_Close: closes the dsp audio device
*****************************************************************************/
void aout_DspClose( aout_thread_t *p_aout )
static void aout_Close( aout_thread_t *p_aout )
{
close( p_aout->i_fd );
}
......
plugins/dsp/dsp.c
View file @ f8da8c95
/*****************************************************************************
* dsp.c : OSS /dev/dsp plugin for vlc
* dsp.c : OSS /dev/dsp module for vlc
*****************************************************************************
* Copyright (C) 2000 VideoLAN
*
* Authors:
* Authors: Michel Kaempf <maxx@via.ecp.fr>
* Samuel Hocevar <sam@zoy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
......@@ -20,98 +21,92 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#define MODULE_NAME dsp
/*****************************************************************************
* Preamble
*****************************************************************************/
#include "defs.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h> /* malloc(), free() */
#include <unistd.h> /* close() */
#include <string.h> /* strdup() */
#include "config.h"
#include "common.h" /* boolean_t, byte_t */
#include "threads.h"
#include "mtime.h"
#include "tests.h"
#include "plugins.h"
#include "interface.h"
#include "audio_output.h"
#include "video.h"
#include "video_output.h"
#include "modules.h"
#include "modules_inner.h"
#include "main.h"
/*****************************************************************************
* Build configuration tree.
*****************************************************************************/
MODULE_CONFIG_START( "Configuration for dsp module" )
ADD_FRAME( "OSS Device" )
ADD_FILE( "Device name: ", MODULE_VAR(device), NULL )
MODULE_CONFIG_END
/*****************************************************************************
* Exported prototypes
* Capabilities defined in the other files.
*****************************************************************************/
static void aout_GetPlugin( p_aout_thread_t p_aout );
/* Audio output */
int aout_DspOpen ( aout_thread_t *p_aout );
int aout_DspReset ( aout_thread_t *p_aout );
int aout_DspSetFormat ( aout_thread_t *p_aout );
int aout_DspSetChannels ( aout_thread_t *p_aout );
int aout_DspSetRate ( aout_thread_t *p_aout );
long aout_DspGetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
void aout_DspPlaySamples ( aout_thread_t *p_aout, byte_t *buffer,
int i_size );
void aout_DspClose ( aout_thread_t *p_aout );
void dsp_aout_getfunctions( function_list_t * p_function_list );
/*****************************************************************************
* GetConfig: get the plugin structure and configuration
* InitModule: get the module structure and configuration.
*****************************************************************************
* We have to fill psz_name, psz_longname and psz_version. These variables
* will be strdup()ed later by the main application because the module can
* be unloaded later to save memory, and we want to be able to access this
* data even after the module has been unloaded.
*****************************************************************************/
plugin_info_t * GetConfig( void )
int InitModule( module_t * p_module )
{
int i_fd;
plugin_info_t * p_info = (plugin_info_t *) malloc( sizeof(plugin_info_t) );
p_module->psz_name = MODULE_STRING;
p_module->psz_longname = "Linux OSS /dev/dsp module";
p_module->psz_version = VERSION;
p_info->psz_name = "OSS /dev/dsp";
p_info->psz_version = VERSION;
p_info->psz_author = "the VideoLAN team <vlc@videolan.org>";
p_module->i_capabilities = MODULE_CAPABILITY_NULL
| MODULE_CAPABILITY_AOUT;
p_info->aout_GetPlugin = aout_GetPlugin;
p_info->vout_GetPlugin = NULL;
p_info->intf_GetPlugin = NULL;
p_info->yuv_GetPlugin = NULL;
return( 0 );
}
/* Test if the device can be opened */
if ( (i_fd = open( main_GetPszVariable( AOUT_DSP_VAR, AOUT_DSP_DEFAULT ),
O_WRONLY|O_NONBLOCK )) < 0 )
{
p_info->i_score = 0;
}
else
/*****************************************************************************
* ActivateModule: set the module to an usable state.
*****************************************************************************
* This function fills the capability functions and the configuration
* structure. Once ActivateModule() has been called, the i_usage can
* be set to 0 and calls to NeedModule() be made to increment it. To unload
* the module, one has to wait until i_usage == 0 and call DeactivateModule().
*****************************************************************************/
int ActivateModule( module_t * p_module )
{
p_module->p_functions = malloc( sizeof( module_functions_t ) );
if( p_module->p_functions == NULL )
{
close( i_fd );
p_info->i_score = 0x100;
return( -1 );
}
/* If this plugin was requested, score it higher */
if( TestMethod( AOUT_METHOD_VAR, "dsp" ) )
{
p_info->i_score += 0x200;
}
dsp_aout_getfunctions( &p_module->p_functions->aout );
return( p_info );
p_module->p_config = p_config;
return( 0 );
}
/*****************************************************************************
* Following functions are only called through the p_info structure
* DeactivateModule: make sure the module can be unloaded.
*****************************************************************************
* This function must only be called when i_usage == 0. If it successfully
* returns, i_usage can be set to -1 and the module unloaded. Be careful to
* lock usage_lock during the whole process.
*****************************************************************************/
static void aout_GetPlugin( p_aout_thread_t p_aout )
int DeactivateModule( module_t * p_module )
{
p_aout->p_sys_open = aout_DspOpen;
p_aout->p_sys_reset = aout_DspReset;
p_aout->p_sys_setformat = aout_DspSetFormat;
p_aout->p_sys_setchannels = aout_DspSetChannels;
p_aout->p_sys_setrate = aout_DspSetRate;
p_aout->p_sys_getbufinfo = aout_DspGetBufInfo;
p_aout->p_sys_playsamples = aout_DspPlaySamples;
p_aout->p_sys_close = aout_DspClose;
free( p_module->p_functions );
return( 0 );
}
plugins/dummy/aout_dummy.c
View file @ f8da8c95
......@@ -60,14 +60,6 @@ int aout_DummyOpen( aout_thread_t *p_aout )
return( 0 );
}
/*****************************************************************************
* aout_DummyReset: fake reset
*****************************************************************************/
int aout_DummyReset( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_DummySetFormat: pretends to set the dsp output format
*****************************************************************************/
......@@ -76,22 +68,6 @@ int aout_DummySetFormat( aout_thread_t *p_aout )
return( 0 );
}
/*****************************************************************************
* aout_DummySetChannels: pretends to set stereo or mono mode
*****************************************************************************/
int aout_DummySetChannels( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_DummySetRate: pretends to set audio output rate
*****************************************************************************/
int aout_DummySetRate( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_DummyGetBufInfo: returns available bytes in buffer
*****************************************************************************/
......@@ -101,10 +77,11 @@ long aout_DummyGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
}
/*****************************************************************************
* aout_DummyPlaySamples: pretends to play a sound
* aout_DummyPlay: pretends to play a sound
*****************************************************************************/
void aout_DummyPlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
void aout_DummyPlay( aout_thread_t *p_aout, byte_t *buffer, int i_size )
{
;
}
/*****************************************************************************
......
plugins/dummy/dummy.c
View file @ f8da8c95
......@@ -48,12 +48,9 @@ static void intf_GetPlugin( p_intf_thread_t p_intf );
/* Audio output */
int aout_DummyOpen ( aout_thread_t *p_aout );
int aout_DummyReset ( aout_thread_t *p_aout );
int aout_DummySetFormat ( aout_thread_t *p_aout );
int aout_DummySetChannels ( aout_thread_t *p_aout );
int aout_DummySetRate ( aout_thread_t *p_aout );
long aout_DummyGetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
void aout_DummyPlaySamples ( aout_thread_t *p_aout, byte_t *buffer,
void aout_DummyPlay ( aout_thread_t *p_aout, byte_t *buffer,
int i_size );
void aout_DummyClose ( aout_thread_t *p_aout );
......@@ -114,14 +111,11 @@ plugin_info_t * GetConfig( void )
static void aout_GetPlugin( p_aout_thread_t p_aout )
{
p_aout->p_sys_open = aout_DummyOpen;
p_aout->p_sys_reset = aout_DummyReset;
p_aout->p_sys_setformat = aout_DummySetFormat;
p_aout->p_sys_setchannels = aout_DummySetChannels;
p_aout->p_sys_setrate = aout_DummySetRate;
p_aout->p_sys_getbufinfo = aout_DummyGetBufInfo;
p_aout->p_sys_playsamples = aout_DummyPlaySamples;
p_aout->p_sys_close = aout_DummyClose;
p_aout->p_open = aout_DummyOpen;
p_aout->p_setformat = aout_DummySetFormat;
p_aout->p_getbufinfo = aout_DummyGetBufInfo;
p_aout->p_play = aout_DummyPlay;
p_aout->p_close = aout_DummyClose;
}
static void vout_GetPlugin( p_vout_thread_t p_vout )
......
plugins/esd/aout_esd.c
View file @ f8da8c95
......@@ -3,7 +3,7 @@
*****************************************************************************
* Copyright (C) 2000 VideoLAN
*
* Authors:
* Authors: Samuel Hocevar <sam@zoy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
......@@ -51,6 +51,8 @@
#include "intf_msg.h" /* intf_DbgMsg(), intf_ErrMsg() */
#include "main.h"
#include "modules.h"
/*****************************************************************************
* aout_sys_t: esd audio output method descriptor
*****************************************************************************
......@@ -64,9 +66,47 @@ typedef struct aout_sys_s
} aout_sys_t;
/*****************************************************************************
* aout_EsdOpen: opens an esd socket
* Local prototypes.
*****************************************************************************/
int aout_EsdOpen( aout_thread_t *p_aout )
static int aout_Probe ( probedata_t *p_data );
static int aout_Open ( aout_thread_t *p_aout );
static int aout_SetFormat ( aout_thread_t *p_aout );
static long aout_GetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
static void aout_Play ( aout_thread_t *p_aout,
byte_t *buffer, int i_size );
static void aout_Close ( aout_thread_t *p_aout );
/*****************************************************************************
* Functions exported as capabilities. They are declared as static so that
* we don't pollute the namespace too much.
*****************************************************************************/
void esd_aout_getfunctions( function_list_t * p_function_list )
{
p_function_list->p_probe = aout_Probe;
p_function_list->functions.aout.p_open = aout_Open;
p_function_list->functions.aout.p_setformat = aout_SetFormat;
p_function_list->functions.aout.p_getbufinfo = aout_GetBufInfo;
p_function_list->functions.aout.p_play = aout_Play;
p_function_list->functions.aout.p_close = aout_Close;
}
/*****************************************************************************
* aout_Probe: probes the audio device and return a score
*****************************************************************************
* This function tries to open the dps and returns a score to the plugin
* manager so that it can
*****************************************************************************/
static int aout_Probe( probedata_t *p_data )
{
/* We don't have to test anything -- if we managed to open this plugin,
* it means we have the appropriate libs. */
return( 50 );
}
/*****************************************************************************
* aout_Open: open an esd socket
*****************************************************************************/
static int aout_Open( aout_thread_t *p_aout )
{
/* mpg123 does it this way */
int i_bits = ESD_BITS16;
......@@ -112,52 +152,28 @@ int aout_EsdOpen( aout_thread_t *p_aout )
}
/*****************************************************************************
* aout_EsdReset: resets the dsp
*****************************************************************************/
int aout_EsdReset( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_EsdSetFormat: sets the dsp output format
*****************************************************************************/
int aout_EsdSetFormat( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_EsdSetChannels: sets the dsp's stereo or mono mode
*****************************************************************************/
int aout_EsdSetChannels( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_EsdSetRate: sets the dsp's audio output rate
* aout_SetFormat: set the output format
*****************************************************************************/
int aout_EsdSetRate( aout_thread_t *p_aout )
static int aout_SetFormat( aout_thread_t *p_aout )
{
return( 0 );
}
/*****************************************************************************
* aout_EsdGetBufInfo: buffer status query
* aout_GetBufInfo: buffer status query
*****************************************************************************/
long aout_EsdGetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
long aout_GetBufInfo( aout_thread_t *p_aout, long l_buffer_limit )
{
/* arbitrary value that should be changed */
return( l_buffer_limit );
}
/*****************************************************************************
* aout_EsdPlaySamples: plays a sound samples buffer
* aout_Play: play a sound samples buffer
*****************************************************************************
* This function writes a buffer of i_length bytes in the dsp
* This function writes a buffer of i_length bytes in the socket
*****************************************************************************/
void aout_EsdPlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
void aout_Play( aout_thread_t *p_aout, byte_t *buffer, int i_size )
{
int amount;
......@@ -182,9 +198,9 @@ void aout_EsdPlaySamples( aout_thread_t *p_aout, byte_t *buffer, int i_size )
}
/*****************************************************************************
* aout_EsdClose: closes the dsp audio device
* aout_Close: close the Esound socket
*****************************************************************************/
void aout_EsdClose( aout_thread_t *p_aout )
void aout_Close( aout_thread_t *p_aout )
{
close( p_aout->i_fd );
}
......
plugins/esd/esd.c
View file @ f8da8c95
/*****************************************************************************
* esd.c : Esound plugin for vlc
* esd.c : EsounD module
*****************************************************************************
* Copyright (C) 2000 VideoLAN
* Copyright (C) 2000, 2001 VideoLAN
*
* Authors:
* Authors: Samuel Hocevar <sam@zoy.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
......@@ -20,82 +20,92 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
*****************************************************************************/
#define MODULE_NAME esd
/*****************************************************************************
* Preamble
*****************************************************************************/
#include "defs.h"
#include <stdlib.h> /* malloc(), free() */
#include <string.h> /* strdup() */
#include "config.h"
#include "common.h" /* boolean_t, byte_t */
#include "threads.h"
#include "mtime.h"
#include "tests.h"
#include "plugins.h"
#include "interface.h"
#include "audio_output.h"
#include "video.h"
#include "video_output.h"
#include "modules.h"
#include "modules_inner.h"
/*****************************************************************************
* Exported prototypes
* Build configuration tree.
*****************************************************************************/
static void aout_GetPlugin( p_aout_thread_t p_aout );
/* Audio output */
int aout_EsdOpen ( aout_thread_t *p_aout );
int aout_EsdReset ( aout_thread_t *p_aout );
int aout_EsdSetFormat ( aout_thread_t *p_aout );
int aout_EsdSetChannels ( aout_thread_t *p_aout );
int aout_EsdSetRate ( aout_thread_t *p_aout );
long aout_EsdGetBufInfo ( aout_thread_t *p_aout, long l_buffer_info );
void aout_EsdPlaySamples ( aout_thread_t *p_aout, byte_t *buffer,
int i_size );
void aout_EsdClose ( aout_thread_t *p_aout );
MODULE_CONFIG_START( "Configuration for esd module" )
ADD_FRAME( "EsounD" )
ADD_COMMENT( "This module does not need configuration" )
MODULE_CONFIG_END
/*****************************************************************************
* GetConfig: get the plugin structure and configuration
* Capabilities defined in the other files.
*****************************************************************************/
plugin_info_t * GetConfig( void )
{
plugin_info_t * p_info = (plugin_info_t *) malloc( sizeof(plugin_info_t) );
void esd_aout_getfunctions( function_list_t * p_function_list );
p_info->psz_name = "Esound";
p_info->psz_version = VERSION;
p_info->psz_author = "the VideoLAN team <vlc@videolan.org>";
/*****************************************************************************
* InitModule: get the module structure and configuration.
*****************************************************************************
* We have to fill psz_name, psz_longname and psz_version. These variables
* will be strdup()ed later by the main application because the module can
* be unloaded later to save memory, and we want to be able to access this
* data even after the module has been unloaded.
*****************************************************************************/
int InitModule( module_t * p_module )
{
p_module->psz_name = MODULE_STRING;
p_module->psz_longname = "EsounD audio module";
p_module->psz_version = VERSION;
p_info->aout_GetPlugin = aout_GetPlugin;
p_info->vout_GetPlugin = NULL;
p_info->intf_GetPlugin = NULL;
p_info->yuv_GetPlugin = NULL;
p_module->i_capabilities = MODULE_CAPABILITY_NULL
| MODULE_CAPABILITY_AOUT;
/* esound should always work, but score it lower than DSP */
p_info->i_score = 0x100;
return( 0 );
}
/* If this plugin was requested, score it higher */
if( TestMethod( AOUT_METHOD_VAR, "esd" ) )
/*****************************************************************************
* ActivateModule: set the module to an usable state.
*****************************************************************************
* This function fills the capability functions and the configuration
* structure. Once ActivateModule() has been called, the i_usage can
* be set to 0 and calls to NeedModule() be made to increment it. To unload
* the module, one has to wait until i_usage == 0 and call DeactivateModule().
*****************************************************************************/
int ActivateModule( module_t * p_module )
{
p_module->p_functions = malloc( sizeof( module_functions_t ) );
if( p_module->p_functions == NULL )
{
p_info->i_score += 0x200;
return( -1 );
}
return( p_info );
esd_aout_getfunctions( &p_module->p_functions->aout );
p_module->p_config = p_config;
return( 0 );
}
/*****************************************************************************
* Following functions are only called through the p_info structure
* DeactivateModule: make sure the module can be unloaded.
*****************************************************************************
* This function must only be called when i_usage == 0. If it successfully
* returns, i_usage can be set to -1 and the module unloaded. Be careful to
* lock usage_lock during the whole process.
*****************************************************************************/
static void aout_GetPlugin( p_aout_thread_t p_aout )
int DeactivateModule( module_t * p_module )
{
p_aout->p_sys_open = aout_EsdOpen;
p_aout->p_sys_reset = aout_EsdReset;
p_aout->p_sys_setformat = aout_EsdSetFormat;
p_aout->p_sys_setchannels = aout_EsdSetChannels;
p_aout->p_sys_setrate = aout_EsdSetRate;
p_aout->p_sys_getbufinfo = aout_EsdGetBufInfo;
p_aout->p_sys_playsamples = aout_EsdPlaySamples;
p_aout->p_sys_close = aout_EsdClose;
free( p_module->p_functions );
return( 0 );
}
plugins/null/null.c
View file @ f8da8c95
......@@ -35,25 +35,25 @@
#include "threads.h"
#include "mtime.h"
#include "tests.h"
#include "modules.h"
#include "modules_inner.h"
#include "modules_config.h"
/*****************************************************************************
* Build configuration tree.
*****************************************************************************/
MODULE_CONFIG_START( "Configuration for null module" )
ADD_PANE( "First" )
ADD_FRAME( "First test" )
ADD_PANE( "First pane" )
ADD_FRAME( "First frame" )
ADD_COMMENT( "You can put whatever you want here." )
ADD_STRING( "Random text: ", MODULE_VAR(text), NULL )
ADD_FRAME( "Second test" )
ADD_FRAME( "Second frame" )
ADD_COMMENT( "The file below is not used." )
ADD_FILE( "Select file: ", MODULE_VAR(file), NULL )
ADD_FRAME( "Third test" )
ADD_FRAME( "Third frame" )
ADD_COMMENT( "This space intentionally left blank." )
ADD_PANE( "Second" )
ADD_FRAME( "NULL Frame" )
ADD_PANE( "Second pane" )
ADD_FRAME( "Frame" )
ADD_COMMENT( "There is nothing in this frame." )
MODULE_CONFIG_END
......@@ -68,7 +68,7 @@ MODULE_CONFIG_END
int InitModule( module_t * p_module )
{
p_module->psz_name = MODULE_STRING;
p_module->psz_longname = "the Null Module that does nothing";
p_module->psz_longname = "the Null module that does nothing";
p_module->psz_version = VERSION;
p_module->i_capabilities = MODULE_CAPABILITY_NULL;
......@@ -86,7 +86,11 @@ int InitModule( module_t * p_module )
*****************************************************************************/
int ActivateModule( module_t * p_module )
{
/* Since the Null module can't do anything, there is no need to
* fill the p_functions structure. */
p_module->p_functions = NULL;
p_module->p_config = p_config;
return( 0 );
}
......@@ -99,6 +103,7 @@ int ActivateModule( module_t * p_module )
*****************************************************************************/
int DeactivateModule( module_t * p_module )
{
/* We didn't allocate p_functions - so we don't have to free it */
return( 0 );
}
plugins/yuvmmx/video_yuv_asm.h
View file @ f8da8c95
......@@ -27,20 +27,23 @@
*****************************************************************************/
/* hope these constant values are cache line aligned */
static unsigned long long mmx_80w = 0x0080008000800080;
static unsigned long long mmx_10w = 0x1010101010101010;
static unsigned long long mmx_00ffw = 0x00ff00ff00ff00ff;
static unsigned long long mmx_Y_coeff = 0x253f253f253f253f;
#define UNUSED_LONGLONG(foo) \
static unsigned long long foo __attribute__((unused))
UNUSED_LONGLONG(mmx_80w) = 0x0080008000800080;
UNUSED_LONGLONG(mmx_10w) = 0x1010101010101010;
UNUSED_LONGLONG(mmx_00ffw) = 0x00ff00ff00ff00ff;
UNUSED_LONGLONG(mmx_Y_coeff) = 0x253f253f253f253f;
static unsigned long long mmx_U_green = 0xf37df37df37df37d;
static unsigned long long mmx_U_blue = 0x4093409340934093;
static unsigned long long mmx_V_red = 0x3312331233123312;
static unsigned long long mmx_V_green = 0xe5fce5fce5fce5fc;
UNUSED_LONGLONG(mmx_U_green) = 0xf37df37df37df37d;
UNUSED_LONGLONG(mmx_U_blue) = 0x4093409340934093;
UNUSED_LONGLONG(mmx_V_red) = 0x3312331233123312;
UNUSED_LONGLONG(mmx_V_green) = 0xe5fce5fce5fce5fc;
static unsigned long long mmx_redmask = 0xf8f8f8f8f8f8f8f8;
static unsigned long long mmx_grnmask = 0xfcfcfcfcfcfcfcfc;
static unsigned long long mmx_grnshift = 0x03;
static unsigned long long mmx_blueshift = 0x03;
UNUSED_LONGLONG(mmx_redmask) = 0xf8f8f8f8f8f8f8f8;
UNUSED_LONGLONG(mmx_grnmask) = 0xfcfcfcfcfcfcfcfc;
UNUSED_LONGLONG(mmx_grnshift) = 0x03;
UNUSED_LONGLONG(mmx_blueshift) = 0x03;
#undef UNUSED_LONGLONG
#define MMX_INIT_16 " \n\
\n\
......
src/audio_output/audio_output.c
View file @ f8da8c95
......@@ -47,6 +47,7 @@
#include "threads.h"
#include "mtime.h" /* mtime_t, mdate(), msleep() */
#include "plugins.h"
#include "modules.h"
#include "intf_msg.h" /* intf_DbgMsg(), intf_ErrMsg() */
......@@ -99,9 +100,6 @@ static __inline__ void InitializeIncrement( aout_increment_t * p_increment, long
aout_thread_t *aout_CreateThread( int *pi_status )
{
aout_thread_t * p_aout; /* thread descriptor */
typedef void ( aout_getplugin_t ) ( aout_thread_t * p_aout );
int i_index;
int i_best_index = 0, i_best_score = 0;
#if 0
int i_status; /* thread status */
#endif
......@@ -113,41 +111,31 @@ aout_thread_t *aout_CreateThread( int *pi_status )
return( NULL );
}
/* Get a suitable audio plugin */
for( i_index = 0 ; i_index < p_main->p_bank->i_plugin_count ; i_index++ )
{
/* If there's a plugin in p_info ... */
if( p_main->p_bank->p_info[ i_index ] != NULL )
{
/* ... and if this plugin provides the functions we want ... */
if( p_main->p_bank->p_info[ i_index ]->aout_GetPlugin != NULL )
{
/* ... and if this plugin has a good score ... */
if( p_main->p_bank->p_info[ i_index ]->i_score > i_best_score )
{
/* ... then take it */
i_best_score = p_main->p_bank->p_info[ i_index ]->i_score;
i_best_index = i_index;
}
}
}
}
/* Choose the best module */
p_aout->p_module = module_Need( p_main->p_module_bank,
MODULE_CAPABILITY_AOUT, NULL );
if( i_best_score == 0 )
if( p_aout->p_module == NULL )
{
intf_ErrMsg( "aout error: no suitable aout module" );
free( p_aout );
return( NULL );
}
/* Get the plugin functions */
( (aout_getplugin_t *)
p_main->p_bank->p_info[ i_best_index ]->aout_GetPlugin )( p_aout );
#define aout_functions p_aout->p_module->p_functions->aout.functions.aout
p_aout->p_open = aout_functions.p_open;
p_aout->p_setformat = aout_functions.p_setformat;
p_aout->p_getbufinfo = aout_functions.p_getbufinfo;
p_aout->p_play = aout_functions.p_play;
p_aout->p_close = aout_functions.p_close;
#undef aout_functions
/*
* Initialize audio device
*/
if ( p_aout->p_sys_open( p_aout ) )
if ( p_aout->p_open( p_aout ) )
{
module_Unneed( p_main->p_module_bank, p_aout->p_module );
free( p_aout );
return( NULL );
}
......@@ -155,27 +143,10 @@ aout_thread_t *aout_CreateThread( int *pi_status )
p_aout->b_stereo = ( p_aout->i_channels == 2 ) ? 1 : 0; /* FIXME: only works
for i_channels == 1 or 2 ??*/
if ( p_aout->p_sys_reset( p_aout ) )
if ( p_aout->p_setformat( p_aout ) )
{
p_aout->p_sys_close( p_aout );
free( p_aout );
return( NULL );
}
if ( p_aout->p_sys_setformat( p_aout ) )
{
p_aout->p_sys_close( p_aout );
free( p_aout );
return( NULL );
}
if ( p_aout->p_sys_setchannels( p_aout ) )
{
p_aout->p_sys_close( p_aout );
free( p_aout );
return( NULL );
}
if ( p_aout->p_sys_setrate( p_aout ) )
{
p_aout->p_sys_close( p_aout );
p_aout->p_close( p_aout );
module_Unneed( p_main->p_module_bank, p_aout->p_module );
free( p_aout );
return( NULL );
}
......@@ -188,7 +159,8 @@ aout_thread_t *aout_CreateThread( int *pi_status )
* this thread is only called in main and all calls are blocking */
if( aout_SpawnThread( p_aout ) )
{
p_aout->p_sys_close( p_aout );
p_aout->p_close( p_aout );
module_Unneed( p_main->p_module_bank, p_aout->p_module );
free( p_aout );
return( NULL );
}
......@@ -362,8 +334,11 @@ void aout_DestroyThread( aout_thread_t * p_aout, int *pi_status )
}
vlc_mutex_destroy( &p_aout->fifos_lock );
/* Release the aout module */
module_Unneed( p_main->p_module_bank, p_aout->p_module );
/* Free the structure */
p_aout->p_sys_close( p_aout );
p_aout->p_close( p_aout );
intf_DbgMsg("aout debug: audio device (%s) closed", p_aout->psz_device);
/* Free structure */
......@@ -822,9 +797,9 @@ void aout_Thread_U8_Mono( aout_thread_t * p_aout )
((u8 *)p_aout->buffer)[l_buffer] = (u8)( ( (p_aout->s32_buffer[l_buffer] / AOUT_MAX_FIFOS / 256 ) + 128 ) * p_aout->vol / 256 );
p_aout->s32_buffer[l_buffer] = 0;
}
l_bytes = p_aout->p_sys_getbufinfo( p_aout, l_buffer_limit );
l_bytes = p_aout->p_getbufinfo( p_aout, l_buffer_limit );
p_aout->date = mdate() + ((((mtime_t)(l_bytes / 1 )) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(u8) << (p_aout->b_stereo) == 1 */
p_aout->p_sys_playsamples( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
p_aout->p_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
if ( l_bytes > (l_buffer_limit * sizeof(u8) * 2) ) /* There are 2 channels (left & right) */
{
msleep( p_aout->l_msleep );
......@@ -1113,9 +1088,9 @@ void aout_Thread_U8_Stereo( aout_thread_t * p_aout )
((u8 *)p_aout->buffer)[l_buffer] = (u8)( ( (p_aout->s32_buffer[l_buffer] / AOUT_MAX_FIFOS / 256) + 128 ) * p_aout->vol / 256 );
p_aout->s32_buffer[l_buffer] = 0;
}
l_bytes = p_aout->p_sys_getbufinfo( p_aout, l_buffer_limit );
l_bytes = p_aout->p_getbufinfo( p_aout, l_buffer_limit );
p_aout->date = mdate() + ((((mtime_t)(l_bytes / 2 )) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(u8) << (p_aout->b_stereo) == 2 */
p_aout->p_sys_playsamples( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
p_aout->p_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(u8) );
if ( l_bytes > (l_buffer_limit * sizeof(u8)) )
{
msleep( p_aout->l_msleep );
......@@ -1408,9 +1383,9 @@ void aout_Thread_S16_Stereo( aout_thread_t * p_aout )
p_aout->s32_buffer[l_buffer] = 0;
}
l_bytes = p_aout->p_sys_getbufinfo( p_aout, l_buffer_limit );
l_bytes = p_aout->p_getbufinfo( p_aout, l_buffer_limit );
p_aout->date = mdate() + ((((mtime_t)(l_bytes / 4)) * 1000000) / ((mtime_t)p_aout->l_rate)); /* sizeof(s16) << (p_aout->b_stereo) == 4 */
p_aout->p_sys_playsamples( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(s16) );
p_aout->p_play( p_aout, (byte_t *)p_aout->buffer, l_buffer_limit * sizeof(s16) );
if ( l_bytes > (l_buffer_limit * sizeof(s16)) )
{
msleep( p_aout->l_msleep );
......
src/input/input_programs.c
View file @ f8da8c95
......@@ -2,7 +2,7 @@
* input_programs.c: es_descriptor_t, pgrm_descriptor_t management
*****************************************************************************
* Copyright (C) 1999, 2000 VideoLAN
* $Id: input_programs.c,v 1.20 2001/01/07 04:31:18 henri Exp $
* $Id: input_programs.c,v 1.21 2001/01/07 16:17:58 sam Exp $
*
* Authors:
*
......@@ -84,15 +84,12 @@ void input_EndStream( input_thread_t * p_input )
/* Don't put i instead of 0 !! */
input_DelProgram( p_input, p_input->stream.pp_programs[0] );
}
free( p_input->stream.pp_programs );
/* Free standalone ES */
for( i = 0; i < p_input->stream.i_es_number; i++ )
{
input_DelES( p_input, p_input->stream.pp_es[0] );
}
free( p_input->stream.pp_es );
free( p_input->stream.pp_selected_es );
}
/*****************************************************************************
......@@ -202,9 +199,6 @@ void input_DelProgram( input_thread_t * p_input, pgrm_descriptor_t * p_pgrm )
input_DelES( p_input, p_pgrm->pp_es[i_index] );
}
/* Free the table of es descriptors */
free( p_pgrm->pp_es );
/* Free the demux data */
if( p_pgrm->p_demux_data != NULL )
{
......@@ -221,16 +215,19 @@ void input_DelProgram( input_thread_t * p_input, pgrm_descriptor_t * p_pgrm )
/* Remove this program from the stream's list of programs */
p_input->stream.i_pgrm_number--;
p_input->stream.pp_programs[i_pgrm_index] =
p_input->stream.pp_programs[p_input->stream.i_pgrm_number];
p_input->stream.pp_programs = realloc( p_input->stream.pp_programs,
p_input->stream.i_pgrm_number
* sizeof(pgrm_descriptor_t *) );
if( p_input->stream.pp_programs == NULL)
if( p_input->stream.i_pgrm_number && p_input->stream.pp_programs == NULL)
{
intf_ErrMsg( "Unable to realloc memory in input_DelProgram" );
intf_ErrMsg( "input error: unable to realloc program list"
" in input_DelProgram" );
}
/* Free the description of this program */
free( p_pgrm );
}
......@@ -360,7 +357,7 @@ void input_DelES( input_thread_t * p_input, es_descriptor_t * p_es )
p_pgrm->pp_es = realloc( p_pgrm->pp_es,
p_pgrm->i_es_number
* sizeof(es_descriptor_t *));
if( p_pgrm->pp_es == NULL )
if( p_pgrm->i_es_number && p_pgrm->pp_es == NULL )
{
intf_ErrMsg( "Unable to realloc memory in input_DelES" );
}
......@@ -391,7 +388,7 @@ void input_DelES( input_thread_t * p_input, es_descriptor_t * p_es )
p_input->stream.pp_es = realloc( p_input->stream.pp_es,
p_input->stream.i_es_number
* sizeof(es_descriptor_t *));
if( p_input->stream.pp_es == NULL )
if( p_input->stream.i_es_number && p_input->stream.pp_es == NULL )
{
intf_ErrMsg( "Unable to realloc memory in input_DelES" );
}
......
src/misc/modules.c
View file @ f8da8c95
......@@ -55,6 +55,8 @@
static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename );
static int HideModule( module_t * p_module );
static int FreeModule( module_bank_t * p_bank, module_t * p_module );
static int LockModule( module_t * p_module );
static int UnlockModule( module_t * p_module );
static int CallSymbol( module_t * p_module, char * psz_name );
/*****************************************************************************
......@@ -109,12 +111,12 @@ void module_InitBank( module_bank_t * p_bank )
/* We only load files ending with ".so" */
if( i_filelen > 3
&& !strcmp( file->d_name + i_filelen - 3, ".so" ) )
&& !strncmp( file->d_name + i_filelen - 3, ".so", 3 ) )
{
#ifdef SYS_BEOS
/* Under BeOS, we need to add beos_GetProgramPath() to
* access files under the current directory */
if( memcmp( file->d_name, "/", 1 ) )
if( strncmp( file->d_name, "/", 1 ) )
{
psz_file = malloc( i_programlen + i_dirlen
+ i_filelen + 3 );
......@@ -236,87 +238,99 @@ void module_ManageBank( module_bank_t * p_bank )
}
/*****************************************************************************
* module_Need: increase the usage count of a module and load it if needed.
* module_Need: return the best module function, given a capability list.
*****************************************************************************
* This function has to be called before a thread starts using a module. If
* the module is already loaded, we just increase its usage count. If it isn't
* loaded, we have to dynamically open it and initialize it.
* If you successfully call module_Need() at any moment, be careful to call
* module_Unneed() when you don't need it anymore.
* This function returns the module that best fits the asked capabilities.
*****************************************************************************/
int module_Need( module_t * p_module )
module_t * module_Need( module_bank_t *p_bank,
int i_capabilities, void *p_data )
{
if( p_module->i_usage >= 0 )
module_t * p_module;
module_t * p_bestmodule = NULL;
int i_score, i_totalscore, i_bestscore = 0;
int i_index;
/* We take the global lock */
vlc_mutex_lock( &p_bank->lock );
/* Parse the module list for capabilities and probe each of them */
for( p_module = p_bank->first ;
p_module != NULL ;
p_module = p_module->next )
{
/* This module is already loaded and activated, we can return */
p_module->i_usage++;
return( 0 );
}
/* Test that this module can do everything we need */
if( ( p_module->i_capabilities & i_capabilities ) == i_capabilities )
{
i_totalscore = 0;
if( p_module->b_builtin )
LockModule( p_module );
/* Parse all the requested capabilities and test them */
for( i_index = 0 ; (1 << i_index) <= i_capabilities ; i_index++ )
{
/* A built-in module should always have a refcount >= 0 ! */
intf_ErrMsg( "module error: built-in module `%s' has refcount %i",
p_module->psz_name, p_module->i_usage );
return( -1 );
}
if( ( (1 << i_index) & i_capabilities ) )
{
i_score = ( (function_list_t *)p_module->p_functions)
[i_index].p_probe( p_data );
if( p_module->i_usage != -1 )
if( i_score )
{
/* This shouldn't happen. Ever. We have serious problems here. */
intf_ErrMsg( "module error: dynamic module `%s' has refcount %i",
p_module->psz_name, p_module->i_usage );
return( -1 );
i_totalscore += i_score;
}
else
{
break;
}
}
}
/* i_usage == -1, which means that the module isn't in memory */
if( ! module_load( p_module->psz_filename, &p_module->handle ) )
/* If the high score was broken, we have a new champion */
if( i_totalscore > i_bestscore )
{
/* The dynamic module couldn't be opened */
intf_ErrMsg( "module error: cannot open %s (%s)",
p_module->psz_filename, module_error() );
return( -1 );
/* Keep the current module locked, but release the previous */
if( p_bestmodule != NULL )
{
UnlockModule( p_bestmodule );
}
if( CallSymbol( p_module, "ActivateModule" ) != 0 )
/* This is the new best module */
i_bestscore = i_totalscore;
p_bestmodule = p_module;
}
else
{
/* We couldn't call ActivateModule() -- looks nasty, but
* we can't do much about it. Just try to unload module. */
module_unload( p_module->handle );
p_module->i_usage = -1;
return( -1 );
/* This module wasn't interesting, unlock it and forget it */
UnlockModule( p_module );
}
}
}
/* Everything worked fine ! The module is ready to be used */
p_module->i_usage = 1;
/* We release the global lock */
vlc_mutex_unlock( &p_bank->lock );
return( 0 );
/* Don't forget that the module is still locked if bestmodule != NULL */
return( p_bestmodule );
}
/*****************************************************************************
* module_Unneed: decrease the usage count of a module.
*****************************************************************************
* This function has to be called before a thread starts using a module. If
* the module is already loaded, we just increase its usage count. If it isn't
* loaded, we have to dynamically open it and initialize it.
* If you successfully call module_Need() at any moment, be careful to call
* module_Unneed() when you don't need it anymore.
* This function must be called by the thread that called module_Need, to
* decrease the reference count and allow for hiding of modules.
*****************************************************************************/
int module_Unneed( module_t * p_module )
void module_Unneed( module_bank_t * p_bank, module_t * p_module )
{
if( p_module->i_usage <= 0 )
{
/* This shouldn't happen. Ever. We have serious problems here. */
intf_ErrMsg( "module error: trying to call module_Unneed() on `%s'"
" which isn't even in use", p_module->psz_name );
return( -1 );
}
/* We take the global lock */
vlc_mutex_lock( &p_bank->lock );
/* This module is still in use, we can return */
p_module->i_usage--;
p_module->i_unused_delay = 0;
/* Just unlock the module - we can't do anything if it fails,
* so there is no need to check the return value. */
UnlockModule( p_module );
return( 0 );
/* We release the global lock */
vlc_mutex_unlock( &p_bank->lock );
return;
}
/*****************************************************************************
......@@ -332,7 +346,7 @@ int module_Unneed( module_t * p_module )
*****************************************************************************/
static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename )
{
module_t * p_module;
module_t * p_module, * p_othermodule;
module_handle_t handle;
/* Try to dynamically load the module. */
......@@ -358,6 +372,7 @@ static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename )
p_module->psz_filename = psz_filename;
p_module->handle = handle;
/* Initialize the module : fill p_module->psz_name, etc. */
if( CallSymbol( p_module, "InitModule" ) != 0 )
{
/* We couldn't call InitModule() */
......@@ -366,6 +381,28 @@ static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename )
return( -1 );
}
/* Check that version numbers match */
if( strcmp( VERSION, p_module->psz_version ) )
{
free( p_module );
module_unload( handle );
return( -1 );
}
/* Check that we don't already have a module with this name */
for( p_othermodule = p_bank->first ;
p_othermodule != NULL ;
p_othermodule = p_othermodule->next )
{
if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) )
{
free( p_module );
module_unload( handle );
return( -1 );
}
}
/* Activate the module : fill the capability structure, etc. */
if( CallSymbol( p_module, "ActivateModule" ) != 0 )
{
/* We couldn't call ActivateModule() */
......@@ -447,6 +484,7 @@ static int HideModule( module_t * p_module )
return( -1 );
}
/* Deactivate the module : free the capability structure, etc. */
if( CallSymbol( p_module, "DeactivateModule" ) != 0 )
{
/* We couldn't call DeactivateModule() -- looks nasty, but
......@@ -530,6 +568,92 @@ static int FreeModule( module_bank_t * p_bank, module_t * p_module )
return( 0 );
}
/*****************************************************************************
* LockModule: increase the usage count of a module and load it if needed.
*****************************************************************************
* This function has to be called before a thread starts using a module. If
* the module is already loaded, we just increase its usage count. If it isn't
* loaded, we have to dynamically open it and initialize it.
* If you successfully call LockModule() at any moment, be careful to call
* UnlockModule() when you don't need it anymore.
*****************************************************************************/
static int LockModule( module_t * p_module )
{
if( p_module->i_usage >= 0 )
{
/* This module is already loaded and activated, we can return */
p_module->i_usage++;
return( 0 );
}
if( p_module->b_builtin )
{
/* A built-in module should always have a refcount >= 0 ! */
intf_ErrMsg( "module error: built-in module `%s' has refcount %i",
p_module->psz_name, p_module->i_usage );
return( -1 );
}
if( p_module->i_usage != -1 )
{
/* This shouldn't happen. Ever. We have serious problems here. */
intf_ErrMsg( "module error: dynamic module `%s' has refcount %i",
p_module->psz_name, p_module->i_usage );
return( -1 );
}
/* i_usage == -1, which means that the module isn't in memory */
if( ! module_load( p_module->psz_filename, &p_module->handle ) )
{
/* The dynamic module couldn't be opened */
intf_ErrMsg( "module error: cannot open %s (%s)",
p_module->psz_filename, module_error() );
return( -1 );
}
/* FIXME: what to do if the guy modified the plugin while it was
* unloaded ? It makes XMMS crash nastily, perhaps we should try
* to be a bit more clever here. */
/* Activate the module : fill the capability structure, etc. */
if( CallSymbol( p_module, "ActivateModule" ) != 0 )
{
/* We couldn't call ActivateModule() -- looks nasty, but
* we can't do much about it. Just try to unload module. */
module_unload( p_module->handle );
p_module->i_usage = -1;
return( -1 );
}
/* Everything worked fine ! The module is ready to be used */
p_module->i_usage = 1;
return( 0 );
}
/*****************************************************************************
* UnlockModule: decrease the usage count of a module.
*****************************************************************************
* We decrease the usage count of a module so that we know when a module
* becomes unused and can be hidden.
*****************************************************************************/
static int UnlockModule( module_t * p_module )
{
if( p_module->i_usage <= 0 )
{
/* This shouldn't happen. Ever. We have serious problems here. */
intf_ErrMsg( "module error: trying to call module_Unneed() on `%s'"
" which isn't even in use", p_module->psz_name );
return( -1 );
}
/* This module is still in use, we can return */
p_module->i_usage--;
p_module->i_unused_delay = 0;
return( 0 );
}
/*****************************************************************************
* CallSymbol: calls a module symbol.
*****************************************************************************
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment