Hacker Guide/Interfaces - Revision history

DoesItReallyMatter: +:Category:Interfaces

2019-05-30T21:26:38Z

← Older revision		Revision as of 21:26, 30 May 2019
Line 82:		Line 82:
	If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be {{VLCSourceFile\|modules/gui/ncurses.c}}. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.		If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be {{VLCSourceFile\|modules/gui/ncurses.c}}. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.

	{{~~Hacker_Guide~~}}		{{Hacker Guide}}

			[[Category:Interfaces\|*]]

DoesItReallyMatter: +{{Back to|Hacker Guide}}

2019-04-17T06:40:00Z

+{{Back to|Hacker Guide}}

← Older revision		Revision as of 06:40, 17 April 2019
Line 1:		Line 1:
			{{Back to\|Hacker Guide}}
	==VLC Interface==		==VLC Interface==

DoesItReallyMatter: c/e

2019-02-16T08:06:20Z

c/e

DoesItReallyMatter: Linking via Template:VLCSourceFile, correcting broken links

2019-02-15T08:32:09Z

Linking via Template:VLCSourceFile, correcting broken links

← Older revision		Revision as of 08:32, 15 February 2019
Line 39:		Line 39:
	==Command line options==		==Command line options==

	VLC uses GNU getopt to parse command line options. getopt structures are defined in ~~<tt>~~src/config/getopt.c~~</tt>~~ and command line parsing is done in ~~<tt>~~src/config/cmdline.c~~</tt>~~.		VLC uses GNU getopt to parse command line options. getopt structures are defined in {{VLCSourceFile\|src/config/getopt.c}} and command line parsing is done in {{VLCSourceFile\|src/config/cmdline.c}}.

	Most configuration directives are exchanged via the environment array, using <code>main_PutVariable</code> and <code>main_GetVariable</code>. As a result, <code>./vlc --height 240</code> is strictly equivalent to: <code>vlc_height=240 ./vlc</code>. That way configuration variables are available everywhere, including plugins.		Most configuration directives are exchanged via the environment array, using <code>main_PutVariable</code> and <code>main_GetVariable</code>. As a result, <code>./vlc --height 240</code> is strictly equivalent to: <code>vlc_height=240 ./vlc</code>. That way configuration variables are available everywhere, including plugins.
Line 47:		Line 47:

	==Playlist management==		==Playlist management==
	The playlist is created on startup from files given in the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in ~~<tt>~~src/playlist/control.c~~</tt>~~.		The playlist is created on startup from files given in the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in {{VLCSourceFile\|src/playlist/control.c}}.

	How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with:		How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with:
	module_Need ( module_bank_t * p_bank, int i_capabilities, void * p_data )		module_Need ( module_bank_t * p_bank, int i_capabilities, void * p_data )
	<code>p_data</code> is an optional parameter (reserved for future use) for the <code>pf_probe()</code> function. The returned <code>module_t</code> structure contains pointers to the functions of the plug-in.<br />		<code>p_data</code> is an optional parameter (reserved for future use) for the <code>pf_probe()</code> function. The returned <code>module_t</code> structure contains pointers to the functions of the plug-in.<br />
	See ~~<tt>~~include/vlc_modules.h~~</tt>~~ for more information.		See {{VLCSourceFile\|include/vlc_modules.h}} for more information.

	==The interface main loop==		==The interface main loop==
Line 62:		Line 62:
	==How to write an interface module==		==How to write an interface module==
	===API for the Module===		===API for the Module===
	Have a look the files in directories ~~<tt>~~modules~~/misc~~/control~~</tt>~~, ~~<tt>~~modules~~/misc~~/access~~</tt>~~, or ~~<tt>~~modules/gui~~</tt>~~. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example ~~<tt>~~modules/control/hotkeys.c~~</tt>~~.		Have a look the files in directories {{VLCSourceFile\|modules/control}}, {{VLCSourceFile\|modules/access}}, or {{VLCSourceFile\|modules/gui}}. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example {{VLCSourceFile\|modules/control/hotkeys.c}}.

	An interface module is made of 3 entry functions and a module description:		An interface module is made of 3 entry functions and a module description:
Line 79:		Line 79:
	Define <code>intf_sys_t</code> to contain any variable you need (don't use static variables, they suck in a multi-threaded application :-).		Define <code>intf_sys_t</code> to contain any variable you need (don't use static variables, they suck in a multi-threaded application :-).

	If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be ~~<tt>~~modules/gui~~/ncurses~~/ncurses.c~~</tt>~~. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.		If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be {{VLCSourceFile\|modules/gui/ncurses.c}}. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.

	{{Hacker_Guide}}		{{Hacker_Guide}}

EPirat: /* A typical VLC run course */ Improve formatting

2017-01-23T18:55:09Z

A typical VLC run course: Improve formatting

← Older revision		Revision as of 18:55, 23 January 2017
Line 3:		Line 3:
	==A typical VLC run course==		==A typical VLC run course==

	This section describes what happens when you launch the vlc program. After the ELF dynamic loader blah blah blah, the main thread becomes the interface thread. It passes through the following steps :		This section describes what happens when you launch the vlc program. After the ELF dynamic loader blah blah blah, the main thread becomes the interface thread. It passes through the following steps:

	#CPU detection : which CPU are we running on, what are its capabilities (MMX, MMXEXT, 3DNow, AltiVec...) ?		# CPU detection: which CPU are we running on, what are its capabilities (MMX, MMXEXT, 3DNow, AltiVec...) ?
	#Message interface initialization ;		# Message interface initialization
	#Command line options parsing ;		# Command line options parsing
	#Playlist creation ;		# Playlist creation
	#Module bank initialization ;		# Module bank initialization
	#Interface opening ;		# Interface opening
	#Signal handler installation : SIGHUP, SIGINT and SIGQUIT are caught to manage a clean quit (please note that the SDL library also catches SIGSEGV) ;		# Signal handler installation: SIGHUP, SIGINT and SIGQUIT are caught to manage a clean quit (please note that the SDL library also catches SIGSEGV)
	#Audio output thread spawning ;		# Audio output thread spawning
	#Video output thread spawning ;		# Video output thread spawning
	#Main loop : events management ;		# Main loop: events management

	Following sections describe each of these steps in particular, and many more.		Following sections describe each of these steps in particular, and many more.

EPirat: /* How to write an interface plugin */ Change to module

2017-01-23T18:35:59Z

How to write an interface plugin: Change to module

← Older revision		Revision as of 18:35, 23 January 2017
Line 60:		Line 60:
	InteractionManage cleans up the module bank by unloading unnecessary modules, manages the playlist, and flushes waiting messages (if the message queue is in use).		InteractionManage cleans up the module bank by unloading unnecessary modules, manages the playlist, and flushes waiting messages (if the message queue is in use).

	==How to write an interface ~~plugin~~==		==How to write an interface module==
	===API for the Module===		===API for the Module===
	Have a look the files in directories <tt>modules/misc/control</tt>, <tt>modules/misc/access</tt>, or <tt>modules/gui</tt>. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example <tt>modules/control/hotkeys.c</tt>.		Have a look the files in directories <tt>modules/misc/control</tt>, <tt>modules/misc/access</tt>, or <tt>modules/gui</tt>. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example <tt>modules/control/hotkeys.c</tt>.

EPirat: /* How to write an interface plugin */ Formatting changes

2017-01-23T18:22:30Z

How to write an interface plugin: Formatting changes

← Older revision		Revision as of 18:22, 23 January 2017
Line 62:		Line 62:
	==How to write an interface plugin==		==How to write an interface plugin==
	===API for the Module===		===API for the Module===
			Have a look the files in directories <tt>modules/misc/control</tt>, <tt>modules/misc/access</tt>, or <tt>modules/gui</tt>. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example <tt>modules/control/hotkeys.c</tt>.

	~~Have~~ a look the files in directories modules/misc/control, modules/misc/access, or modules/gui. However the GUI interfaces are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example modules/control/hotkeys.c.		An interface module is made of 3 entry functions and a module description:

	~~An interface~~ module is made of ~~3 entry functions and a~~ module description:		The module description is made of macros that declares the capabilities of the module (interface, in this case) with their priority, the module description as it will appear in the preferences of GUI modules that implement them, some configuration variables specific to the module, shortcuts, sub-modules, etc.

	*The module description is made of macros that declares the capabilities of the module (interface, in this case) with their priority, the module description as it will appear in the preferences of GUI modules that implement them, some configuration variables specific to the module, shortcuts, sub-modules, etc.		; <code>Open ( vlc_object_t* p_object )</code>
	Open ( vlc_object_t p_object ): This is called by VLC to initialize the module.		: This is called by VLC to initialize the module.
	Run ( vlc_object_t p_object ): ~~really~~ does the job of the interface module (waiting for user input and displaying info). It should check periodically that p_intf->b_die is not VLC_TRUE.		; <code>Run ( vlc_object_t* p_object )</code>
	Close ( vcl_object_t p_object ) function is called by VLC to uninitialize the module (basically, this consists in destroying whatever have been allocated by Open)		: Really does the job of the interface module (waiting for user input and displaying info). It should check periodically that <code>p_intf->b_die</code> is not <code>VLC_TRUE</code>.
			; <code>Close ( vcl_object_t * p_object )</code>
			: This function is called by VLC to uninitialize the module (basically, this consists in destroying whatever have been allocated by Open)

	The above functions take a vlc_object_t* as argument, but that may need to be cast into a intf_thread_t* depending on your needs. This structure is often needed as a parameter for exported VLC functions, such as msg_Err(), msg_Warn(), ...		The above functions take a <code>vlc_object_t</code> as argument, but that may need to be cast into a <code>intf_thread_t</code> depending on your needs. This structure is often needed as a parameter for exported VLC functions, such as <code>msg_Err()</code>, <code>msg_Warn()</code>, ...

	Define intf_sys_t to contain any variable you need (don't use static variables, they suck in a multi-threaded application :-).		Define <code>intf_sys_t</code> to contain any variable you need (don't use static variables, they suck in a multi-threaded application :-).

	If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be modules/gui/ncurses/ncurses.c. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.		If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be <tt>modules/gui/ncurses/ncurses.c</tt>. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.

	{{Hacker_Guide}}		{{Hacker_Guide}}

EPirat: /* Playlist management */ Improve formatting and adjust path

2017-01-23T18:15:49Z

Playlist management: Improve formatting and adjust path

← Older revision		Revision as of 18:15, 23 January 2017
Line 47:		Line 47:

	==Playlist management==		==Playlist management==
			The playlist is created on startup from files given in the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in <tt>src/playlist/control.c</tt>.

	The playlist is created on startup from files given in the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in src/playlist/control.c.		How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with:
			module_Need ( module_bank_t * p_bank, int i_capabilities, void * p_data )
			<code>p_data</code> is an optional parameter (reserved for future use) for the <code>pf_probe()</code> function. The returned <code>module_t</code> structure contains pointers to the functions of the plug-in.<br />
	How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with module_Need ( module_bank_t * p_bank, int i_capabilities, void * p_data ). p_data is an optional parameter (reserved for future use) for the pf_probe() function. The returned module_t structure contains pointers to the functions of the plug-in. See include/~~modules~~.h for more information.		See <tt>include/vlc_modules.h</tt> for more information.

	==The interface main loop==		==The interface main loop==

EPirat: /* Command line options */ Adjust formatting and correct path

2017-01-23T18:11:20Z

Command line options: Adjust formatting and correct path

← Older revision		Revision as of 18:11, 23 January 2017
Line 39:		Line 39:
	==Command line options==		==Command line options==

	VLC uses GNU getopt to parse command line options. getopt structures are defined in src/~~extras~~/getopt.c and command line parsing is done in src/config/cmdline.c		VLC uses GNU getopt to parse command line options. getopt structures are defined in <tt>src/config/getopt.c</tt> and command line parsing is done in <tt>src/config/cmdline.c</tt>.

	Most configuration directives are exchanged via the environment array, using main_PutVariable and main_GetVariable. As a result, ./vlc --height 240 is strictly equivalent to : vlc_height=240 ./vlc. That way configuration variables are available everywhere, including plugins.		Most configuration directives are exchanged via the environment array, using <code>main_PutVariable</code> and <code>main_GetVariable</code>. As a result, <code>./vlc --height 240</code> is strictly equivalent to: <code>vlc_height=240 ./vlc</code>. That way configuration variables are available everywhere, including plugins.

	===Warning===		===Warning===
			Please note that for thread-safety issues, you should not use <code>main_Put*Variable</code> once the second thread has been spawned.
	Please note that for thread-safety issues, you should not use main_Put*Variable once the second thread has been spawned

	==Playlist management==		==Playlist management==

EPirat: /* The message interface */ Update formatting

2017-01-23T18:06:25Z

The message interface: Update formatting

← Older revision		Revision as of 18:06, 23 January 2017
Line 20:		Line 20:
	==The message interface==		==The message interface==

	It is a known fact that printf() functions are not necessarily thread-safe. As a result, one thread interrupted in a printf() call, followed by another calls to it, will leave the program in an undetermined state. So an API must be set up to print messages without crashing.		It is a known fact that <code>printf()</code> functions are not necessarily thread-safe. As a result, one thread interrupted in a <code>printf()</code> call, followed by another calls to it, will leave the program in an undetermined state. So an API must be set up to print messages without crashing.

	This API is implemented in two ways. If INTF_MSG_QUEUE is defined in config.h , every printf-like (see below) call will queue the message into a chained list. This list will be printed and flushed by the interface thread once upon an event loop. If INTF_MSG_QUEUE is undefined, the calling thread will acquire the print lock (which prevents two print operations to occur at the same time) and print the message directly (default behaviour).		This API is implemented in two ways. If INTF_MSG_QUEUE is defined in config.h , every printf-like (see below) call will queue the message into a chained list. This list will be printed and flushed by the interface thread once upon an event loop. If INTF_MSG_QUEUE is undefined, the calling thread will acquire the print lock (which prevents two print operations to occur at the same time) and print the message directly (default behaviour).
Line 26:		Line 26:
	Functions available to print messages are :		Functions available to print messages are :

	*msg_Info ( p_this, ... ) : Print a message to stdout , plain and stupid (for instance "it works!").		; <code>msg_Info ( p_this, ... )</code>
	*msg_Err( p_this, ... ) : Print an error message to stderr .		: Print a message to stdout, plain and stupid (for instance "it works!").
	*msg_Warn( p_this, ... ) : Print a message to stderr if the warning level (determined by -v, -vv and -vvv) is low enough. ''Please note that the lower the level, the less important the message is.''		; <code>msg_Err( p_this, ... )</code>
	*msg_Dbg( p_this, ... ) : This function is designed for optional checkpoint messages, such as "we are now entering function dvd_foo_thingy". It does		: Print an error message to stderr.
	nothing in non-trace mode. If the VLC is compiled with --enable-trace, the message is either written to the file vlc-trace.log (if TRACE_LOG is defined in config.h), or printed to stderr (otherwise).		; <code>msg_Warn( p_this, ... )</code>
	*msg_Flush(p_this) : Flush the message queue, if it is in use.		: Print a message to stderr if the warning level (determined by <code>-v</code>, <code>-vv</code> and <code>-vvv</code>) is low enough. ''Please note that the lower the level, the less important the message is.''
			; <code>msg_Dbg( p_this, ... )</code>
			: This function is designed for optional checkpoint messages, such as "we are now entering function dvd_foo_thingy". It does nothing in non-trace mode. If the VLC is compiled with <code>--enable-trace</code>, the message is either written to the file vlc-trace.log (if TRACE_LOG is defined in config.h), or printed to stderr (otherwise).
			; <code>msg_Flush(p_this)</code>
			: Flush the message queue, if it is in use.

	==Command line options==		==Command line options==

← Older revision		Revision as of 08:06, 16 February 2019
Line 1:		Line 1:
	=VLC Interface=		==VLC Interface==

	==A typical VLC run course==		===A typical VLC run course===

	This section describes what happens when you launch the vlc program. After the ELF dynamic loader blah blah blah, the main thread becomes the interface thread. It passes through the following steps:		This section describes what happens when you launch the vlc program. After the ELF dynamic loader blah blah blah, the main thread becomes the interface thread. It passes through the following steps:

	# CPU detection: which CPU are we running on, what are its capabilities (MMX, MMXEXT, 3DNow, AltiVec...) ?		# CPU detection: which CPU are we running on, what are its capabilities (MMX, MMXEXT, 3DNow, AltiVec...) ?
Line 11:		Line 11:
	# Module bank initialization		# Module bank initialization
	# Interface opening		# Interface opening
	# Signal handler installation: SIGHUP, SIGINT and SIGQUIT are caught to manage a clean quit (please note that the SDL library also catches SIGSEGV)		# Signal handler installation: <code>SIGHUP</code>, <code>SIGINT</code> and <code>SIGQUIT</code> are caught to manage a clean quit (please note that the SDL library also catches <code>SIGSEGV</code>)
	# Audio output thread spawning		# Audio output thread spawning
	# Video output thread spawning		# Video output thread spawning
	# Main loop: events management		# Main loop: events management

	~~Following~~ sections describe each of these steps in particular, and many more.		The following sections describe each of these steps in particular, and many more.

	==The message interface==		===The message interface===

	It is a known fact that <code>printf()</code> functions are not necessarily thread-safe. As a result, one thread interrupted in a <code>printf()</code> call, followed by another ~~calls~~ to it, will leave the program in an undetermined state. So an API must be set up to print messages without crashing.		It is a known fact that <code>printf()</code> functions are not necessarily thread-safe. As a result, one thread interrupted in a <code>printf()</code> call, followed by another call to it, will leave the program in an undetermined state. So an {{API}} must be set up to print messages without crashing.

	This API is implemented in two ways. If INTF_MSG_QUEUE is defined in config.h , every printf-like (see below) call will queue the message into a chained list. This list will be printed and flushed by the interface thread once upon an event loop. If INTF_MSG_QUEUE is undefined, the calling thread will acquire the print lock (which prevents two print operations to occur at the same time) and print the message directly (default behaviour).		This API is implemented in two ways. If <var>INTF_MSG_QUEUE</var> is defined in <code>config.h</code>, every printf-like (see below) call will queue the message into a chained list. This list will be printed and flushed by the interface thread once upon an event loop. If <var>INTF_MSG_QUEUE</var> is undefined, the calling thread will acquire the print lock (which prevents two print operations to occur at the same time) and print the message directly (default behaviour).

	Functions available to print messages are :		Functions available to print messages are:

	; <code>msg_Info ( p_this, ... )</code>		; <code>msg_Info ( p_this, ... )</code>
Line 33:		Line 33:
	: Print a message to stderr if the warning level (determined by <code>-v</code>, <code>-vv</code> and <code>-vvv</code>) is low enough. ''Please note that the lower the level, the less important the message is.''		: Print a message to stderr if the warning level (determined by <code>-v</code>, <code>-vv</code> and <code>-vvv</code>) is low enough. ''Please note that the lower the level, the less important the message is.''
	; <code>msg_Dbg( p_this, ... )</code>		; <code>msg_Dbg( p_this, ... )</code>
	: This function is designed for optional checkpoint messages, such as "we are now entering function dvd_foo_thingy". It does nothing in non-trace mode. If ~~the~~ VLC is compiled with <code>--enable-trace</code>, the message ~~is either~~ written to the file vlc-trace.log ~~(if TRACE_LOG is defined in config.h), or~~ printed to stderr ~~(otherwise)~~.		: This function is designed for optional checkpoint messages, such as "we are now entering function dvd_foo_thingy". It does nothing in non-trace mode. If VLC is compiled with <code>--enable-trace</code> (and <var>TRACE_LOG</var> is defined in <code>config.h</code>), the message will be written to the file <code>vlc-trace.log</code>; else the message will be printed on stderr.
	; <code>msg_Flush(p_this)</code>		; <code>msg_Flush(p_this)</code>
	: Flush the message queue, if it is in use.		: Flush the message queue, if it is in use.

	==Command line options==		===Command line options===

	VLC uses GNU getopt to parse command line options. getopt structures are defined in {{VLCSourceFile\|src/config/getopt.c}} and command line parsing is done in {{VLCSourceFile\|src/config/cmdline.c}}.		VLC uses GNU getopt to parse command line options. getopt structures are defined in {{VLCSourceFile\|src/config/getopt.c}} and command line parsing is done in {{VLCSourceFile\|src/config/cmdline.c}}.

	Most configuration directives are exchanged via the environment array, using <code>main_PutVariable</code> and <code>main_GetVariable</code>. As a result, <code>./vlc --height 240</code> is strictly equivalent to: <code>vlc_height=240 ./vlc</code>. That way configuration variables are available everywhere, including plugins.		Most configuration directives are exchanged via the environment array, using <code>main_PutVariable</code> and <code>main_GetVariable</code>. As a result, <code>./vlc --height 240</code> is strictly equivalent to: <code>vlc_height=240 ./vlc</code>. That way configuration variables are available everywhere, including plugins.

	===Warning===		====Warning====
	Please note that for thread-safety issues, you should not use <code>main_Put*Variable</code> once the second thread has been spawned.		Please note that for thread-safety issues, you should not use <code>main_Put*Variable</code> once the second thread has been spawned.

	==Playlist management==		===Playlist management===
	The playlist is created on startup from files given in the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in {{VLCSourceFile\|src/playlist/control.c}}.		The playlist is created on startup from files given on the command line. An appropriate interface plugin can then add or remove files from it. Functions to be used are described in {{VLCSourceFile\|src/playlist/control.c}}.

	How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with:		How to write a plugin is described in the latter sections. Other threads can request a plugin descriptor with:
Line 54:		Line 54:
	See {{VLCSourceFile\|include/vlc_modules.h}} for more information.		See {{VLCSourceFile\|include/vlc_modules.h}} for more information.

	==The interface main loop==		===The interface main loop===

	The interface thread will first look for a suitable interface plugin. Then it enters the main interface loop, with the plugin's pf_run function. This function will do what's appropriate, and every 100 ms will call (typically via a GUI timer callback) InteractionManage.		The interface thread will first look for a suitable interface plugin. Then it enters the main interface loop, with the plugin's <code>pf_run function</code>. This function will do what's appropriate, and every 100 ms will call (typically via a GUI timer callback) <code>InteractionManage</code>.

	InteractionManage cleans up the module bank by unloading unnecessary modules, manages the playlist, and flushes waiting messages (if the message queue is in use).		InteractionManage cleans up the module bank by unloading unnecessary modules, manages the playlist, and flushes waiting messages (if the message queue is in use).

	==How to write an interface module==		===How to write an interface module===
	===API for the Module===		====API for the Module====
	Have a look the files in directories {{~~VLCSourceFile~~\|modules/control}}, {{~~VLCSourceFile~~\|modules/access}}, or {{~~VLCSourceFile~~\|modules/gui}}. However the ~~GUI interfaces~~ are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example {{VLCSourceFile\|modules/control/hotkeys.c}}.		Have a look at the files in directories {{VLCSourceFolder\|modules/control}}, {{VLCSourceFolder\|modules/access}}, or {{VLCSourceFolder\|modules/gui}}. However the GUIs are not very easy to understand, since they are quite big. I suggest to start digging into a non-graphical interface modules first. For example {{VLCSourceFile\|modules/control/hotkeys.c}}.

	An interface module is made of 3 entry functions and a module description:		An interface module is made of 3 entry functions and a module description:
Line 77:		Line 77:
	The above functions take a <code>vlc_object_t</code> as argument, but that may need to be cast into a <code>intf_thread_t</code> depending on your needs. This structure is often needed as a parameter for exported VLC functions, such as <code>msg_Err()</code>, <code>msg_Warn()</code>, ...		The above functions take a <code>vlc_object_t</code> as argument, but that may need to be cast into a <code>intf_thread_t</code> depending on your needs. This structure is often needed as a parameter for exported VLC functions, such as <code>msg_Err()</code>, <code>msg_Warn()</code>, ...

	Define <code>intf_sys_t</code> to contain any variable you need (don't use static variables, they suck in a multi-threaded application :-).		Define <code>intf_sys_t</code> to contain any variable you need (don't use static variables, they suck in a multi-threaded application <span title="smile">:-)</span>.

	If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be {{VLCSourceFile\|modules/gui/ncurses.c}}. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.		If additional capabilities (such as Open button, playlist, menus, etc.) are needed, consult one of the GUI modules. One of the simpler GUI modules to consult might be {{VLCSourceFile\|modules/gui/ncurses.c}}. It is a quite simple complete interface module with playlist interaction, and progress bar, among other things.

	{{Hacker_Guide}}		{{Hacker_Guide}}