m_option.h

   1 #ifndef MPLAYER_M_OPTION_H
   2 #define MPLAYER_M_OPTION_H
   3
   4 #include <string.h>
   5 #include <stddef.h>
   6
   7 /// \defgroup Options
   8 /// m_option allows to parse, print and copy data of various types.
   9 /// It is the base of the \ref OptionsStruct, \ref Config and
  10 /// \ref Properties APIs.
  11 ///@{
  12
  13 /// \file m_option.h
  14
  15 /// \ingroup OptionTypes
  16 typedef struct m_option_type m_option_type_t;
  17 typedef struct m_option m_option_t;
  18 struct m_struct_st;
  19
  20 /// \defgroup OptionTypes Options types
  21 /// \ingroup Options
  22 ///@{
  23
  24 ///////////////////////////// Options types declarations ////////////////////////////
  25
  26 // Simple types
  27 extern const m_option_type_t m_option_type_flag;
  28 extern const m_option_type_t m_option_type_int;
  29 extern const m_option_type_t m_option_type_int64;
  30 extern const m_option_type_t m_option_type_float;
  31 extern const m_option_type_t m_option_type_double;
  32 extern const m_option_type_t m_option_type_string;
  33 extern const m_option_type_t m_option_type_string_list;
  34 extern const m_option_type_t m_option_type_position;
  35 extern const m_option_type_t m_option_type_time;
  36 extern const m_option_type_t m_option_type_time_size;
  37
  38 extern const m_option_type_t m_option_type_print;
  39 extern const m_option_type_t m_option_type_print_indirect;
  40 extern const m_option_type_t m_option_type_print_func;
  41 extern const m_option_type_t m_option_type_subconfig;
  42 extern const m_option_type_t m_option_type_imgfmt;
  43 extern const m_option_type_t m_option_type_afmt;
  44
  45 // Func-based types
  46 extern const m_option_type_t m_option_type_func_full;
  47 extern const m_option_type_t m_option_type_func_param;
  48 extern const m_option_type_t m_option_type_func;
  49
  50 /// Callback used to reset func options.
  51 typedef void (*m_opt_default_func_t)(const m_option_t *, const char*);
  52
  53 /// Callback used by m_option_type_func_full options.
  54 typedef int (*m_opt_func_full_t)(const m_option_t *, const char *, char *);
  55
  56 /// Callback used by m_option_type_func_param options.
  57 typedef int (*m_opt_func_param_t)(const m_option_t *, const char *);
  58
  59 /// Callback used by m_option_type_func options.
  60 typedef int (*m_opt_func_t)(const m_option_t *);
  61
  62 // Backwards compatibility
  63 typedef m_opt_default_func_t cfg_default_func_t;
  64 typedef m_opt_func_full_t cfg_func_arg_param_t;
  65 typedef m_opt_func_param_t cfg_func_param_t;
  66 typedef m_opt_func_t cfg_func_t;
  67
  68 #define END_AT_NONE   0
  69 #define END_AT_TIME   1
  70 #define END_AT_SIZE   2
  71 typedef struct {
  72   double pos;
  73   int type;
  74 } m_time_size_t;
  75
  76 /// Extra definition needed for \ref m_option_type_obj_settings_list options.
  77 typedef struct {
  78   /// Pointer to an array of pointer to some object type description struct.
  79   void** list;
  80   /// Offset of the object type name (char*) in the description struct.
  81   void* name_off;
  82   /// Offset of the object type info string (char*) in the description struct.
  83   void* info_off;
  84   /// \brief Offset of the object type parameter description (\ref m_struct_st)
  85   /// in the description struct.
  86   void* desc_off;
  87 } m_obj_list_t;
  88
  89 /// The data type used by \ref m_option_type_obj_settings_list.
  90 typedef struct m_obj_settings {
  91   /// Type of the object.
  92   char* name;
  93   /// NULL terminated array of parameter/value pairs.
  94   char** attribs;
  95 } m_obj_settings_t;
  96
  97 /// A parser to set up a list of objects.
  98 /** It creates a NULL terminated array \ref m_obj_settings. The option priv
  99  *  field (\ref m_option::priv) must point to a \ref m_obj_list_t describing
 100  *  the available object types.
 101  */
 102 extern const m_option_type_t m_option_type_obj_settings_list;
 103
 104 /// Extra definition needed for \ref m_option_type_obj_presets options.
 105 typedef struct {
 106   /// Description of the struct holding the presets.
 107   struct m_struct_st* in_desc;
 108   /// Description of the struct that should be set by the presets.
 109   struct m_struct_st* out_desc;
 110   /// Pointer to an array of structs defining the various presets.
 111   void* presets;
 112   /// Offset of the preset's name inside the in_struct.
 113   void* name_off;
 114 } m_obj_presets_t;
 115
 116 /// Set several fields in a struct at once.
 117 /** For this two struct descriptions are used. One for the struct holding the
 118  *  preset and one for the struct beeing set. Every field present in both
 119  *  structs will be copied from the preset struct to the destination one.
 120  *  The option priv field (\ref m_option::priv) must point to a correctly
 121  *  filled \ref m_obj_presets_t.
 122  */
 123 extern const m_option_type_t m_option_type_obj_presets;
 124
 125 /// Parse an URL into a struct.
 126 /** The option priv field (\ref m_option::priv) must point to a
 127  *  \ref m_struct_st describing which fields of the URL must be used.
 128  */
 129 extern const m_option_type_t m_option_type_custom_url;
 130
 131 /// Extra definition needed for \ref m_option_type_obj_params options.
 132 typedef struct {
 133   /// Field descriptions.
 134   const struct m_struct_st* desc;
 135   /// Field separator to use.
 136   char separator;
 137 } m_obj_params_t;
 138
 139 /// Parse a set of parameters.
 140 /** Parameters are separated by the given separator and each one
 141  *  successively sets a field from the struct. The option priv field
 142  *  (\ref m_option::priv) must point to a \ref m_obj_params_t.
 143  */
 144 extern const m_option_type_t m_option_type_obj_params;
 145
 146 typedef struct {
 147   int start;
 148   int end;
 149 } m_span_t;
 150 /// Ready made settings to parse a \ref m_span_t with a start-end syntax.
 151 extern const m_obj_params_t m_span_params_def;
 152
 153
 154 // FIXME: backward compatibility
 155 #define CONF_TYPE_FLAG          (&m_option_type_flag)
 156 #define CONF_TYPE_INT           (&m_option_type_int)
 157 #define CONF_TYPE_INT64         (&m_option_type_int64)
 158 #define CONF_TYPE_FLOAT         (&m_option_type_float)
 159 #define CONF_TYPE_DOUBLE        (&m_option_type_double)
 160 #define CONF_TYPE_STRING        (&m_option_type_string)
 161 #define CONF_TYPE_FUNC          (&m_option_type_func)
 162 #define CONF_TYPE_FUNC_PARAM    (&m_option_type_func_param)
 163 #define CONF_TYPE_PRINT         (&m_option_type_print)
 164 #define CONF_TYPE_PRINT_INDIRECT (&m_option_type_print_indirect)
 165 #define CONF_TYPE_PRINT_FUNC    (&m_option_type_print_func)
 166 #define CONF_TYPE_FUNC_FULL     (&m_option_type_func_full)
 167 #define CONF_TYPE_SUBCONFIG     (&m_option_type_subconfig)
 168 #define CONF_TYPE_STRING_LIST   (&m_option_type_string_list)
 169 #define CONF_TYPE_POSITION      (&m_option_type_position)
 170 #define CONF_TYPE_IMGFMT        (&m_option_type_imgfmt)
 171 #define CONF_TYPE_AFMT          (&m_option_type_afmt)
 172 #define CONF_TYPE_SPAN          (&m_option_type_span)
 173 #define CONF_TYPE_OBJ_SETTINGS_LIST (&m_option_type_obj_settings_list)
 174 #define CONF_TYPE_OBJ_PRESETS   (&m_option_type_obj_presets)
 175 #define CONF_TYPE_CUSTOM_URL    (&m_option_type_custom_url)
 176 #define CONF_TYPE_OBJ_PARAMS    (&m_option_type_obj_params)
 177 #define CONF_TYPE_TIME          (&m_option_type_time)
 178 #define CONF_TYPE_TIME_SIZE     (&m_option_type_time_size)
 179
 180 /////////////////////////////////////////////////////////////////////////////////////////////
 181
 182 /// Option type description
 183 struct m_option_type {
 184   char* name;
 185   /// Syntax description, etc
 186   char* comments;
 187   /// Size needed for the data.
 188   unsigned int size;
 189   /// See \ref OptionTypeFlags.
 190   unsigned int flags;
 191
 192   /// Parse the data from a string.
 193   /** It is the only required function, all others can be NULL.
 194    *
 195    *  \param opt The option that is parsed.
 196    *  \param name The full option name.
 197    *  \param param The parameter to parse.
 198    *  \param dst Pointer to the memory where the data should be written.
 199    *             If NULL the parameter validity should still be checked.
 200    *  \param src Source of the option, see \ref OptionParserModes.
 201    *  \return On error a negative value is returned, on success the number of arguments
 202    *          consumed. For details see \ref OptionParserReturn.
 203    */
 204   int (*parse)(const m_option_t* opt,const char *name, char *param, void* dst, int src);
 205
 206   /// Print back a value in string form.
 207   /** \param opt The option to print.
 208    *  \param val Pointer to the memory holding the data to be printed.
 209    *  \return An allocated string containing the text value or (void*)-1
 210    *          on error.
 211    */
 212   char* (*print)(const m_option_t* opt, const void* val);
 213
 214   /** \name
 215    *  These functions are called to save/set/restore the status of the
 216    *  variables. The difference between the 3 only matters for types like
 217    *  \ref m_option_type_func where 'setting' needs to do more than just
 218    *  copying some data.
 219    */
 220   //@{
 221
 222   /// Update a save slot (dst) from the current value in the program (src).
 223   /** \param opt The option to copy.
 224    *  \param dst Pointer to the destination memory.
 225    *  \param src Pointer to the source memory.
 226    */
 227   void (*save)(const m_option_t* opt,void* dst, void* src);
 228
 229   /// Set the value in the program (dst) from a save slot.
 230   /** \param opt The option to copy.
 231    *  \param dst Pointer to the destination memory.
 232    *  \param src Pointer to the source memory.
 233    */
 234   void (*set)(const m_option_t* opt,void* dst, void* src);
 235
 236   /// Copy the data between two save slots. If NULL and size is > 0 a memcpy will be used.
 237   /** \param opt The option to copy.
 238    *  \param dst Pointer to the destination memory.
 239    *  \param src Pointer to the source memory.
 240    */
 241   void (*copy)(const m_option_t* opt,void* dst, void* src);
 242   //@}
 243
 244   /// Free the data allocated for a save slot.
 245   /** This is only needed for dynamic types like strings.
 246    *  \param dst Pointer to the data, usually a pointer that should be freed and
 247    *             set to NULL.
 248    */
 249   void (*free)(void* dst);
 250 };
 251
 252 ///@}
 253
 254 /// Option description
 255 /** \ingroup Options
 256  */
 257 struct m_option {
 258   /// Option name.
 259   const char *name;
 260
 261   /// Reserved for higher level APIs, it shouldn't be used by parsers.
 262   /** The suboption parser and func types do use it. They should instead
 263    *  use the priv field but this was inherited from older versions of the
 264    *  config code.
 265    */
 266   void *p;
 267
 268   /// Option type.
 269   const m_option_type_t* type;
 270
 271   /// See \ref OptionFlags.
 272   unsigned int flags;
 273
 274   /// \brief Mostly useful for numeric types, the \ref M_OPT_MIN flags must
 275   /// also be set.
 276   double min;
 277
 278   /// \brief Mostly useful for numeric types, the \ref M_OPT_MAX flags must
 279   /// also be set.
 280   double max;
 281
 282   /// Type dependent data (for all kinds of extended settings).
 283   /** This used to be a function pointer to hold a 'reverse to defaults' func.
 284    *  Now it can be used to pass any type of extra args needed by the parser.
 285    *  Passing a 'default func' is still valid for all func based option types.
 286    */
 287   void* priv;
 288
 289   int new;
 290
 291   int offset;
 292 };
 293
 294
 295 /// \defgroup OptionFlags Option flags
 296 ///@{
 297
 298 /// The option has a minimum set in \ref m_option::min.
 299 #define M_OPT_MIN               (1<<0)
 300
 301 /// The option has a maximum set in \ref m_option::max.
 302 #define M_OPT_MAX               (1<<1)
 303
 304 /// The option has a minimum and maximum in \ref m_option::min and \ref m_option::max.
 305 #define M_OPT_RANGE             (M_OPT_MIN|M_OPT_MAX)
 306
 307 /// The option is forbidden in config files.
 308 #define M_OPT_NOCFG             (1<<2)
 309
 310 /// The option is forbidden on the command line.
 311 #define M_OPT_NOCMD             (1<<3)
 312
 313 /// The option is global in the \ref Config.
 314 /** It won't be saved on push and the command line parser will set it when
 315  *  it's parsed (i.e. it won't be set later)
 316  *  e.g options : -v, -quiet
 317  */
 318 #define M_OPT_GLOBAL            (1<<4)
 319
 320 /// The \ref Config won't save this option on push.
 321 /** It won't be saved on push but the command line parser will add it with
 322  *  its entry (i.e. it may be set later)
 323  *  e.g options : -include
 324  */
 325 #define M_OPT_NOSAVE            (1<<5)
 326
 327 /// \brief The \ref Config will emulate the old behavior by pushing the
 328 /// option only if it was set by the user.
 329 #define M_OPT_OLD               (1<<6)
 330
 331 /// The option should be set during command line pre-parsing
 332 #define M_OPT_PRE_PARSE         (1<<7)
 333
 334 /// \defgroup OldOptionFlags Backward compatibility
 335 ///
 336 /// These are kept for compatibility with older code.
 337 /// @{
 338 #define CONF_MIN                M_OPT_MIN
 339 #define CONF_MAX                M_OPT_MAX
 340 #define CONF_RANGE              M_OPT_RANGE
 341 #define CONF_NOCFG              M_OPT_NOCFG
 342 #define CONF_NOCMD              M_OPT_NOCMD
 343 #define CONF_GLOBAL             M_OPT_GLOBAL
 344 #define CONF_NOSAVE             M_OPT_NOSAVE
 345 #define CONF_OLD                M_OPT_OLD
 346 #define CONF_PRE_PARSE          M_OPT_PRE_PARSE
 347 ///@}
 348
 349 ///@}
 350
 351 /// \defgroup OptionTypeFlags Option type flags
 352 /// \ingroup OptionTypes
 353 ///
 354 /// These flags are used to describe special parser capabilities or behavior.
 355 ///
 356 ///@{
 357
 358 /// Suboption parser flag.
 359 /** When this flag is set, m_option::p should point to another m_option
 360  *  array. Only the parse function will be called. If dst is set, it should
 361  *  create/update an array of char* containg opt/val pairs. The options in
 362  *  the child array will then be set automatically by the \ref Config.
 363  *  Also note that suboptions may be directly accessed by using
 364  *  -option:subopt blah.
 365  */
 366 #define M_OPT_TYPE_HAS_CHILD            (1<<0)
 367
 368 /// Wildcard matching flag.
 369 /** If set the option type has a use for option names ending with a *
 370  *  (used for -aa*), this only affects the option name matching.
 371  */
 372 #define M_OPT_TYPE_ALLOW_WILDCARD       (1<<1)
 373
 374 /// Dynamic data type.
 375 /** This flag indicates that the data is dynamically allocated (m_option::p
 376  *  points to a pointer). It enables a little hack in the \ref Config wich
 377  *  replaces the initial value of such variables with a dynamic copy in case
 378  *  the initial value is statically allocated (pretty common with strings).
 379  */
 380 #define M_OPT_TYPE_DYNAMIC              (1<<2)
 381
 382 /// Indirect option type.
 383 /** If this is set the parse function doesn't directly return
 384  *  the wanted thing. Options use this if for some reasons they have to wait
 385  *  until the set call to be able to correctly set the target var.
 386  *  So for those types new values must first be parsed, then set to the target
 387  *  var. If this flag isn't set then new values can be parsed directly to the
 388  *  target var. It's used by the callback-based options as the callback call
 389  *  may append later on.
 390  */
 391 #define M_OPT_TYPE_INDIRECT             (1<<3)
 392
 393 ///@}
 394
 395 ///////////////////////////// Parser flags ////////////////////////////////////////
 396
 397 /// \defgroup OptionParserModes Option parser modes
 398 /// \ingroup Options
 399 ///
 400 /// Some parsers behave differently depending on the mode passed in the src
 401 /// parameter of m_option_type::parse. For example the flag type doesn't take
 402 /// an argument when parsing from the command line.
 403 ///@{
 404
 405 /// Set when parsing from a config file.
 406 #define M_CONFIG_FILE 0
 407 /// Set when parsing command line arguments.
 408 #define M_COMMAND_LINE 1
 409 /// Set when pre-parsing the command line
 410 #define M_COMMAND_LINE_PRE_PARSE 2
 411
 412 ///@}
 413
 414 /// \defgroup OptionParserReturn Option parser return code
 415 /// \ingroup Options
 416 ///
 417 /// On success parsers return the number of arguments consumed: 0 or 1.
 418 ///
 419 /// To indicate that MPlayer should exit without playing anything,
 420 /// parsers return M_OPT_EXIT minus the number of parameters they
 421 /// consumed: \ref M_OPT_EXIT or \ref M_OPT_EXIT-1.
 422 ///
 423 /// On error one of the following (negative) error codes is returned:
 424 ///@{
 425
 426 /// For use by higher level APIs when the option name is invalid.
 427 #define M_OPT_UNKNOWN           -1
 428
 429 /// Returned when a parameter is needed but wasn't provided.
 430 #define M_OPT_MISSING_PARAM     -2
 431
 432 /// Returned when the given parameter couldn't be parsed.
 433 #define M_OPT_INVALID           -3
 434
 435 /// \brief Returned if the value is "out of range". The exact meaning may
 436 /// vary from type to type.
 437 #define M_OPT_OUT_OF_RANGE      -4
 438
 439 /// Returned if the parser failed for any other reason than a bad parameter.
 440 #define M_OPT_PARSER_ERR        -5
 441
 442 /// Returned when MPlayer should exit. Used by various help stuff.
 443 /** M_OPT_EXIT must be the lowest number on this list.
 444  */
 445 #define M_OPT_EXIT              -6
 446
 447 /// \defgroup OldOptionParserReturn Backward compatibility
 448 ///
 449 /// These are kept for compatibility with older code.
 450 ///
 451 ///@{
 452 #define ERR_NOT_AN_OPTION       M_OPT_UNKNOWN
 453 #define ERR_MISSING_PARAM       M_OPT_MISSING_PARAM
 454 #define ERR_OUT_OF_RANGE        M_OPT_OUT_OF_RANGE
 455 #define ERR_FUNC_ERR            M_OPT_PARSER_ERR
 456 ///@}
 457
 458 ///@}
 459
 460 /// Find the option matching the given name in the list.
 461 /** \ingroup Options
 462  *  This function takes the possible wildcards into account (see
 463  *  \ref M_OPT_TYPE_ALLOW_WILDCARD).
 464  *
 465  *  \param list Pointer to an array of \ref m_option.
 466  *  \param name Name of the option.
 467  *  \return The matching option or NULL.
 468  */
 469 const m_option_t* m_option_list_find(const m_option_t* list,const char* name);
 470
 471 /// Helper to parse options, see \ref m_option_type::parse.
 472 inline static int
 473 m_option_parse(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
 474   return opt->type->parse(opt,name,param,dst,src);
 475 }
 476
 477 /// Helper to print options, see \ref m_option_type::print.
 478 inline static  char*
 479 m_option_print(const m_option_t* opt, const void* val_ptr) {
 480   if(opt->type->print)
 481     return opt->type->print(opt,val_ptr);
 482   else
 483     return (char*)-1;
 484 }
 485
 486 /// Helper around \ref m_option_type::copy.
 487 inline  static void
 488 m_option_copy(const m_option_t* opt,void* dst, void* src) {
 489   if(opt->type->copy)
 490     opt->type->copy(opt,dst,src);
 491   else if(opt->type->size > 0)
 492     memcpy(dst,src,opt->type->size);
 493 }
 494
 495 /// Helper around \ref m_option_type::free.
 496 inline static void
 497 m_option_free(const m_option_t* opt,void* dst) {
 498   if(opt->type->free)
 499     opt->type->free(dst);
 500 }
 501
 502 /*@}*/
 503
 504 #define OPT_FLAG_ON(optname, varname, flags) {optname, NULL, &m_option_type_flag, flags, 0, 1, NULL, 1, offsetof(struct MPOpts, varname)}
 505 #define OPT_FLAG_OFF(optname, varname, flags) {optname, NULL, &m_option_type_flag, flags, 1, 0, NULL, 1, offsetof(struct MPOpts, varname)}
 506 #define OPT_FLAG_CONSTANTS(optname, varname, flags, offvalue, value) {optname, NULL, &m_option_type_flag, flags, offvalue, value, NULL, 1, offsetof(struct MPOpts, varname)}
 507 #define OPT_STRINGLIST(optname, varname, flags) {optname, NULL, &m_option_type_string_list, flags, 0, 0, NULL, 1, offsetof(struct MPOpts, varname)}
 508 #define OPT_INT(optname, varname, flags) {optname, NULL, &m_option_type_int, flags, 0, 0, NULL, 1, offsetof(struct MPOpts, varname)}
 509 #define OPT_INTRANGE(optname, varname, flags, min, max) {optname, NULL, &m_option_type_int, (flags)|CONF_RANGE, min, max, NULL, 1, offsetof(struct MPOpts, varname)}
 510 #define OPT_FLOATRANGE(optname, varname, flags, min, max) {optname, NULL, &m_option_type_float, (flags)|CONF_RANGE, min, max, NULL, 1, offsetof(struct MPOpts, varname)}
 511 #define OPT_STRING(optname, varname, flags) {optname, NULL, &m_option_type_string, flags, 0, 0, NULL, 1, offsetof(struct MPOpts, varname)}
 512 #define OPT_SETTINGSLIST(optname, varname, flags, objlist) {optname, NULL, &m_option_type_obj_settings_list, flags, 0, 0, objlist, 1, offsetof(struct MPOpts, varname)}
 513
 514 #endif /* MPLAYER_M_OPTION_H */