Doxygen attack!

git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@18259 b3059339-0415-0410-9bf9-f77b7e298cf2

m_config.c

@@ -1,3 +1,7 @@
+
+/// \file
+/// \ingroup Config
+
 #include "config.h"
 
 #include <stdlib.h>

m_config.h

@@ -1,89 +1,200 @@
 #ifndef _M_CONFIG_H
 #define _M_CONFIG_H
 
+/// \defgroup Config Config manager
+///
+/// m_config provide an API to manipulate the config variables in MPlayer.
+/// It make use of the \ref Options API to provide a context stack that
+/// allow saving and later restoring the state of all variables.
+///@{
+
+/// \file
+
 typedef struct m_config_option m_config_option_t;
 typedef struct m_config_save_slot m_config_save_slot_t;
+/// \ingroup ConfigProfiles
 typedef struct m_profile m_profile_t;
 struct m_option;
 struct m_option_type;
 
+/// Config option save slot
 struct m_config_save_slot {
+  /// Previous level slot.
   m_config_save_slot_t* prev;
+  /// Level at which the save was made.
   int lvl;
   // we have to store other datatypes in this as well,
   // so make sure we get properly aligned addresses
   unsigned char data[0] __attribute__ ((aligned (8)));
 };
 
+/// Config option
 struct m_config_option {
   m_config_option_t* next;
-  char* name; // Full name (ie option:subopt)
+  /// Full name (ie option:subopt).
+  char* name;
+  /// Option description.
   struct m_option* opt;
+  /// Save slot stack.
   m_config_save_slot_t* slots;
-  unsigned int flags; // currently it only tell if the option was set
+  /// See \ref ConfigOptionFlags.
+  unsigned int flags;
 };
 
+/// \defgroup ConfigProfiles Config profiles
+/// \ingroup Config
+///
+/// Profiles allow to predefine some set of options that can then
+/// be applied later on with the internal -profile option.
+///
+///@{
+
+/// Config profile
 struct m_profile {
   m_profile_t* next;
   char* name;
   char* desc;
   int num_opts;
+  /// Option/value pair array.
   char** opts;
 };
 
+///@}
+
+/// Config object
+/** \ingroup Config */
 typedef struct m_config {
+  /// Registered options.
+  /** This contain all options and suboptions.
+   */ 
   m_config_option_t* opts;
-  int lvl; // Current stack level
+  /// Current stack level.
+  int lvl;
+  /// \ref OptionParserModes
   int mode;
+  /// List of the defined profiles.
   m_profile_t* profiles;
+  /// Depth when recursively including profiles.
   int profile_depth;
+  /// Options defined by the config itself.
   struct m_option* self_opts;
 } m_config_t;
 
+/// \defgroup ConfigOptionFlags Config option flags
+/// \ingroup Config
+///@{
+
+/// Set if an option have been set at the current level.
 #define M_CFG_OPT_SET    (1<<0)
+
+/// Set if another option already use the same variable.
 #define M_CFG_OPT_ALIAS  (1<<1)
 
+///@}
 
-//////////////////////////// Functions ///////////////////////////////////
+/// Create a new config object.
-
+/** \ingroup Config
+ */
 m_config_t*
 m_config_new(void);
 
+/// Free a config object.
 void
 m_config_free(m_config_t* config);
 
+/// Push a new context.
+/** \param config The config object.
+ */
 void
 m_config_push(m_config_t* config);
 
+/// Pop the current context restoring the previous context state.
+/** \param config The config object.
+ */
 void
 m_config_pop(m_config_t* config);
 
+/// Register some options to be used.
+/** \param config The config object.
+ *  \param args An array of \ref m_option struct.
+ *  \return 1 on success, 0 on failure.
+ */
 int
 m_config_register_options(m_config_t *config, struct m_option *args);
 
+/// Set an option.
+/** \param config The config object.
+ *  \param arg The option's name.
+ *  \param param The value of the option, can be NULL.
+ *  \return See \ref OptionParserReturn.
+ */
 int
 m_config_set_option(m_config_t *config, char* arg, char* param);
 
+/// Check if an option setting is valid.
+/** \param config The config object.
+ *  \param arg The option's name.
+ *  \param param The value of the option, can be NULL.
+ *  \return See \ref OptionParserReturn.
+ */
 int
 m_config_check_option(m_config_t *config, char* arg, char* param);
 
+/// Get the option matching the given name.
+/** \param config The config object.
+ *  \param arg The option's name.
+ */
 struct m_option*
 m_config_get_option(m_config_t *config, char* arg);
 
+/// Print a list of all registered options.
+/** \param config The config object.
+ */
 void
 m_config_print_option_list(m_config_t *config);
 
+/// \addtogroup ConfigProfiles
+///@{
+
+/// Find the profile with the given name.
+/** \param config The config object.
+ *  \param arg The profile's name.
+ *  \return The profile object or NULL.
+ */
 m_profile_t*
 m_config_get_profile(m_config_t* config, char* name);
 
+/// Get the profile with the given name, creating it if necessary.
+/** \param config The config object.
+ *  \param arg The profile's name.
+ *  \return The profile object.
+ */
 m_profile_t*
 m_config_add_profile(m_config_t* config, char* name);
 
+/// Set the description of a profile.
+/** This is used by the config file parser when defining a profile. 
+ * 
+ *  \param p The profile object.
+ *  \param arg The profile's name.
+ */
 void
 m_profile_set_desc(m_profile_t* p, char* desc);
 
+/// Add an option to a profile.
+/** This is used by the config file parser when defining a profile. 
+ * 
+ *  \param config The config object.
+ *  \param p The profile object.
+ *  \param name The option's name.
+ *  \param val The option's value.
+ */
 int
 m_config_set_profile_option(m_config_t* config, m_profile_t* p,
 			    char* name, char* val);
 
+///@}
+
+///@}
+
 #endif /* _M_CONFIG_H */

m_option.c

@@ -1,3 +1,7 @@
+
+/// \file
+/// \ingroup Options
+
 #include "config.h"
 
 #include <stdlib.h>

m_option.h

@@ -1,10 +1,23 @@
 #ifndef _M_OPTION_H
 #define _M_OPTION_H
 
+/// \defgroup Options
+/// m_option allow to parse, print and copy data of various types.
+/// It is the base of the \ref OptionsStruct, \ref Config and
+/// \ref Properties APIs.
+///@{
+
+/// \file m_option.h
+
+/// \ingroup OptionTypes
 typedef struct m_option_type m_option_type_t;
 typedef struct m_option m_option_t;
 struct m_struct_st;
 
+/// \defgroup OptionTypes Options types
+/// \ingroup Options
+///@{
+
 ///////////////////////////// Options types declarations ////////////////////////////
 
 // Simple types
@@ -28,52 +41,99 @@ extern m_option_type_t m_option_type_func_full;
 extern m_option_type_t m_option_type_func_param;
 extern m_option_type_t m_option_type_func;
 
+/// Callback used to reset func options.
 typedef void (*m_opt_default_func_t)(m_option_t *, char*);
+
+/// Callback used by m_option_type_func_full options.
 typedef int (*m_opt_func_full_t)(m_option_t *, char *, char *);
+
+/// Callback used by m_option_type_func_param options.
 typedef int (*m_opt_func_param_t)(m_option_t *, char *);
+
+/// Callback used by m_option_type_func options.
 typedef int (*m_opt_func_t)(m_option_t *);
-///////////// Backward compat
+
+// Backward compat
 typedef m_opt_default_func_t cfg_default_func_t;
 typedef m_opt_func_full_t cfg_func_arg_param_t;
 typedef m_opt_func_param_t cfg_func_param_t;
 typedef m_opt_func_t cfg_func_t;
 
+/// Extra definition needed for \ref m_option_type_obj_settings_list options.
 typedef struct {
+  /// Pointer to an array of pointer to some object type description struct.
   void** list;
+  /// Offset of the object type name (char*) in the description struct.
   void* name_off;
+  /// Offset of the object type info string (char*) in the description struct.
   void* info_off;
+  /// \brief Offset of the object type parameter description (\ref m_struct_st)
+  /// in the description struct.
   void* desc_off;
 } m_obj_list_t;
 
-typedef struct {
+/// The data type used by \ref m_option_type_obj_settings_list.
+typedef struct m_obj_settings {
+  /// Type of the object.
   char* name;
+  /// NULL terminated array of parameter/value pairs.
   char** attribs;
 } m_obj_settings_t;
+
+/// A parser to setup a list of objects.
+/** It create a NULL terminated array \ref m_obj_settings. The option priv
+ *  field (\ref m_option::priv) must point to a \ref m_obj_list_t describing
+ *  the available object types.
+ */
 extern m_option_type_t m_option_type_obj_settings_list;
 
-// Presets are mean to be used with options struct
+/// Extra definition needed for \ref m_option_type_obj_presets options.
-
-
 typedef struct {
+  /// Description of the struct holding the presets.
   struct m_struct_st* in_desc;
+  /// Description of the struct that should be set by the presets.
   struct m_struct_st* out_desc;
-  void* presets; // Pointer to an arry of struct defined by in_desc
+  /// Pointer to an array of struct defining the various presets.
-  void* name_off; // Offset of the preset name inside the in_struct
+  void* presets;
+  /// Offset of the preset's name inside the in_struct.
+  void* name_off;
 } m_obj_presets_t;
+
+/// Set several fields in a struct at once.
+/** For this two struct description are used. One for the struct holding the
+ *  preset and one for the struct beeing set. Every field present in both
+ *  struct will be copied from the preset struct to the destination one.
+ *  The option priv field (\ref m_option::priv) must point to a correctly
+ *  filled \ref m_obj_presets_t.
+ */
 extern m_option_type_t m_option_type_obj_presets;
 
+/// Parse an URL into a struct.
+/** The option priv field (\ref m_option::priv) must point to a
+ *  \ref m_struct_st describing which fields of the URL must be used.
+ */
 extern m_option_type_t m_option_type_custom_url;
 
+/// Extra definition needed for \ref m_option_type_obj_params options.
 typedef struct {
-  struct m_struct_st* desc; // Fields description
+  /// Fields description.
-  char separator; // Field separator to use
+  struct m_struct_st* desc;
+  /// Field separator to use.
+  char separator;
 } m_obj_params_t;
+
+/// Parse a set of parameters.
+/** Parameters are separated by the given separator and each one
+ *  successively set a field from the struct. The option priv field
+ *  (\ref m_option::priv) must point to a \ref m_obj_params_t.
+ */
 extern m_option_type_t m_option_type_obj_params;
 
 typedef struct {
   int start;
   int end;
 } m_span_t;
+/// Ready made settings to parse a \ref m_span_t with a start-end syntax.
 extern m_obj_params_t m_span_params_def;
 
 
@@ -102,67 +162,155 @@ extern m_obj_params_t m_span_params_def;
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
+/// Option type description
 struct m_option_type {
   char* name;
-  char* comments; // syntax desc, etc
+  /// Syntax desc, etc
-  unsigned int size; // size needed for a save slot
+  char* comments;
+  /// Size needed for the data.
+  unsigned int size;
+  /// See \ref OptionTypeFlags.
   unsigned int flags;
-
+  
-  // parse is the only requiered function all others can be NULL
+  /// Parse the data from a string.
-  // If dst if non-NULL it should create/update the save slot
+  /** It is the only required function, all others can be NULL.
-  // If dst is NULL it should just test the validity of the arg if possible
+   * 
-  // Src tell from where come this setting (ie cfg file, command line, playlist, ....
+   *  \param opt The option that is parsed.
-  // It should return 1 if param was used, 0 if not.
+   *  \param name The full option name.
-  // On error it must return 1 of the error code below
+   *  \param param The parameter to parse.
+   *  \param dst Pointer to the memory where the data should be writen.
+   *             If NULL the parameter validity should still be checked.
+   *  \param src Source of the option, see \ref OptionParserModes.
+   *  \return On error a negative value is returned, on success the number of argument
+   *          consumed. For details see \ref OptionParserReturn.
+   */
   int (*parse)(m_option_t* opt,char *name, char *param, void* dst, int src);
-  // Print back a value in human form
+  
+  /// Print back a value in string form.
+  /** \param opt The option to print.
+   *  \param val Pointer to the memory holding the data to be printed.
+   *  \return An allocated string containing the text value or (void*)-1
+   *          on error.
+   */
   char* (*print)(m_option_t* opt,  void* val);
 
-  // These 3 will be a memcpy in 50% of the case, it's called to save/restore the status of
+  /** \name
-  // the var it's there for complex type like CONF_TYPE_FUNC*
+   *  These functions are called to save/set/restore the status of the
-  // update a save slot (dst) from the current value in the prog (src)
+   *  variables. The difference between the 3 only matter for types like 
+   *  \ref m_option_type_func where 'setting' need to do more than just
+   *  copying some data.
+   */
+  //@{
+
+  /// Update a save slot (dst) from the current value in the prog (src).
+  /** \param opt The option to copy.
+   *  \param dst Pointer to the destination memory.
+   *  \param src Pointer to the source memory.
+   */
   void (*save)(m_option_t* opt,void* dst, void* src);
-  // set the current value (dst) from a save slot
+  
+  /// Set the value in the prog (dst) from a save slot.
+  /** \param opt The option to copy.
+   *  \param dst Pointer to the destination memory.
+   *  \param src Pointer to the source memory.
+   */
   void (*set)(m_option_t* opt,void* dst, void* src);
-  // Copy betewen 2 slot (if NULL and size > 0 a memcpy will be used
+
+  /// Copy the data between two save slots. If NULL and size is > 0 a memcpy will be used.
+  /** \param opt The option to copy.
+   *  \param dst Pointer to the destination memory.
+   *  \param src Pointer to the source memory.
+   */
   void (*copy)(m_option_t* opt,void* dst, void* src);
-  // Free the data allocated for a save slot if needed
+  //@}
+
+  /// Free the data allocated for a save slot.
+  /** This is only needed for dynamic types like strings.
+   *  \param dst Pointer to the data, usually a pointer that should be freed and
+   *             set to NULL.
+   */
   void (*free)(void* dst);
 };
 
+///@}
+
+/// Option description
+/** \ingroup Options
+ */
 struct m_option {
+  /// Option name.
   char *name;
-  void *p; 
+  
+  /// Reserved for higher level APIs, it shouldn't be used by parsers.
+  /** The suboption parser and func types do use it. They should instead
+   *  use the priv field but this was herited from older versions of the
+   *  config code.
+   */
+  void *p;
+  
+  /// Option type.
   m_option_type_t* type;
+  
+  /// See \ref OptionFlags.
   unsigned int flags;
-  double min,max;
+  
-  // This used to be function pointer to hold a 'reverse to defaults' func.
+  /// \brief Mostly usefull for numeric types, the \ref M_OPT_MIN flags must
-  // Nom it can be used to pass any type of extra args.
+  /// also be set.
-  // Passing a 'default func' is still valid for all func based option types
+  double min;
-  void* priv; // Type dependent data (for all kind of extended setting)
+
+  /// \brief Mostly usefull for numeric types, the \ref M_OPT_MAX flags must
+  /// also be set.
+  double max;
+  
+  /// Type dependent data (for all kind of extended setting).
+  /** This used to be function pointer to hold a 'reverse to defaults' func.
+   *  Now it can be used to pass any type of extra args needed by the parser.
+   *  Passing a 'default func' is still valid for all func based option types
+   */
+  void* priv;
 };
 
 
-//////////////////////////////// Option flags /////////////////////////////////
+/// \defgroup OptionFlags Option flags
+///@{
 
-// Option flags
+/// The option have a minimum set in \ref m_option::min.
 #define M_OPT_MIN		(1<<0)
+
+/// The option have a maximum set in \ref m_option::max.
 #define M_OPT_MAX		(1<<1)
+
+/// The option have a minimum and maximum in \ref m_option::min and \ref m_option::max.
 #define M_OPT_RANGE		(M_OPT_MIN|M_OPT_MAX)
+
+/// The option is forbidden in config files.
 #define M_OPT_NOCFG		(1<<2)
+
+/// The option is forbiden on the command line.
 #define M_OPT_NOCMD		(1<<3)
-// This option is global : it won't be saved on push and the command
+
-// line parser will set it when it's parsed (ie. it won't be set later)
+/// The option is global in the \ref Config.
-// e.g options : -v, -quiet
+/** It won't be saved on push and the command line parser will set it when
+ *  it's parsed (ie. it won't be set later)
+ *  e.g options : -v, -quiet
+ */
 #define M_OPT_GLOBAL		(1<<4)
-// Do not save this option : it won't be saved on push but the command
+
-// line parser will put it with it's entry (ie : it may be set later)
+/// The \ref Config won't save this option on push.
-// e.g options : -include
+/** It won't be saved on push but the command line parser will put it with
+ *  it's entry (ie : it may be set later)
+ *  e.g options : -include
+ */
 #define M_OPT_NOSAVE		(1<<5)
-// Emulate old behaviour by pushing the option only if it was set by the user
+
+/// \brief The \ref Config will emulate the old behaviour by pushing the
+/// option only if it was set by the user.
 #define M_OPT_OLD		(1<<6)
 
-// FIXME: backward compatibility
+/// \defgroup OldOptionFlags Backward compatibility
+///
+/// Those are kept for compatibility with older code.
+/// @{
 #define CONF_MIN		M_OPT_MIN
 #define CONF_MAX		M_OPT_MAX
 #define CONF_RANGE		M_OPT_RANGE
@@ -171,73 +319,135 @@ struct m_option {
 #define CONF_GLOBAL		M_OPT_GLOBAL
 #define CONF_NOSAVE		M_OPT_NOSAVE
 #define CONF_OLD		M_OPT_OLD
+///@}
 
+///@}
 
-///////////////////////////// Option type flags ///////////////////////////////////
+/// \defgroup OptionTypeFlags Option type flags
+/// \ingroup OptionTypes
+///
+/// These flags are used to describe special parser capabilities or behaviour.
+///
+///@{
 
-// These flags are for the parsers. The description here apply to the m_config_t
+/// Suboption parser flag.
-// based parsers (ie. cmd line and config file parsers)
+/** When this flag is set, m_option::p should point to another m_option
-// Some parser will refuse option types that have some of these flags
+ *  array. Only the parse function will be called. If dst is set, it should
-
+ *  create/update an array of char* containg opt/val pairs. The options in
-// This flag is used for the subconfig
+ *  the child array will then be set automatically by the \ref Config.
-// When this flag is set, opt->p should point to another m_option_t array
+ *  Also note that sub options may be directly accessed by using
-// Only the parse function will be called. If dst is set, it should create/update
+ *  -option:subopt blah.
-// an array of char* containg opt/val pairs.
+ */
-// Then the options in the child array will then be set automaticly.
-// You can only affect the way suboption are parsed.
-// Also note that suboptions may be directly accessed by using -option:subopt blah :-)
 #define M_OPT_TYPE_HAS_CHILD		(1<<0)
-// If this flag is set the option type support option name with * at the end (used for -aa*)
+
-// This only affect the option name matching, the option type have to implement
+/// Wildcard matching flag.
-// the needed stuff.
+/** If set the option type have a use for option name ending with a *
+ *  (used for -aa*), this only affect the option name matching.
+ */
 #define M_OPT_TYPE_ALLOW_WILDCARD	(1<<1)
-// This flag indicate that the data is dynamicly allocated (opt->p point to a pointer)
+
-// It enable a little hack wich replace the initial value by a dynamic copy
+/// Dynamic data type.
-// in case the initial value is staticly allocated (pretty common with strings)
+/** This flag indicate that the data is dynamicly allocated (m_option::p point
+ *  to a pointer). It enable a little hack in the \ref Config wich replace
+ *  the initial value of such variables with a dynamic copy in case the
+ *  initial value is staticaly allocated (pretty common with strings).
+ */
 #define M_OPT_TYPE_DYNAMIC		(1<<2)
-/// If this is set the parse function doesn't directly return
+
-// the wanted thing. Options use this if for some reasons they have to wait
+/// Indirect option type.
-// until the set call to be able to correctly set the target var.
+/** If this is set the parse function doesn't directly return
-// So for those types you have to first parse and then set the target var
+ *  the wanted thing. Options use this if for some reasons they have to wait
-// If this flag isn't set you can parse directly to the target var
+ *  until the set call to be able to correctly set the target var.
-// It's used for the callback based option as the callback call may append
+ *  So for those types new values must first be parsed, then set to the target
-// later on.
+ *  var. If this flag isn't set then new values can be parsed directly to the
+ *  target var. It's used by the callback based option as the callback call
+ *  may append later on.
+ */
 #define M_OPT_TYPE_INDIRECT		(1<<3)
 
+///@}
 
 ///////////////////////////// Parser flags ////////////////////////////////////////
 
-// Config mode : some parser type behave differently depending
+/// \defgroup OptionParserModes Option parser modes
-// on config->mode value wich is passed in the src param of parse()
+/// \ingroup Options
+///
+/// Some parser behave differently depending on the mode passed in the src
+/// parameter of m_option_type::parse. For example the flag type doesn't take
+/// an argument when parsing from the command line.
+///@{
+
+/// Set when parsing from a config file.
 #define M_CONFIG_FILE 0
+/// Set when parsing command line arguments.
 #define M_COMMAND_LINE 1
 
-// Option parser error code
+///@}
-#define M_OPT_UNKNOWN		-1
-#define M_OPT_MISSING_PARAM	-2
-#define M_OPT_INVALID		-3
-#define M_OPT_OUT_OF_RANGE	-4
-#define M_OPT_PARSER_ERR	-5
-#define M_OPT_EXIT              -6
-// M_OPT_EXIT must be the lowest number on this list.
-// To indicate that mplayer should exit without playing anything,
-// a parsing function needs to return M_OPT_EXIT less the number
-// of additional command line parameters it consumed.
-// Generally it will return either M_OPT_EXIT or M_OPT_EXIT - 1.
 
-// FIXME: backward compatibility
+/// \defgroup OptionParserReturn Option parser return code
+/// \ingroup Options
+///
+/// On sucess parsers return the number of arguments consumed: 0 or 1.
+///
+/// To indicate that mplayer should exit without playing anything,
+/// parsers return M_OPT_EXIT minus the number of parameters they
+/// consumed: \ref M_OPT_EXIT or \ref M_OPT_EXIT-1.
+///
+/// On error one of the following (negative) error code is returned:
+///@{
+
+/// For use by higer level APIs when the option name is invalid.
+#define M_OPT_UNKNOWN		-1
+
+/// Returned when a parameter is needed but wasn't provided.
+#define M_OPT_MISSING_PARAM	-2
+
+/// Returned when the given parameter couldn't be parsed.
+#define M_OPT_INVALID		-3
+
+/// \brief Returned if the value is "out of range". The exact meaning may 
+/// vary from type to type.
+#define M_OPT_OUT_OF_RANGE	-4
+
+/// Returned if the parser failed for any other reason than a bad parameter.
+#define M_OPT_PARSER_ERR	-5
+
+/// Returned when MPlayer should exit. Used by various help stuff.
+/** M_OPT_EXIT must be the lowest number on this list.
+ */
+#define M_OPT_EXIT              -6
+
+/// \defgroup OldOptionParserReturn Backward compatibility
+///
+/// Those are kept for compatibility with older code.
+///
+///@{
 #define ERR_NOT_AN_OPTION	M_OPT_UNKNOWN
 #define ERR_MISSING_PARAM	M_OPT_MISSING_PARAM
 #define ERR_OUT_OF_RANGE	M_OPT_OUT_OF_RANGE
 #define ERR_FUNC_ERR		M_OPT_PARSER_ERR
+///@}
 
+///@}
+
+/// Find the option matching the given name in the list.
+/** \ingroup Options
+ *  This function take the possible wildcards in account (see
+ *  \ref M_OPT_TYPE_ALLOW_WILDCARD).
+ * 
+ *  \param list Pointer to an array of \ref m_option.
+ *  \param name Name of the option.
+ *  \return The matching option or NULL.
+ */
 m_option_t* m_option_list_find(m_option_t* list,char* name);
 
+/// Helper to parse options, see \ref m_option_type::parse.
 inline static int
 m_option_parse(m_option_t* opt,char *name, char *param, void* dst, int src) {
   return opt->type->parse(opt,name,param,dst,src);
 }
 
+/// Helper to print options, see \ref m_option_type::print.
 inline static  char*
 m_option_print(m_option_t* opt,  void* val_ptr) {
   if(opt->type->print)
@@ -246,18 +456,21 @@ m_option_print(m_option_t* opt,  void* val_ptr) {
     return (char*)-1;
 }
 
+/// Helper around \ref m_option_type::save.
 inline static  void
 m_option_save(m_option_t* opt,void* dst, void* src) {
   if(opt->type->save)
     opt->type->save(opt,dst,src);
 }
 
+/// Helper around \ref m_option_type::set.
 inline static  void
 m_option_set(m_option_t* opt,void* dst, void* src) {
   if(opt->type->set)
     opt->type->set(opt,dst,src);
 }
 
+/// Helper around \ref m_option_type::copy.
 inline  static void
 m_option_copy(m_option_t* opt,void* dst, void* src) {
   if(opt->type->copy)
@@ -266,10 +479,13 @@ m_option_copy(m_option_t* opt,void* dst, void* src) {
     memcpy(dst,src,opt->type->size);
 }
 
+/// Helper around \ref m_option_type::free.
 inline static void
 m_option_free(m_option_t* opt,void* dst) {
   if(opt->type->free)
     opt->type->free(dst);
 }
 
+/*@}*/
+
 #endif /* _M_OPTION_H */

m_property.c

@@ -1,4 +1,7 @@
 
+/// \file
+/// \ingroup Properties
+
 #include "config.h"
 
 #include <stdlib.h>

m_property.h

@@ -1,50 +1,136 @@
 
-// Get the current value                                                   
+/// \defgroup Properties
-#define M_PROPERTY_GET         0                                           
+///
-// Get a string representing the current value                             
+/// Properties provide an interface to query and set the state of various
-#define M_PROPERTY_PRINT       1                                           
+/// things in MPlayer. The API is based on the \ref Options API like the
-// Set a new value                                                         
+/// \ref Config, but instead of using variables, properties use an ioctl like
-#define M_PROPERTY_SET         2                                           
+/// function. The function is used to perform various actions like get and set
-// Set a new value from a string                                           
+/// (see \ref PropertyActions).
-#define M_PROPERTY_PARSE       3                                           
+///@{
-// Increment the property                                                  
-#define M_PROPERTY_STEP_UP     4                                           
-// Decrement the property                                                  
-#define M_PROPERTY_STEP_DOWN   5                                           
 
-// Return values for the control function
+/// \file
+
+/// \defgroup PropertyActions Property actions
+/// \ingroup Properties
+///@{
+
+/// Get the current value.
+/** \param arg Pointer to a variable of the right type.
+ */
+#define M_PROPERTY_GET         0
+
+/// Get a string representing the current value.
+/** Set the variable to a newly allocated string or NULL.
+ *  \param arg Pointer to a char* variable.
+ */
+#define M_PROPERTY_PRINT       1
+
+/// Set a new value.
+/** The variable is updated to the value actually set.
+ *  \param arg Pointer to a variable of the right type.
+ */
+#define M_PROPERTY_SET         2
+
+/// Set a new value from a string.
+/** \param arg String containing the value.
+ */
+#define M_PROPERTY_PARSE       3
+
+/// Increment the current value.
+/** The sign of the argument is also taken into account if applicable.
+ *  \param arg Pointer to a variable of the right type or NULL.
+ */
+#define M_PROPERTY_STEP_UP     4
+
+/// Decrement the current value.
+/** The sign of the argument is also taken into account if applicable.
+ *  \param arg Pointer to a variable of the right type or NULL.
+ */
+#define M_PROPERTY_STEP_DOWN   5
+
+///@}
+
+/// \defgroup PropertyActionsReturn Property actions return code
+/// \ingroup Properties
+/// \brief  Return values for the control function.
+///@{
+
+/// Returned on success.
 #define M_PROPERTY_OK                1
+
+/// Returned on error.
 #define M_PROPERTY_ERROR             0
-// Returned when the property can't be used, for ex something about
+
-// the subs while playing audio only
+/// \brief Returned when the property can't be used, for ex something about
+/// the subs while playing audio only
 #define M_PROPERTY_UNAVAILABLE      -1
-// Returned if the requested action is not implemented
+
+/// Returned if the requested action is not implemented.
 #define M_PROPERTY_NOT_IMPLEMENTED  -2
-// Returned when asking for a property that doesn't exist
+
+/// Returned when asking for a property that doesn't exist.
 #define M_PROPERTY_UNKNOWN          -3
-// Returned when the action can't be done (like setting the volume when edl mute)
+
+/// Returned when the action can't be done (like setting the volume when edl mute).
 #define M_PROPERTY_DISABLED         -4
 
+///@}
+
+/// \ingroup Properties
+/// \brief Property action callback.
 typedef int(*m_property_ctrl_f)(m_option_t* prop,int action,void* arg);
 
+/// Do an action on a property.
+/** \param prop The property.
+ *  \param action See \ref PropertyActions.
+ *  \param arg Argument, usually a pointer to the data type used by the property.
+ *  \return See \ref PropertyActionsReturn.
+ */
 int m_property_do(m_option_t* prop, int action, void* arg);
 
+/// Print the current value of a property.
+/** \param prop The property.
+ *  \return A newly allocated string with current value or NULL on error.
+ */
 char* m_property_print(m_option_t* prop);
 
+/// Set a property.
+/** \param prop The property.
+ *  \param txt The value to set.
+ *  \return 1 on success, 0 on error.
+ */
 int m_property_parse(m_option_t* prop, char* txt);
 
+/// Print a list of properties.
 void m_properties_print_help_list(m_option_t* list);
 
+/// Expand a property string.
+/** This function allow to print strings containing property values.
+ *  ${NAME} is expanded to the value of property NAME or an empty
+ *  string in case of error. $(NAME:STR) expand STR only if the property
+ *  NAME is available.
+ * 
+ *  \param prop_list An array of \ref m_option describing the available
+ *                   properties.
+ *  \param str The string to expand.
+ *  \return The newly allocated expanded string.
+ */
 char* m_properties_expand_string(m_option_t* prop_list,char* str);
 
 // Helpers to use MPlayer's properties
 
+/// Get an MPlayer property.
 m_option_t*  mp_property_find(char* name);
 
+/// Do an action with an MPlayer property.
 int mp_property_do(char* name,int action, void* val);
 
-// Helpers for property implementations
+/// \defgroup PropertyImplHelper Property implementation helpers
+/// \ingroup Properties
+/// \brief Helper functions for common property types.
+///@{
 
+/// Clamp a value according to \ref m_option::min and \ref m_option::max.
 #define M_PROPERTY_CLAMP(prop,val) do {                                 \
         if(((prop)->flags & M_OPT_MIN) && (val) < (prop)->min)          \
             (val) = (prop)->min;                                        \
@@ -52,37 +138,41 @@ int mp_property_do(char* name,int action, void* val);
             (val) = (prop)->max;                                        \
     } while(0)
 
-// Implement get
+/// Implement get.
 int m_property_int_ro(m_option_t* prop,int action,
                       void* arg,int var);
 
-// Implement set, get and step up/down
+/// Implement set, get and step up/down.
 int m_property_int_range(m_option_t* prop,int action,
                          void* arg,int* var);
 
-// Same but cycle
+/// Same as m_property_int_range but cycle.
 int m_property_choice(m_option_t* prop,int action,
                       void* arg,int* var);
 
-// Switch betwen min and max
+/// Switch betwen min and max.
 int m_property_flag(m_option_t* prop,int action,
                     void* arg,int* var);
 
-// Implement get, print
+/// Implement get, print.
 int m_property_float_ro(m_option_t* prop,int action,
                         void* arg,float var);
 
-// Implement set, get and step up/down
+/// Implement set, get and step up/down
 int m_property_float_range(m_option_t* prop,int action,
                            void* arg,float* var);
 
-// float with a print function which print the time in ms
+/// float with a print function which print the time in ms
 int m_property_delay(m_option_t* prop,int action,
                      void* arg,float* var);
 
-// Implement get, print
+/// Implement get, print
 int m_property_double_ro(m_option_t* prop,int action,
                          void* arg,double var);
 
-// get/print the string
+/// get/print the string
 int m_property_string_ro(m_option_t* prop,int action,void* arg, char* str);
+
+///@}
+
+///@}

m_struct.c

@@ -1,3 +1,7 @@
+
+/// \file
+/// \ingroup OptionsStruct
+
 #include "config.h"
 
 #include <stdlib.h>

m_struct.h

@@ -1,48 +1,108 @@
 #ifndef _M_STRUCT_H
 #define _M_STRUCT_H
 
-///////////////////// A struct setter ////////////////////////
+/// \defgroup OptionsStruct Options struct
+/// \ingroup Options
+/// An API to manipulate structs using m_option.
+///@{
+
+/// \file m_struct.h
 
 struct m_option;
 
 /// Struct definition
 typedef struct m_struct_st {
-  char* name; // For error msg and debuging
+  /// For error msg and debuging
-  unsigned int size; // size of the whole struct
+  char* name;
-  void* defaults; // Pointer to a struct filled with the default settings
+  /// size of the whole struct
-  struct m_option* fields; // settable fields
+  unsigned int size;
+  /// Pointer to a struct filled with the default settings
+  void* defaults;
+  /// Field list.
+  /** The p field of the \ref m_option struct must contain the offset
+   *  of the member in the struct (use M_ST_OFF macro for this).
+   */
+  struct m_option* fields;
 } m_struct_t;
 
-// Note : the p field of the m_option_t struct must contain the offset
-// of the member in the struct (use M_ST_OFF macro for this).
 
 // From glib.h (modified ;-)
+
+/// Get the offset of a struct field.
+/** \param struct_type Struct type.
+ *  \param member Name of the field.
+ *  \return The offset of the field in bytes.
+ */
 #define M_ST_OFF(struct_type, member)    \
     ((void*) &((struct_type*) 0)->member)
+
+/// Get a pointer to a struct field.
+/** \param struct_p Pointer to the struct.
+ *  \param struct_offset Offset of the field in the struct.
+ *  \return Pointer to the struct field.
+ */
 #define M_ST_MB_P(struct_p, struct_offset)   \
     ((void*) (struct_p) + (unsigned long) (struct_offset))
+
+/// Acces a struct field at a given offset.
+/** \param member_type Type of the field.
+ *  \param struct_p Pointer to the struct.
+ *  \param struct_offset Offset of the field in the struct.
+ *  \return The struct field at the given offset.
+ */
 #define M_ST_MB(member_type, struct_p, struct_offset)   \
     (*(member_type*) M_ST_MB_P ((struct_p), (struct_offset)))
 
 
 
-/// Allocate the struct and set it to the defaults
+/// Allocate the struct and set it to the defaults.
+/** \param st Struct definition.
+ *  \return The newly allocated object set to default.
+ */
 void*
 m_struct_alloc(m_struct_t* st);
-/// Set a field of the struct
+
+/// Set a field of the struct.
+/** \param st Struct definition.
+ *  \param obj Pointer to the struct to set.
+ *  \param field Name of the field to set.
+ *  \param param New value of the field.
+ *  \return 0 on error, 1 on success.
+ */
 int
 m_struct_set(m_struct_t* st, void* obj, char* field, char* param);
-/// Reset a field (or all if field == NULL) to defaults
+
+/// Reset a field (or all if field == NULL) to defaults.
+/** \param st Struct definiton.
+ *  \param obj Pointer to the struct to set.
+ *  \param field Name of the field to reset, if NULL all fields are reseted.
+ */
 void
 m_struct_reset(m_struct_t* st, void* obj, char* field);
-/// Create a copy of an existing struct
+
+/// Create a copy of an existing struct.
+/** \param st Struct definiton.
+ *  \param obj Pointer to the struct to copy.
+ *  \return Newly allocated copy of obj.
+ */
 void*
 m_struct_copy(m_struct_t* st, void* obj);
-/// Free an allocated struct
+
+/// Free an allocated struct.
+/** \param st Struct definiton.
+ *  \param obj Pointer to the struct to copy.
+ */
 void
 m_struct_free(m_struct_t* st, void* obj);
-/// Get a field description
+
+/// Get a field description.
+/** \param st Struct definiton.
+ *  \param f Name of the field.
+ *  \return The \ref m_option struct describing the field or NULL if not found.
+ */
 struct m_option*
 m_struct_get_field(m_struct_t* st,char* f);
 
+///@}
+
 #endif /* _M_STRUCT_H */