RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/core/m_option.c

2380 lines
66 KiB
C
Raw Normal View History

Add license header to all top-level files missing them. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@30471 b3059339-0415-0410-9bf9-f77b7e298cf2
2010-01-30 23:24:23 +00:00
/*
* This file is part of MPlayer.
*
* MPlayer 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.
*
* MPlayer 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 MPlayer; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
Doxygen attack! git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@18259 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-04-24 19:20:04 +00:00
/// \file
/// \ingroup Options
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <stdio.h>
#include <stdarg.h>
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
#include <limits.h>
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
#include <inttypes.h>
FreeBSD fix git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8263 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-24 01:03:16 +00:00
#include <unistd.h>
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
#include <assert.h>
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
#include <libavutil/common.h>
#include <libavutil/avstring.h>
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
#include "talloc.h"
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
#include "core/mp_common.h"
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "core/m_option.h"
#include "core/mp_msg.h"
introduce new 'stream' directory for all stream layer related components and split them from libmpdemux git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19277 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-07-31 17:39:17 +00:00
#include "stream/url.h"
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
char *m_option_strerror(int code)
{
switch (code) {
case M_OPT_UNKNOWN:
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return mp_gtext("option not found");
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
case M_OPT_MISSING_PARAM:
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return mp_gtext("option requires parameter");
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
case M_OPT_INVALID:
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return mp_gtext("option parameter could not be parsed");
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
case M_OPT_OUT_OF_RANGE:
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return mp_gtext("parameter is outside values allowed for option");
case M_OPT_DISALLOW_PARAM:
return mp_gtext("option doesn't take a parameter");
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
case M_OPT_PARSER_ERR:
default:
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return mp_gtext("parser error");
options: commandline: print error type for parse failures If parsing an option fails, print a string corresponding to the parse function return value (M_OPT_MISSING_PARAM etc). The primary motivation is that the parsing code already outputs messages explaining most problems, but does not itself print anything in the missing parameter case. Before double-dash --options such errors were rare (or rather they resulted in the next commandline argument being silently misinterpreted as an argument to the previous option instead); but now an argument like "--ss" should give a better indication about the problem than just "Error parsing option".
2011-07-29 04:52:29 +00:00
}
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static const struct m_option *m_option_list_findb(const struct m_option *list,
struct bstr name)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
for (int i = 0; list[i].name; i++) {
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
struct bstr lname = bstr0(list[i].name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if ((list[i].type->flags & M_OPT_TYPE_ALLOW_WILDCARD)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
&& bstr_endswith0(lname, "*")) {
lname.len--;
if (bstrcasecmp(bstr_splice(name, 0, lname.len), lname) == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return &list[i];
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
} else if (bstrcasecmp(lname, name) == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return &list[i];
}
return NULL;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
const m_option_t *m_option_list_find(const m_option_t *list, const char *name)
{
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
return m_option_list_findb(list, bstr0(name));
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
}
spelling and grammar fixes galore git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10642 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-08-17 13:51:04 +00:00
// Default function that just does a memcpy
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
static void copy_opt(const m_option_t *opt, void *dst, const void *src)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
if (dst && src)
memcpy(dst, src, opt->type->size);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
// Flag
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(int *)(x))
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_flag(const m_option_t *opt, void *val)
{
if (VAL(val) == opt->min || VAL(val) == opt->max)
return 0;
VAL(val) = opt->min;
return M_OPT_OUT_OF_RANGE;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_flag(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
if (param.len) {
options: accept "yes" and "no" only for flags This removes the alternative values like "off", "0", "false" etc., and also the non-English versions of these. This is done for general consistency. It's better to have a single way of doing things when multiple ways don't add singificant value. Also update some choices for consistency.
2012-09-18 13:50:24 +00:00
if (!bstrcasecmp0(param, "yes")) {
if (dst)
VAL(dst) = opt->max;
return 1;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
options: accept "yes" and "no" only for flags This removes the alternative values like "off", "0", "false" etc., and also the non-English versions of these. This is done for general consistency. It's better to have a single way of doing things when multiple ways don't add singificant value. Also update some choices for consistency.
2012-09-18 13:50:24 +00:00
if (!bstrcasecmp0(param, "no")) {
if (dst)
VAL(dst) = opt->min;
return 1;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
}
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Invalid parameter for %.*s flag: %.*s\n",
BSTR_P(name), BSTR_P(param));
return M_OPT_INVALID;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
} else {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (dst)
VAL(dst) = opt->max;
return 0;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_flag(const m_option_t *opt, const void *val)
{
if (VAL(val) == opt->min)
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_strdup(NULL, "no");
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
else
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_strdup(NULL, "yes");
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
static void add_flag(const m_option_t *opt, void *val, double add, bool wrap)
{
if (fabs(add) < 0.5)
return;
bool state = VAL(val) != opt->min;
state = wrap ? !state : add > 0;
VAL(val) = state ? opt->max : opt->min;
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_flag = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// need yes or no in config files
.name = "Flag",
.size = sizeof(int),
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
.flags = M_OPT_TYPE_OPTIONAL_PARAM,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.parse = parse_flag,
.print = print_flag,
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_flag,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_flag,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
options: change handling of "no-" options Normally, all flag options can be negated by prepending a "no-", for example "--no-opt" becomes "--opt=no". Some flag options can't actually be negated, so add a CONF_TYPE_STORE option type to disallow the "no-" fallback. Do the same for choice options. Remove the explicit "no-" prefixed options, add "no" as choice. Move the handling of automatic "no-" options from parser-mpcmd.c to m_config.c, and use it in m_config_set_option/m_config_parse_option. This makes these options available in the config file. It also simplifies sub-option parsing, because it doesn't need to handle "no-" anymore.
2012-09-20 01:32:01 +00:00
// Single-value, write-only flag
static int parse_store(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
{
if (param.len == 0 || bstrcasecmp0(param, "yes") == 0) {
if (dst)
VAL(dst) = opt->max;
return 0;
} else {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Invalid parameter for %.*s flag: %.*s\n",
BSTR_P(name), BSTR_P(param));
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
return M_OPT_DISALLOW_PARAM;
options: change handling of "no-" options Normally, all flag options can be negated by prepending a "no-", for example "--no-opt" becomes "--opt=no". Some flag options can't actually be negated, so add a CONF_TYPE_STORE option type to disallow the "no-" fallback. Do the same for choice options. Remove the explicit "no-" prefixed options, add "no" as choice. Move the handling of automatic "no-" options from parser-mpcmd.c to m_config.c, and use it in m_config_set_option/m_config_parse_option. This makes these options available in the config file. It also simplifies sub-option parsing, because it doesn't need to handle "no-" anymore.
2012-09-20 01:32:01 +00:00
}
}
const m_option_type_t m_option_type_store = {
// can only be activated
.name = "Flag",
.size = sizeof(int),
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
.flags = M_OPT_TYPE_OPTIONAL_PARAM,
options: change handling of "no-" options Normally, all flag options can be negated by prepending a "no-", for example "--no-opt" becomes "--opt=no". Some flag options can't actually be negated, so add a CONF_TYPE_STORE option type to disallow the "no-" fallback. Do the same for choice options. Remove the explicit "no-" prefixed options, add "no" as choice. Move the handling of automatic "no-" options from parser-mpcmd.c to m_config.c, and use it in m_config_set_option/m_config_parse_option. This makes these options available in the config file. It also simplifies sub-option parsing, because it doesn't need to handle "no-" anymore.
2012-09-20 01:32:01 +00:00
.parse = parse_store,
};
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
// Integer
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
#undef VAL
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_longlong(const m_option_t *opt, void *val)
{
long long v = *(long long *)val;
int r = 0;
if ((opt->flags & M_OPT_MAX) && (v > opt->max)) {
v = opt->max;
r = M_OPT_OUT_OF_RANGE;
}
if ((opt->flags & M_OPT_MIN) && (v < opt->min)) {
v = opt->min;
r = M_OPT_OUT_OF_RANGE;
}
*(long long *)val = v;
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_longlong(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr rest;
long long tmp_int = bstrtoll(param, &rest, 10);
if (rest.len)
tmp_int = bstrtoll(param, &rest, 0);
if (rest.len) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be an integer: %.*s\n",
BSTR_P(name), BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if ((opt->flags & M_OPT_MIN) && (tmp_int < opt->min)) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be >= %d: %.*s\n",
BSTR_P(name), (int) opt->min, BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if ((opt->flags & M_OPT_MAX) && (tmp_int > opt->max)) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be <= %d: %.*s\n",
BSTR_P(name), (int) opt->max, BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (dst)
*(long long *)dst = tmp_int;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_int(const m_option_t *opt, void *val)
{
long long tmp = *(int *)val;
int r = clamp_longlong(opt, &tmp);
*(int *)val = tmp;
return r;
}
static int clamp_int64(const m_option_t *opt, void *val)
{
long long tmp = *(int64_t *)val;
int r = clamp_longlong(opt, &tmp);
*(int64_t *)val = tmp;
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_int(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
{
long long tmp;
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
int r = parse_longlong(opt, name, param, &tmp);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (r >= 0 && dst)
*(int *)dst = tmp;
return r;
}
static int parse_int64(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
{
long long tmp;
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
int r = parse_longlong(opt, name, param, &tmp);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (r >= 0 && dst)
*(int64_t *)dst = tmp;
return r;
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_int(const m_option_t *opt, const void *val)
{
if (opt->type->size == sizeof(int64_t))
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_asprintf(NULL, "%"PRId64, *(const int64_t *)val);
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
return talloc_asprintf(NULL, "%d", *(const int *)val);
}
static void add_int64(const m_option_t *opt, void *val, double add, bool wrap)
{
int64_t v = *(int64_t *)val;
v = v + add;
bool is64 = opt->type->size == sizeof(int64_t);
int64_t nmin = is64 ? INT64_MIN : INT_MIN;
int64_t nmax = is64 ? INT64_MAX : INT_MAX;
int64_t min = (opt->flags & M_OPT_MIN) ? opt->min : nmin;
int64_t max = (opt->flags & M_OPT_MAX) ? opt->max : nmax;
if (v < min)
v = wrap ? max : min;
if (v > max)
v = wrap ? min : max;
*(int64_t *)val = v;
}
static void add_int(const m_option_t *opt, void *val, double add, bool wrap)
{
int64_t tmp = *(int *)val;
add_int64(opt, &tmp, add, wrap);
*(int *)val = tmp;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_int = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Integer",
.size = sizeof(int),
.parse = parse_int,
.print = print_int,
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_int,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_int,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
Add a 64 bit integer type to the suboption parser. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@28794 b3059339-0415-0410-9bf9-f77b7e298cf2
2009-03-02 11:17:50 +00:00
const m_option_type_t m_option_type_int64 = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Integer64",
.size = sizeof(int64_t),
.parse = parse_int64,
.print = print_int,
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_int64,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_int64,
Add a 64 bit integer type to the suboption parser. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@28794 b3059339-0415-0410-9bf9-f77b7e298cf2
2009-03-02 11:17:50 +00:00
};
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_intpair(const struct m_option *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
return M_OPT_MISSING_PARAM;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr s = param;
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
int end = -1;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int start = bstrtoll(s, &s, 10);
if (s.len == param.len)
goto bad;
if (s.len > 0) {
if (!bstr_startswith0(s, "-"))
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
goto bad;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
s = bstr_cut(s, 1);
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (s.len > 0)
end = bstrtoll(s, &s, 10);
if (s.len > 0)
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
goto bad;
if (dst) {
int *p = dst;
p[0] = start;
p[1] = end;
}
return 1;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
bad:
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid integer range "
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"specification for option %.*s: %.*s\n",
BSTR_P(name), BSTR_P(param));
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
return M_OPT_INVALID;
}
const struct m_option_type m_option_type_intpair = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Int[-Int]",
.size = sizeof(int[2]),
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
.parse = parse_intpair,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
};
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_choice(const m_option_t *opt, void *val)
{
int v = *(int *)val;
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX)) {
if (v >= opt->min && v <= opt->max)
return 0;
}
;
for (struct m_opt_choice_alternatives *alt = opt->priv; alt->name; alt++) {
if (alt->value == v)
return 0;
}
return M_OPT_INVALID;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_choice(const struct m_option *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
{
options: allow choice options without parameter If an m_option_type_choice option is declared with M_OPT_IMPLICIT_DEFAULT in its flags, it doesn't require a parameter. For example, if --opt is such an option, it can be invoked as "--opt=val", "-opt", or "--opt". The last two will set the option to the first choice the option declares. Note that "-opt val" (using the old option syntax) is not allowed in this case, as it would be ambiguous. Normal option parsing should be unaffected.
2012-01-06 21:26:21 +00:00
struct m_opt_choice_alternatives *alt = opt->priv;
options: remove M_OPT_IMPLICIT_DEFAULT This was to make an option without value use the option's default value (e.g. --term-osd is the same as --term-osd=auto). Make it simpler by handling this case as an empty choice. The flag was probably needed when option handling still did ambiguous argument parsing.
2012-09-03 20:44:44 +00:00
for ( ; alt->name; alt++)
if (!bstrcasecmp0(param, alt->name))
break;
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
if (!alt->name) {
options: remove M_OPT_IMPLICIT_DEFAULT This was to make an option without value use the option's default value (e.g. --term-osd is the same as --term-osd=auto). Make it simpler by handling this case as an empty choice. The flag was probably needed when option handling still did ambiguous argument parsing.
2012-09-03 20:44:44 +00:00
if (param.len == 0)
return M_OPT_MISSING_PARAM;
options: change --loop option, and extend choice option type The --loop option takes slightly different parameters now. --loop=0 used to mean looping forever. Now it means looping is disabled (this is more logical: 2 means playing 2 more times, 1 means playing 1 more time, and 0 should mean playing not again). Now --loop=inf must be used to enable looping forever. Extend choice types to allow an optional range of integers as values. If CONF_RANGE is added to the flags of a m_option_type_choice option, m_option.min/max specify a range of allowed integer values. This can be used to remove "special" values from make integer range options. These special values are unintuitive, and sometimes expose mplayer internals to the user. The (internal) choice values can be freely mixed with the specified integer value range. If there are overlaps, the choice values are preferred for conversion to/from strings. Also make sure the extension to choice options works with properties. Add the ability to step choice properties downwards, instead of just upwards.
2012-09-05 00:17:13 +00:00
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX)) {
long long val;
if (parse_longlong(opt, name, param, &val) == 1) {
if (dst)
*(int *)dst = val;
return 1;
}
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Invalid value for option %.*s: %.*s\n",
BSTR_P(name), BSTR_P(param));
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Valid values are:");
for (alt = opt->priv; alt->name; alt++)
mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s", alt->name);
m_option: print valid integer range for choices on parsing errors Only some choices have an additional integer range. For those which do, printing the choices only would be confusing. E.g. --cursor-autohide accepts the choices "always", "no", or an integer value. The help text printed on option parse errors should print the accepted integer range additional to "always" and "no".
2012-11-19 00:19:12 +00:00
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX))
mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %g-%g", opt->min, opt->max);
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
return M_OPT_INVALID;
}
if (dst)
*(int *)dst = alt->value;
options: remove M_OPT_IMPLICIT_DEFAULT This was to make an option without value use the option's default value (e.g. --term-osd is the same as --term-osd=auto). Make it simpler by handling this case as an empty choice. The flag was probably needed when option handling still did ambiguous argument parsing.
2012-09-03 20:44:44 +00:00
return 1;
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_choice(const m_option_t *opt, const void *val)
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
{
int v = *(int *)val;
struct m_opt_choice_alternatives *alt;
for (alt = opt->priv; alt->name; alt++)
if (alt->value == v)
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_strdup(NULL, alt->name);
options: change --loop option, and extend choice option type The --loop option takes slightly different parameters now. --loop=0 used to mean looping forever. Now it means looping is disabled (this is more logical: 2 means playing 2 more times, 1 means playing 1 more time, and 0 should mean playing not again). Now --loop=inf must be used to enable looping forever. Extend choice types to allow an optional range of integers as values. If CONF_RANGE is added to the flags of a m_option_type_choice option, m_option.min/max specify a range of allowed integer values. This can be used to remove "special" values from make integer range options. These special values are unintuitive, and sometimes expose mplayer internals to the user. The (internal) choice values can be freely mixed with the specified integer value range. If there are overlaps, the choice values are preferred for conversion to/from strings. Also make sure the extension to choice options works with properties. Add the ability to step choice properties downwards, instead of just upwards.
2012-09-05 00:17:13 +00:00
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX)) {
if (v >= opt->min && v <= opt->max)
return talloc_asprintf(NULL, "%d", v);
}
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
abort();
}
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
static void choice_get_min_max(const struct m_option *opt, int *min, int *max)
{
assert(opt->type == &m_option_type_choice);
*min = INT_MAX;
*max = INT_MIN;
for (struct m_opt_choice_alternatives *alt = opt->priv; alt->name; alt++) {
*min = FFMIN(*min, alt->value);
*max = FFMAX(*max, alt->value);
}
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX)) {
*min = FFMIN(*min, opt->min);
*max = FFMAX(*max, opt->max);
}
}
static void check_choice(int dir, int val, bool *found, int *best, int choice)
{
if ((dir == -1 && (!(*found) || choice > (*best)) && choice < val) ||
(dir == +1 && (!(*found) || choice < (*best)) && choice > val))
{
*found = true;
*best = choice;
}
}
static void add_choice(const m_option_t *opt, void *val, double add, bool wrap)
{
assert(opt->type == &m_option_type_choice);
int dir = add > 0 ? +1 : -1;
bool found = false;
int ival = *(int *)val;
int best = 0; // init. value unused
if (fabs(add) < 0.5)
return;
if ((opt->flags & M_OPT_MIN) && (opt->flags & M_OPT_MAX)) {
int newval = ival + add;
if (ival >= opt->min && ival <= opt->max &&
newval >= opt->min && newval <= opt->max)
{
found = true;
best = newval;
} else {
check_choice(dir, ival, &found, &best, opt->min);
check_choice(dir, ival, &found, &best, opt->max);
}
}
for (struct m_opt_choice_alternatives *alt = opt->priv; alt->name; alt++)
check_choice(dir, ival, &found, &best, alt->value);
if (!found) {
int min, max;
choice_get_min_max(opt, &min, &max);
best = (dir == -1) ^ wrap ? min : max;
}
*(int *)val = best;
}
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
const struct m_option_type m_option_type_choice = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "String", // same as arbitrary strings in option list for now
.size = sizeof(int),
options: add "choice" option type, use for -pts-association-mode Add a "choice" option type. Options of this type take a string as input and set an int option variable to the value corresponding to the string. The string->int mapping is option-specific and is given in the option definition. Strings not found in the mapping are rejected as invalid option values. Change the option -pts-association-mode to use this new option type and accept values "auto, decoder, sort" instead of "0, 1, 2". The change in accepted values shouldn't cause problems as this option is not appropriate to use in normal user config files.
2010-12-17 23:00:28 +00:00
.parse = parse_choice,
.print = print_choice,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_choice,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_choice,
options: move -chapter values to option struct -chapter can optionally take a range with a start and an end. Add a new option type which supports such values and use that instead of a custom per-option function. This commit also fixes a build configuration bug: before the availability of the -chapter option depended on DVD functionality being enabled in the binary, even though the option works with other sources too.
2010-04-24 17:09:31 +00:00
};
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
// Float
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(double *)(x))
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_double(const m_option_t *opt, void *val)
{
double v = VAL(val);
int r = 0;
if ((opt->flags & M_OPT_MAX) && (v > opt->max)) {
v = opt->max;
r = M_OPT_OUT_OF_RANGE;
}
if ((opt->flags & M_OPT_MIN) && (v < opt->min)) {
v = opt->min;
r = M_OPT_OUT_OF_RANGE;
}
VAL(val) = v;
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_double(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr rest;
double tmp_float = bstrtod(param, &rest);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
switch (rest.len ? rest.start[0] : 0) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
case ':':
case '/':
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
tmp_float /= bstrtod(bstr_cut(rest, 1), &rest);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
break;
case '.':
case ',':
/* we also handle floats specified with
* non-locale decimal point ::atmos
*/
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
rest = bstr_cut(rest, 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (tmp_float < 0)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
tmp_float -= 1.0 / pow(10, rest.len) * bstrtod(rest, &rest);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
else
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
tmp_float += 1.0 / pow(10, rest.len) * bstrtod(rest, &rest);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
break;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (rest.len) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be a floating point number or a "
"ratio (numerator[:/]denominator): %.*s\n",
BSTR_P(name), BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (opt->flags & M_OPT_MIN)
if (tmp_float < opt->min) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be >= %f: %.*s\n",
BSTR_P(name), opt->min, BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
if (opt->flags & M_OPT_MAX)
if (tmp_float > opt->max) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"The %.*s option must be <= %f: %.*s\n",
BSTR_P(name), opt->max, BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
if (dst)
VAL(dst) = tmp_float;
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_double(const m_option_t *opt, const void *val)
{
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_asprintf(NULL, "%f", VAL(val));
m_option_type_double git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11948 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 14:32:06 +00:00
}
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
static char *print_double_f2(const m_option_t *opt, const void *val)
{
return talloc_asprintf(NULL, "%.2f", VAL(val));
}
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
static void add_double(const m_option_t *opt, void *val, double add, bool wrap)
{
double v = VAL(val);
v = v + add;
double min = (opt->flags & M_OPT_MIN) ? opt->min : -INFINITY;
double max = (opt->flags & M_OPT_MAX) ? opt->max : +INFINITY;
if (v < min)
v = wrap ? max : min;
if (v > max)
v = wrap ? min : max;
VAL(val) = v;
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_double = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// double precision float or ratio (numerator[:/]denominator)
.name = "Double",
.size = sizeof(double),
.parse = parse_double,
.print = print_double,
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
.pretty_print = print_double_f2,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_double,
m_option_type_double git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11948 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 14:32:06 +00:00
};
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(float *)(x))
m_option_type_double git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11948 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 14:32:06 +00:00
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_float(const m_option_t *opt, void *val)
{
double tmp = VAL(val);
int r = clamp_double(opt, &tmp);
VAL(val) = tmp;
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_float(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
m_option_type_double git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11948 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 14:32:06 +00:00
double tmp;
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
int r = parse_double(opt, name, param, &tmp);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r == 1 && dst)
VAL(dst) = tmp;
100l (cvs commit + tired ...) git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11951 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 22:58:30 +00:00
return r;
m_option_type_double git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@11948 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-02-10 14:32:06 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_float(const m_option_t *opt, const void *val)
{
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
return talloc_asprintf(NULL, "%f", VAL(val));
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
static char *print_float_f2(const m_option_t *opt, const void *val)
{
return talloc_asprintf(NULL, "%.2f", VAL(val));
}
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
static void add_float(const m_option_t *opt, void *val, double add, bool wrap)
{
double tmp = VAL(val);
add_double(opt, &tmp, add, wrap);
VAL(val) = tmp;
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_float = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// floating point number or ratio (numerator[:/]denominator)
.name = "Float",
.size = sizeof(float),
.parse = parse_float,
.print = print_float,
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
.pretty_print = print_float_f2,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_float,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_float,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
///////////// String
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(char **)(x))
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
static char *unescape_string(void *talloc_ctx, bstr str)
{
char *res = talloc_strdup(talloc_ctx, "");
while (str.len) {
bstr rest;
bool esc = bstr_split_tok(str, "\\", &str, &rest);
res = talloc_strndup_append_buffer(res, str.start, str.len);
if (esc) {
if (!mp_parse_escape(&rest, &res)) {
talloc_free(res);
return NULL;
}
}
str = rest;
}
return res;
}
static char *escape_string(char *str0)
{
char *res = talloc_strdup(NULL, "");
bstr str = bstr0(str0);
while (str.len) {
bstr rest;
bool esc = bstr_split_tok(str, "\\", &str, &rest);
res = talloc_strndup_append_buffer(res, str.start, str.len);
if (esc)
res = talloc_strdup_append_buffer(res, "\\\\");
str = rest;
}
return res;
}
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
static int clamp_str(const m_option_t *opt, void *val)
{
char *v = VAL(val);
int len = v ? strlen(v) : 0;
if ((opt->flags & M_OPT_MIN) && (len < opt->min))
return M_OPT_OUT_OF_RANGE;
if ((opt->flags & M_OPT_MAX) && (len > opt->max))
return M_OPT_OUT_OF_RANGE;
return 0;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_str(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
int r = 1;
void *tmp = talloc_new(NULL);
if (param.start == NULL) {
r = M_OPT_MISSING_PARAM;
goto exit;
}
if (opt->flags & M_OPT_PARSE_ESCAPES) {
char *res = unescape_string(tmp, param);
if (!res) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Parameter has broken escapes: %.*s\n", BSTR_P(param));
r = M_OPT_INVALID;
goto exit;
}
param = bstr0(res);
}
options: fix specifying string options without parameter Specifying a string option with no parameter, as in "--dumpfile" with no '=', erroneously set the corresponding variable to NULL. Fix this to give an error about missing parameter instead. Suboption parsing explicitly treated empty option values as if the option had been specified with no value (no '='). Thus it was not possible to specify empty strings as values. I think this behavior was originally added only because of other limitations in the old implementation. Remove it, so that suboptions now behave the same as top-level ones in this regard. Document the NULL-distinguishing property of bstrdup0() that the code depends on, and also make bstrdup() behave consistently.
2012-06-29 02:14:26 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if ((opt->flags & M_OPT_MIN) && (param.len < opt->min)) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Parameter must be >= %d chars: %.*s\n",
(int) opt->min, BSTR_P(param));
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
r = M_OPT_OUT_OF_RANGE;
goto exit;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if ((opt->flags & M_OPT_MAX) && (param.len > opt->max)) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Parameter must be <= %d chars: %.*s\n",
(int) opt->max, BSTR_P(param));
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
r = M_OPT_OUT_OF_RANGE;
goto exit;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (dst) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(VAL(dst));
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
VAL(dst) = bstrdup0(NULL, param);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
exit:
talloc_free(tmp);
return r;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static char *print_str(const m_option_t *opt, const void *val)
{
options: parse C-style escapes for some options Being able to insert newline characters ("\n") is useful for --osd-status-msg, and possibly also for anything that prints to the terminal. Espcially --term-osd-esc looks relatively useless without being able to specify escapes. Maybe parsing escapes should happen during command line / config parsing instead (for all options).
2013-02-16 22:24:10 +00:00
bool need_escape = opt->flags & M_OPT_PARSE_ESCAPES;
char *s = val ? VAL(val) : NULL;
return s ? (need_escape ? escape_string(s) : talloc_strdup(NULL, s)) : NULL;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
static void copy_str(const m_option_t *opt, void *dst, const void *src)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
if (dst && src) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(VAL(dst));
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
VAL(dst) = talloc_strdup(NULL, VAL(src));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static void free_str(void *src)
{
if (src && VAL(src)) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(VAL(src));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(src) = NULL;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_string = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "String",
.size = sizeof(char *),
.flags = M_OPT_TYPE_DYNAMIC,
.parse = parse_str,
.print = print_str,
.copy = copy_str,
.free = free_str,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_str,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
//////////// String list
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(char ***)(x))
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
#define OP_NONE 0
#define OP_ADD 1
#define OP_PRE 2
#define OP_DEL 3
#define OP_CLR 4
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static void free_str_list(void *dst)
{
char **d;
int i;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!dst || !VAL(dst))
return;
d = VAL(dst);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (i = 0; d[i] != NULL; i++)
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(d[i]);
talloc_free(d);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = NULL;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
static int str_list_add(char **add, int n, void *dst, int pre)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
if (!dst)
return M_OPT_PARSER_ERR;
m_option: minor simplification Relict of mplayer's C89 compatibility?
2012-10-31 23:50:08 +00:00
char **lst = VAL(dst);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
m_option: minor simplification Relict of mplayer's C89 compatibility?
2012-10-31 23:50:08 +00:00
int ln;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (ln = 0; lst && lst[ln]; ln++)
/**/;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
lst = talloc_realloc(NULL, lst, char *, n + ln + 1);
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (pre) {
memmove(&lst[n], lst, ln * sizeof(char *));
memcpy(lst, add, n * sizeof(char *));
} else
memcpy(&lst[ln], add, n * sizeof(char *));
// (re-)add NULL-termination
lst[ln + n] = NULL;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(add);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = lst;
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static int str_list_del(char **del, int n, void *dst)
{
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
char **lst, *ep;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
int i, ln, s;
long idx;
if (!dst)
return M_OPT_PARSER_ERR;
lst = VAL(dst);
for (ln = 0; lst && lst[ln]; ln++)
/**/;
s = ln;
for (i = 0; del[i] != NULL; i++) {
idx = strtol(del[i], &ep, 0);
if (*ep) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid index: %s\n", del[i]);
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(del[i]);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
continue;
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(del[i]);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (idx < 0 || idx >= ln) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Index %ld is out of range.\n", idx);
continue;
} else if (!lst[idx])
continue;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(lst[idx]);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
lst[idx] = NULL;
s--;
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(del);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (s == 0) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(lst);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = NULL;
return 1;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
// Don't bother shrinking the list allocation
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (i = 0, n = 0; i < ln; i++) {
if (!lst[i])
continue;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
lst[n] = lst[i];
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n++;
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
lst[s] = NULL;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static struct bstr get_nextsep(struct bstr *ptr, char sep, bool modify)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr str = *ptr;
struct bstr orig = str;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (;;) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int idx = bstrchr(str, sep);
if (idx > 0 && str.start[idx - 1] == '\\') {
if (modify) {
memmove(str.start + idx - 1, str.start + idx, str.len - idx);
str.len--;
str = bstr_cut(str, idx);
} else
str = bstr_cut(str, idx + 1);
} else {
str = bstr_cut(str, idx < 0 ? str.len : idx);
str_list separator backslash-escaping git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22151 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-05 18:03:12 +00:00
break;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
}
str_list separator backslash-escaping git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22151 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-05 18:03:12 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
*ptr = str;
return bstr_splice(orig, 0, str.start - orig.start);
str_list separator backslash-escaping git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22151 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-05 18:03:12 +00:00
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_str_list(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
char **res;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
int op = OP_NONE;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int len = strlen(opt->name);
if (opt->name[len - 1] == '*' && (name.len > len - 1)) {
struct bstr suffix = bstr_cut(name, len - 1);
if (bstrcasecmp0(suffix, "-add") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_ADD;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-pre") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_PRE;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-del") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_DEL;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-clr") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_CLR;
else
return M_OPT_UNKNOWN;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// Clear the list ??
if (op == OP_CLR) {
if (dst)
free_str_list(dst);
return 0;
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// All other ops need a param
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// custom type for "profile" calls this but uses ->priv for something else
char separator = opt->type == &m_option_type_string_list && opt->priv ?
*(char *)opt->priv : OPTION_LIST_SEPARATOR;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int n = 0;
struct bstr str = param;
while (str.len) {
get_nextsep(&str, separator, 0);
str = bstr_cut(str, 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n++;
}
if (n == 0)
return M_OPT_INVALID;
if (((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
((opt->flags & M_OPT_MAX) && (n > opt->max)))
return M_OPT_OUT_OF_RANGE;
if (!dst)
return 1;
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
res = talloc_array(NULL, char *, n + 2);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
str = bstrdup(NULL, param);
char *ptr = str.start;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n = 0;
options: fix failure to parse trailing ',' in string list A trailing separator in string list options was ignored after recent commit e873d703e9 ("options: change option parsing to use bstr"), which broke uses such as "-vo vdpau,". Fix.
2011-07-31 17:25:22 +00:00
while (1) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr el = get_nextsep(&str, separator, 1);
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
res[n] = bstrdup0(NULL, el);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n++;
options: fix failure to parse trailing ',' in string list A trailing separator in string list options was ignored after recent commit e873d703e9 ("options: change option parsing to use bstr"), which broke uses such as "-vo vdpau,". Fix.
2011-07-31 17:25:22 +00:00
if (!str.len)
break;
str = bstr_cut(str, 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
res[n] = NULL;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
talloc_free(ptr);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
switch (op) {
case OP_ADD:
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
return str_list_add(res, n, dst, 0);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
case OP_PRE:
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
return str_list_add(res, n, dst, 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
case OP_DEL:
return str_list_del(res, n, dst);
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (VAL(dst))
free_str_list(dst);
VAL(dst) = res;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
static void copy_str_list(const m_option_t *opt, void *dst, const void *src)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
int n;
char **d, **s;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!(dst && src))
return;
s = VAL(src);
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (VAL(dst))
free_str_list(dst);
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!s) {
VAL(dst) = NULL;
return;
}
Fix the Gui with NEW_CONFIG git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8169 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 12:39:05 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (n = 0; s[n] != NULL; n++)
/* NOTHING */;
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
d = talloc_array(NULL, char *, n + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (; n >= 0; n--)
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
d[n] = talloc_strdup(NULL, s[n]);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = d;
}
static char *print_str_list(const m_option_t *opt, const void *src)
{
char **lst = NULL;
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
char *ret = NULL;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!(src && VAL(src)))
return NULL;
lst = VAL(src);
commands: change property mechanism to use talloc strings
2011-07-03 17:04:21 +00:00
for (int i = 0; lst[i]; i++) {
if (ret)
ret = talloc_strdup_append_buffer(ret, ",");
ret = talloc_strdup_append_buffer(ret, lst[i]);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
return ret;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_string_list = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
/* A list of strings separated by ','.
* Option with a name ending in '*' permits using the following suffixes:
* -add: Add the given parameters at the end of the list.
* -pre: Add the given parameters at the beginning of the list.
* -del: Remove the entry at the given indices.
* -clr: Clear the list.
* e.g: -vf-add flip,mirror -vf-del 2,5
*/
.name = "String list",
.size = sizeof(char **),
.flags = M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
.parse = parse_str_list,
.print = print_str_list,
.copy = copy_str_list,
.free = free_str_list,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
/////////////////// Print
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_print(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
if (opt->type == CONF_TYPE_PRINT) {
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", mp_gtext(opt->p));
} else {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
char *name0 = bstrdup0(NULL, name);
char *param0 = bstrdup0(NULL, param);
int r = ((m_opt_func_full_t) opt->p)(opt, name0, param0);
talloc_free(name0);
talloc_free(param0);
return r;
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (opt->priv == NULL)
return M_OPT_EXIT;
return 0;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_print = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Print",
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
.flags = M_OPT_TYPE_OPTIONAL_PARAM,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.parse = parse_print,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
const m_option_type_t m_option_type_print_func_param = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Print",
.flags = M_OPT_TYPE_ALLOW_WILDCARD,
.parse = parse_print,
New option type to print help text with a function. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@17471 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-01-24 11:14:13 +00:00
};
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
const m_option_type_t m_option_type_print_func = {
.name = "Print",
options: unify single dash and double dash options There were two option syntax variations: "old": -opt value "new": --opt=value "-opt=value" was invalid, and "--opt value" meant "--opt=" followed by a separate option "value" (i.e. interpreted as filename). There isn't really any reason to do this. The "old" syntax used to be ambiguous (you had to call the option parser to know whether the following argument is an option value or a new option), but that has been removed. Further, using "=" in the option string is always unambiguous. Since the distinction between the two option variants is confusing, just remove the difference and allow "--opt value" and "-opt=value". To make this easier, do some other cleanups as well (e.g. avoid having to do a manual lookup of the option just to check for M_OPT_PRE_PARSE, which somehow ended up with finally getting rid of the m_config.mode member). Error reporting is still a mess, and we opt for reporting too many rather than too few errors to the user. There shouldn't be many user-visible changes. The --framedrop and --term-osd options now always require parameters. The --mute option is intentionally made ambiguous: it works like a flag option, but a value can be passed to it explicitly ("--mute=auto"). If the interpretation of the option is ambiguous (like "--mute auto"), the second string is interpreted as separate option or filename. (Normal flag options are actually ambiguous in this way too.)
2012-09-21 07:22:25 +00:00
.flags = M_OPT_TYPE_ALLOW_WILDCARD | M_OPT_TYPE_OPTIONAL_PARAM,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
.parse = parse_print,
};
pphelp git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8737 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-01-03 12:40:10 +00:00
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
/////////////////////// Subconfig
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(char ***)(x))
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_subconf(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: support parsing values into substructs Add an alternate mode for option parser objects (struct m_config) which is not inherently tied to any particular instance of an option value struct. Instead, this type or parsers can be used to initialize defaults in or parse values into a struct given as a parameter. They do not have the save slot functionality used for main player configuration. The new functionality will be used to replace the separate subopt_helper.c parsing code that is currently used to parse per-object suboptions in VOs etc. Previously, option default values were handled by initializing them in external code before creating a parser. This initialization was done with constants even for dynamically-allocated types like strings. Because trying to free a pointer to a constant would cause a crash when trying to replace the default with another value, parser initialization code then replaced all the original defaults with dynamically-allocated copies. This replace-with-copy behavior is no longer supported for new-style options; instead the option definition itself may contain a default value (new OPTDEF macros), and the new function m_config_initialize() is used to set all options to their default values. Convert the existing initialized dynamically allocated options in main config (the string options --dumpfile, --term-osd-esc, --input=conf) to use this. Other non-dynamic ones could be later converted to use this style of initialization too. There's currently no public call to free all dynamically allocated options in a given option struct because I intend to use talloc functionality for that (make them children of the struct and free with it).
2012-05-17 00:31:11 +00:00
int nr = 0;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
char **lst = NULL;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr p = param;
while (p.len) {
int optlen = bstrcspn(p, ":=");
struct bstr subopt = bstr_splice(p, 0, optlen);
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
struct bstr subparam = bstr0(NULL);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
p = bstr_cut(p, optlen);
if (bstr_startswith0(p, "=")) {
p = bstr_cut(p, 1);
if (bstr_startswith0(p, "\"")) {
p = bstr_cut(p, 1);
optlen = bstrcspn(p, "\"");
subparam = bstr_splice(p, 0, optlen);
p = bstr_cut(p, optlen);
if (!bstr_startswith0(p, "\"")) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Terminating '\"' missing for '%.*s'\n",
BSTR_P(subopt));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
p = bstr_cut(p, 1);
} else if (bstr_startswith0(p, "%")) {
p = bstr_cut(p, 1);
optlen = bstrtoll(p, &p, 0);
if (!bstr_startswith0(p, "%") || (optlen > p.len - 1)) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Invalid length %d for '%.*s'\n",
optlen, BSTR_P(subopt));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
subparam = bstr_splice(p, 1, optlen + 1);
p = bstr_cut(p, optlen + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
} else {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
optlen = bstrcspn(p, ":");
subparam = bstr_splice(p, 0, optlen);
p = bstr_cut(p, optlen);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (bstr_startswith0(p, ":"))
p = bstr_cut(p, 1);
else if (p.len > 0) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Incorrect termination for '%.*s'\n", BSTR_P(subopt));
Add support for suboption escaping via both "" and %n%str syntax git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@16742 b3059339-0415-0410-9bf9-f77b7e298cf2
2005-10-12 16:35:37 +00:00
return M_OPT_INVALID;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (dst) {
lst = talloc_realloc(NULL, lst, char *, 2 * (nr + 2));
options: support parsing values into substructs Add an alternate mode for option parser objects (struct m_config) which is not inherently tied to any particular instance of an option value struct. Instead, this type or parsers can be used to initialize defaults in or parse values into a struct given as a parameter. They do not have the save slot functionality used for main player configuration. The new functionality will be used to replace the separate subopt_helper.c parsing code that is currently used to parse per-object suboptions in VOs etc. Previously, option default values were handled by initializing them in external code before creating a parser. This initialization was done with constants even for dynamically-allocated types like strings. Because trying to free a pointer to a constant would cause a crash when trying to replace the default with another value, parser initialization code then replaced all the original defaults with dynamically-allocated copies. This replace-with-copy behavior is no longer supported for new-style options; instead the option definition itself may contain a default value (new OPTDEF macros), and the new function m_config_initialize() is used to set all options to their default values. Convert the existing initialized dynamically allocated options in main config (the string options --dumpfile, --term-osd-esc, --input=conf) to use this. Other non-dynamic ones could be later converted to use this style of initialization too. There's currently no public call to free all dynamically allocated options in a given option struct because I intend to use talloc functionality for that (make them children of the struct and free with it).
2012-05-17 00:31:11 +00:00
lst[2 * nr] = bstrdup0(lst, subopt);
options: fix specifying string options without parameter Specifying a string option with no parameter, as in "--dumpfile" with no '=', erroneously set the corresponding variable to NULL. Fix this to give an error about missing parameter instead. Suboption parsing explicitly treated empty option values as if the option had been specified with no value (no '='). Thus it was not possible to specify empty strings as values. I think this behavior was originally added only because of other limitations in the old implementation. Remove it, so that suboptions now behave the same as top-level ones in this regard. Document the NULL-distinguishing property of bstrdup0() that the code depends on, and also make bstrdup() behave consistently.
2012-06-29 02:14:26 +00:00
lst[2 * nr + 1] = bstrdup0(lst, subparam);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
memset(&lst[2 * (nr + 1)], 0, 2 * sizeof(char *));
nr++;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
}
if (dst)
VAL(dst) = lst;
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_subconfig = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// The syntax is -option opt1=foo:flag:opt2=blah
.name = "Subconfig",
.flags = M_OPT_TYPE_HAS_CHILD,
.parse = parse_subconf,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
m_config: support auto-allocated sub-structs Given your option struct has a field that is a pointer to another struct, this commit allows you to declare options that write into that other struct. The code in m_config will dereference the pointer field on its own if such an option is accessed. If the field is NULL on initialization of the containing m_config, the struct is automatically allocated. OPT_SUBSTRUCT() can be used to declare such a field. struct m_sub_options is used to describe the pointed-to struct, and includes size and defaults if the struct has to be allocated by m_config.
2012-08-06 15:45:17 +00:00
const m_option_type_t m_option_type_subconfig_struct = {
.name = "Subconfig",
.flags = M_OPT_TYPE_HAS_CHILD | M_OPT_TYPE_USE_SUBSTRUCT,
.parse = parse_subconf,
};
m_option: add color option type This accepts HTML-style hex colors in the form #RRGGBB. It's also possible to provide an alpha component with #AARRGGBB. Each 2-digit group is a hex number, which gives the color value from 0-255 (e.g. There is existing code in subassconvert.c, which parses HTML-style color values in SRT subs. This is not used: it's probably better if option parsing is completely separate from code specific to certain subtitle formats, even if a little code is duplicated.
2012-11-17 18:58:57 +00:00
static int parse_color(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
{
if (param.len == 0)
return M_OPT_MISSING_PARAM;
bstr val = param;
struct m_color color = {0};
if (bstr_eatstart0(&val, "#")) {
// #[AA]RRGGBB
if (val.len != 6 && val.len != 8)
goto error;
bool has_alpha = val.len == 8;
uint32_t c = bstrtoll(val, &val, 16);
if (val.len)
goto error;
color = (struct m_color) {
(c >> 16) & 0xFF,
(c >> 8) & 0xFF,
c & 0xFF,
has_alpha ? (c >> 24) & 0xFF : 0xFF,
};
} else {
goto error;
}
if (dst)
*((struct m_color *)dst) = color;
return 1;
error:
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: invalid color: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Valid colors must be in the form #RRRGGBB or #AARRGGBB (in hex)\n");
return M_OPT_INVALID;
}
const m_option_type_t m_option_type_color = {
.name = "Color",
.size = sizeof(struct m_color),
.parse = parse_color,
};
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
// Parse a >=0 number starting at s. Set s to the string following the number.
// If the number ends with '%', eat that and set *out_per to true, but only
// if the number is between 0-100; if not, don't eat anything, even the number.
static bool eat_num_per(bstr *s, int *out_num, bool *out_per)
{
bstr rest;
long long v = bstrtoll(*s, &rest, 10);
if (s->len == rest.len || v < INT_MIN || v > INT_MAX)
return false;
*out_num = v;
*out_per = false;
*s = rest;
if (bstr_eatstart0(&rest, "%") && v >= 0 && v <= 100) {
*out_per = true;
*s = rest;
}
return true;
}
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
static bool parse_geometry_str(struct m_geometry *gm, bstr s)
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
{
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
*gm = (struct m_geometry) { .x = INT_MIN, .y = INT_MIN };
if (s.len == 0)
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
return true;
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
// Approximate grammar:
// [W[xH]][{+-}X{+-}Y] | [X:Y]
// (meaning: [optional] {one character of} one|alternative)
// Every number can be followed by '%'
int num;
bool per;
#define READ_NUM(F, F_PER) do { \
if (!eat_num_per(&s, &num, &per)) \
goto error; \
gm->F = num; \
gm->F_PER = per; \
} while(0)
#define READ_SIGN(F) do { \
if (bstr_eatstart0(&s, "+")) { \
gm->F = false; \
} else if (bstr_eatstart0(&s, "-")) {\
gm->F = true; \
} else goto error; \
} while(0)
if (bstrchr(s, ':') < 0) {
gm->wh_valid = true;
if (!bstr_startswith0(s, "+") && !bstr_startswith0(s, "-")) {
READ_NUM(w, w_per);
if (bstr_eatstart0(&s, "x"))
READ_NUM(h, h_per);
}
if (s.len > 0) {
gm->xy_valid = true;
READ_SIGN(x_sign);
READ_NUM(x, x_per);
READ_SIGN(y_sign);
READ_NUM(y, y_per);
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
}
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
} else {
gm->xy_valid = true;
READ_NUM(x, x_per);
if (!bstr_eatstart0(&s, ":"))
goto error;
READ_NUM(y, y_per);
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
}
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
return s.len == 0;
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
error:
return false;
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
}
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
#undef READ_NUM
#undef READ_SIGN
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
// xpos,ypos: position of the left upper corner
// widw,widh: width and height of the window
// scrw,scrh: width and height of the current screen
// The input parameters should be set to a centered window (default fallbacks).
void m_geometry_apply(int *xpos, int *ypos, int *widw, int *widh,
int scrw, int scrh, struct m_geometry *gm)
{
if (gm->wh_valid) {
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
int prew = *widw, preh = *widh;
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
if (gm->w > 0)
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
*widw = gm->w_per ? scrw * (gm->w / 100.0) : gm->w;
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
if (gm->h > 0)
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
*widh = gm->h_per ? scrh * (gm->h / 100.0) : gm->h;
// keep aspect if the other value is not set
double asp = (double)prew / preh;
if (gm->w > 0 && !(gm->h > 0)) {
*widh = *widw / asp;
} else if (!(gm->w > 0) && gm->h > 0) {
*widw = *widh * asp;
}
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
}
if (gm->xy_valid) {
if (gm->x != INT_MIN) {
*xpos = gm->x;
if (gm->x_per)
*xpos = (scrw - *widw) * (*xpos / 100.0);
if (gm->x_sign)
*xpos = scrw - *widw - *xpos;
}
if (gm->y != INT_MIN) {
*ypos = gm->y;
if (gm->y_per)
*ypos = (scrh - *widh) * (*ypos / 100.0);
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
if (gm->y_sign)
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
*ypos = scrh - *widh - *ypos;
}
}
}
static int parse_geometry(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
{
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
struct m_geometry gm;
if (!parse_geometry_str(&gm, param))
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
goto error;
if (dst)
*((struct m_geometry *)dst) = gm;
return 1;
error:
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: invalid geometry: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: allow using % for width and height in --geometry Now all numbers in the --geometry specification can take percentages. Rewrite the parsing of --geometry, because adjusting the sscanf() mess would require adding all the combinations of using and not using %. As a side effect, using % and pixel values can be freely mixed. Keep the aspect if only one of width or height is set. This is more useful in general. Note: there is one semantic change: --geometry=num used to mean setting the window X position, but now it means setting the window width. Apparently this was a mplayer-specific feature (not part of standard X geometry specifications), and it doesn't look like an overly useful feature, so we are fine with breaking it. In general, the new parsing should still adhere to standard X geometry specification (as used by XParseGeometry()).
2013-01-23 09:56:27 +00:00
"Valid format: [W[%%][xH[%%]]][{+-}X[%%]{+-}Y[%%]] | [X[%%]:Y[%%]]\n");
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
return M_OPT_INVALID;
}
const m_option_type_t m_option_type_geometry = {
.name = "Window geometry",
.size = sizeof(struct m_geometry),
.parse = parse_geometry,
};
video: add --autofit and --autofit-larger options --autofit=WxH sets the window size to a maximum width and/or height, without changing the window's aspect ratio. --autofit-larger=WxH does the same, but only if the video size is actually larger than the window size that would result when using the --autofit=WxH option with the same arguments.
2013-01-23 09:56:36 +00:00
static int parse_size_box(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
{
struct m_geometry gm;
if (!parse_geometry_str(&gm, param))
goto error;
if (gm.xy_valid)
goto error;
if (dst)
*((struct m_geometry *)dst) = gm;
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
video: add --autofit and --autofit-larger options --autofit=WxH sets the window size to a maximum width and/or height, without changing the window's aspect ratio. --autofit-larger=WxH does the same, but only if the video size is actually larger than the window size that would result when using the --autofit=WxH option with the same arguments.
2013-01-23 09:56:36 +00:00
return 1;
error:
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: invalid size: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Valid format: W[%%][xH[%%]] or empty string\n");
return M_OPT_INVALID;
}
const m_option_type_t m_option_type_size_box = {
.name = "Window size",
.size = sizeof(struct m_geometry),
.parse = parse_size_box,
};
options: move -geometry parsing to m_option.c This also means the option is verified on program start, not when the VO is created. The actual code becomes a bit more complex, because the screen width/height is not available at program start. The actual parsing code is still the same, with its unusual sscanf() usage.
2013-01-23 09:56:11 +00:00
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "video/img_format.h"
Improve the imgfmt option type git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9601 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 20:49:39 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_imgfmt(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(param, "help")) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
options, codecs.conf, img_format: unify imgfmt name handling Remove the duplication of image format name lists from codec-cfg.c and img_format.c. Remove the list of "long" image format names from img_format.c. One user visible change is that now mplayer won't print "long" format names anymore: e.g. instead of "Planar 420P 10-bit little-endian", the name "420p10le" is used. This is consistent with the names used by the option parser, and also less noisy. Partially based on mplayer2 commit f98e47574de15, with some differences.
2012-08-28 21:58:48 +00:00
for (int i = 0; mp_imgfmt_list[i].name; i++)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s", mp_imgfmt_list[i].name);
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
return M_OPT_EXIT - 1;
}
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
options, codecs.conf, img_format: unify imgfmt name handling Remove the duplication of image format name lists from codec-cfg.c and img_format.c. Remove the list of "long" image format names from img_format.c. One user visible change is that now mplayer won't print "long" format names anymore: e.g. instead of "Planar 420P 10-bit little-endian", the name "420p10le" is used. This is consistent with the names used by the option parser, and also less noisy. Partially based on mplayer2 commit f98e47574de15, with some differences.
2012-08-28 21:58:48 +00:00
unsigned int fmt = mp_imgfmt_from_name(param, false);
if (!fmt) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: unknown format name: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
return M_OPT_INVALID;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
if (dst)
*((uint32_t *)dst) = fmt;
return 1;
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_imgfmt = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// Please report any missing colorspaces
.name = "Image format",
.size = sizeof(uint32_t),
.parse = parse_imgfmt,
.copy = copy_opt,
New config system + cleanup of header inter dependency git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@8165 b3059339-0415-0410-9bf9-f77b7e298cf2
2002-11-12 01:56:42 +00:00
};
video: decouple internal pixel formats from FourCCs mplayer's video chain traditionally used FourCCs for pixel formats. For example, it used IMGFMT_YV12 for 4:2:0 YUV, which was defined to the string 'YV12' interpreted as unsigned int. Additionally, it used to encode information into the numeric values of some formats. The RGB formats had their bit depth and endian encoded into the least significant byte. Extended planar formats (420P10 etc.) had chroma shift, endian, and component bit depth encoded. (This has been removed in recent commits.) Replace the FourCC mess with a simple enum. Remove all the redundant formats like YV12/I420/IYUV. Replace some image format names by something more intuitive, most importantly IMGFMT_YV12 -> IMGFMT_420P. Add img_fourcc.h, which contains the old IDs for code that actually uses FourCCs. Change the way demuxers, that output raw video, identify the video format: they set either MP_FOURCC_RAWVIDEO or MP_FOURCC_IMGFMT to request the rawvideo decoder, and sh_video->imgfmt specifies the pixel format. Like the previous hack, this is supposed to avoid the need for a complete codecs.cfg entry per format, or other lookup tables. (Note that the RGB raw video FourCCs mostly rely on ffmpeg's mappings for NUT raw video, but this is still considered better than adding a raw video decoder - even if trivial, it would be full of annoying lookup tables.) The TV code has not been tested. Some corrective changes regarding endian and other image format flags creep in.
2012-12-23 19:03:30 +00:00
static int parse_fourcc(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
{
if (param.len == 0)
return M_OPT_MISSING_PARAM;
unsigned int value;
if (param.len == 4) {
uint8_t *s = param.start;
value = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
} else {
bstr rest;
value = bstrtoll(param, &rest, 16);
if (rest.len != 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: invalid FourCC: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
return M_OPT_INVALID;
}
}
if (dst)
*((unsigned int *)dst) = value;
return 1;
}
const m_option_type_t m_option_type_fourcc = {
.name = "FourCC",
.size = sizeof(unsigned int),
.parse = parse_fourcc,
.copy = copy_opt,
};
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "audio/format.h"
CONF_TYPE_AFMT similar to CONF_TYPE_IMGFMT git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@14247 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-12-27 17:32:54 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_afmt(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(param, "help")) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
options, libaf: unify audio format name handling Remove the duplicated list of audio format names from m_option.c. Remove "long" audio format names, and let af_fmt2str() print the usual short format names. The long names were overly verbose, and were actually rarely user visible. The only difference between af_fmt2str() and af_fmt2str_short() is that the former prints unknown format values as hexadecimal string as fallback.
2012-08-28 22:34:21 +00:00
for (int i = 0; af_fmtstr_table[i].name; i++)
mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s", af_fmtstr_table[i].name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
return M_OPT_EXIT - 1;
}
options, libaf: unify audio format name handling Remove the duplicated list of audio format names from m_option.c. Remove "long" audio format names, and let af_fmt2str() print the usual short format names. The long names were overly verbose, and were actually rarely user visible. The only difference between af_fmt2str() and af_fmt2str_short() is that the former prints unknown format values as hexadecimal string as fallback.
2012-08-28 22:34:21 +00:00
int fmt = af_str2fmt_short(param);
if (fmt == -1) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: unknown format name: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
return M_OPT_INVALID;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
CONF_TYPE_AFMT similar to CONF_TYPE_IMGFMT git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@14247 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-12-27 17:32:54 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (dst)
*((uint32_t *)dst) = fmt;
CONF_TYPE_AFMT similar to CONF_TYPE_IMGFMT git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@14247 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-12-27 17:32:54 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
CONF_TYPE_AFMT similar to CONF_TYPE_IMGFMT git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@14247 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-12-27 17:32:54 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_afmt = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
// Please report any missing formats
.name = "Audio format",
.size = sizeof(uint32_t),
.parse = parse_afmt,
.copy = copy_opt,
CONF_TYPE_AFMT similar to CONF_TYPE_IMGFMT git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@14247 b3059339-0415-0410-9bf9-f77b7e298cf2
2004-12-27 17:32:54 +00:00
};
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_timestring(struct bstr str, double *time, char endchar)
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
{
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
int a, b, len;
double d;
*time = 0; /* ensure initialization for error cases */
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (bstr_sscanf(str, "%d:%d:%lf%n", &a, &b, &d, &len) >= 3)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
*time = 3600 * a + 60 * b + d;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstr_sscanf(str, "%d:%lf%n", &a, &d, &len) >= 2)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
*time = 60 * a + d;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstr_sscanf(str, "%lf%n", &d, &len) >= 1)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
*time = d;
else
return 0; /* unsupported time format */
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (len < str.len && str.start[len] != endchar)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 0; /* invalid extra characters at the end */
return len;
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_time(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
{
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
double time;
remove C99-ism (mixed declaration and code), 10l to Uoti Urpala for breaking GCC-2.95 support yet again even though any post-2.95 GCC version print a clear warning about it Patch by Carl Eugen Hoyos % cehoyos A ag P or P at % git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22374 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-28 09:18:42 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!parse_timestring(param, &time, 0)) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: invalid time: '%.*s'\n",
BSTR_P(name), BSTR_P(param));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (dst)
*(double *)dst = time;
return 1;
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
}
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
static char *pretty_print_time(const m_option_t *opt, const void *val)
{
return mp_format_time(*(double *)val, false);
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_time = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Time",
.size = sizeof(double),
.parse = parse_time,
.print = print_double,
commands: generally handle property formatting with m_option Use the m_option code by default to format property values, instead of having separate code in m_property. To facilitate that, add a pretty_print callback to option types. These format values in a more human readable and user friendly way, as opposed to the print callback, which produces parseable values. This also changes the strings used with flags. Instead of "enabled" and "disabled", flags are formatted as "yes" and "no". (We could use the pretty_print callback to deal with this, but we don't for consistency.)
2012-09-18 13:31:46 +00:00
.pretty_print = pretty_print_time,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
commands: handle property stepping in a generic way Instead of forcing each property implementation implement its own logic for M_PROPERTY_STEP_UP/M_PROPERTY_STEP_DOWN, handle it in the generic property code. Rename the M_PROPERTY_STEP_UP command to M_PROPERTY_SWITCH (the other property command, M_PROPERTY_STEP_DOWN, isn't needed anymore: stepping downwards is done by passing a negative argument). Always use double as argument type; it makes the code easier, and covers all property types. Move the code which does the actual type-specific value stepping to m_option.c (the idea is that m_option handles types). Some properties still have custom handlers implemented with M_PROPERTY_SWITCH. They can't be mapped to the generic mechanism, because their value range is dynamic or entirely unknown. For some properties, the default step stride is changed to 1. This is no issue, because the default bindings in input.conf all use an explicit stride in the affected cases.
2012-09-18 12:00:08 +00:00
.add = add_double,
commands: handle property clamping in m_option Instead of clamping property values to the valid range in each property implementation, handle it in the property layer. The functionality to handle clamping for each type is in m_option.c. It's not really clear whether this is really needed. Normally, the raw values for M_PROPERTY_SET come only from m_option_type.parse (setting properties as string) or from m_option_parse.add (using the "switch" input command). However, since this was already done before, and since we _really_ want to be sure only to write valid values, add this code anyway. The newly added warnings/error messages should never actually be printed during normal operation and are for debugging (if they happen, we definitely want to see them).
2012-09-18 15:05:11 +00:00
.clamp = clamp_double,
Move parsing of the -ss option to the option code. Also fixes a memory leak of the parameter string. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22330 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-02-24 07:11:57 +00:00
};
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
// Relative time
after a long time, finally i could add -endpos option to mplayer executable. as oded told me on 1006 02 24, i applied it, blame me if some problem occurs, i hope not, since i tried it for a while.... git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19979 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-25 16:47:56 +00:00
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
static int parse_rel_time(const m_option_t *opt, struct bstr name,
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
struct m_rel_time t = {0};
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
after a long time, finally i could add -endpos option to mplayer executable. as oded told me on 1006 02 24, i applied it, blame me if some problem occurs, i hope not, since i tried it for a while.... git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19979 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-25 16:47:56 +00:00
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
// Percent pos
m_option: fix braindead --start, --length, --end option parsing bugs The option type m_option_type_rel_time was completely broken. It interpreted everything starting with a number as percent position. This is because sscanf() semantics are idiotic (trailing string doesn't need to be matched), and due to my own idiocy this was overlooked when testing. Fix by considering sscanf() evil and not using it. (bstr_sscanf() is a straight wrapper around sscanf()). Even if the percent code was fixed, there was another bug: it always interpreted times as negative (starting from end for --start). Fix the basic logic.
2012-11-17 23:19:43 +00:00
if (bstr_endswith0(param, "%")) {
double percent = bstrtod(bstr_splice(param, 0, -1), &param);
if (param.len == 0 && percent >= 0 && percent <= 100) {
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
t.type = REL_TIME_PERCENT;
t.pos = percent;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
goto out;
}
after a long time, finally i could add -endpos option to mplayer executable. as oded told me on 1006 02 24, i applied it, blame me if some problem occurs, i hope not, since i tried it for a while.... git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19979 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-25 16:47:56 +00:00
}
options: support chapters for --start and --end The --start and --end switch now accept a chapter number. The chapter number is prefixed with '#', e.g. "--start=#2" jumps to chapter 2. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise. (This was supposed to be added in 51503a, but apparently the fixup commit adding it was lost in a rebase. This might also be the reason for the mess-up fixed in 394285.)
2012-11-18 17:02:14 +00:00
// Chapter pos
if (bstr_startswith0(param, "#")) {
int chapter = bstrtoll(bstr_cut(param, 1), &param, 10);
if (param.len == 0 && chapter >= 1) {
t.type = REL_TIME_CHAPTER;
t.pos = chapter - 1;
goto out;
}
}
m_option: fix braindead --start, --length, --end option parsing bugs The option type m_option_type_rel_time was completely broken. It interpreted everything starting with a number as percent position. This is because sscanf() semantics are idiotic (trailing string doesn't need to be matched), and due to my own idiocy this was overlooked when testing. Fix by considering sscanf() evil and not using it. (bstr_sscanf() is a straight wrapper around sscanf()). Even if the percent code was fixed, there was another bug: it always interpreted times as negative (starting from end for --start). Fix the basic logic.
2012-11-17 23:19:43 +00:00
bool sign = bstr_eatstart0(&param, "-");
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
double time;
if (parse_timestring(param, &time, 0)) {
t.type = sign ? REL_TIME_NEGATIVE : REL_TIME_ABSOLUTE;
t.pos = time;
goto out;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: support chapters for --start and --end The --start and --end switch now accept a chapter number. The chapter number is prefixed with '#', e.g. "--start=#2" jumps to chapter 2. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise. (This was supposed to be added in 51503a, but apparently the fixup commit adding it was lost in a rebase. This might also be the reason for the mess-up fixed in 394285.)
2012-11-18 17:02:14 +00:00
"Option %.*s: invalid time or position: '%.*s'\n",
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
BSTR_P(name), BSTR_P(param));
return M_OPT_INVALID;
Fix broken parse_time_size, it would cause MPlayer to parse its parameter twice, e.g. "mplayer file -endpos 01" would try to play the file "01", too git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@20009 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-29 23:23:41 +00:00
out:
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (dst)
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
*(struct m_rel_time *)dst = t;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
after a long time, finally i could add -endpos option to mplayer executable. as oded told me on 1006 02 24, i applied it, blame me if some problem occurs, i hope not, since i tried it for a while.... git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19979 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-25 16:47:56 +00:00
}
options: rename -ss and -endpos, allow relative times Rename the -ss option to -start, and -endpos to -length. Add a -end option. The -end option always specifies an absolute end time, as opposed to -endpos/-length. All these options (--start, --end, --length) now accept relative times. Percent positions (e.g. "--start=30%") are interpreted as fractions of the file duration. Negative times (e.g. "--start=-1:00) are interpreted relative to the end of the file. Chapters (e.g. "--start=#3") yield the chapter's time position. The chapter support might be able to replace --chapter completely, but for now I am not sure how well this works out with e.g. DVDs and BDs, and a separate --chapter option is useful interface-wise.
2012-11-15 17:49:17 +00:00
const m_option_type_t m_option_type_rel_time = {
.name = "Relative time or percent position",
.size = sizeof(struct m_rel_time),
.parse = parse_rel_time,
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.copy = copy_opt,
after a long time, finally i could add -endpos option to mplayer executable. as oded told me on 1006 02 24, i applied it, blame me if some problem occurs, i hope not, since i tried it for a while.... git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@19979 b3059339-0415-0410-9bf9-f77b7e298cf2
2006-09-25 16:47:56 +00:00
};
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
spelling and grammar fixes galore git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10642 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-08-17 13:51:04 +00:00
//// Objects (i.e. filters, etc) settings
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
Rename directories, move files (step 2 of 2) Finish renaming directories and moving files. Adjust all include statements to make the previous commit compile. The two commits are separate, because git is bad at tracking renames and content changes at the same time. Also take this as an opportunity to remove the separation between "common" and "mplayer" sources in the Makefile. ("common" used to be shared between mplayer and mencoder.)
2012-11-09 00:06:43 +00:00
#include "core/m_struct.h"
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
#undef VAL
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
#define VAL(x) (*(m_obj_settings_t **)(x))
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int find_obj_desc(struct bstr name, const m_obj_list_t *l,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
const m_struct_t **ret)
{
int i;
char *n;
for (i = 0; l->list[i]; i++) {
n = M_ST_MB(char *, l->list[i], l->name_off);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(name, n)) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
*ret = M_ST_MB(m_struct_t *, l->list[i], l->desc_off);
return 1;
}
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 0;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int get_obj_param(struct bstr opt_name, struct bstr obj_name,
const m_struct_t *desc, struct bstr str, int *nold,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
int oldmax, char **dst)
{
const m_option_t *opt;
int r;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int eq = bstrchr(str, '=');
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (eq > 0) { // eq == 0 ignored
struct bstr p = bstr_cut(str, eq + 1);
str = bstr_splice(str, 0, eq);
opt = m_option_list_findb(desc->fields, str);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!opt) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: %.*s doesn't have a %.*s parameter.\n",
BSTR_P(opt_name), BSTR_P(obj_name), BSTR_P(str));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_UNKNOWN;
}
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
r = m_option_parse(opt, str, p, NULL);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
if (r > M_OPT_EXIT)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: "
"Error while parsing %.*s parameter %.*s (%.*s)\n",
BSTR_P(opt_name), BSTR_P(obj_name), BSTR_P(str),
BSTR_P(p));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
if (dst) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
dst[0] = bstrdup0(NULL, str);
dst[1] = bstrdup0(NULL, p);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
} else {
if ((*nold) >= oldmax) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: %.*s has only %d params, so you can't give more than %d unnamed params.\n",
BSTR_P(opt_name), BSTR_P(obj_name), oldmax, oldmax);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
opt = &desc->fields[(*nold)];
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
r = m_option_parse(opt, bstr0(opt->name), str, NULL);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
if (r > M_OPT_EXIT)
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: "
"Error while parsing %.*s parameter %s (%.*s)\n",
BSTR_P(opt_name), BSTR_P(obj_name), opt->name,
BSTR_P(str));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
if (dst) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
dst[0] = talloc_strdup(NULL, opt->name);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
dst[1] = bstrdup0(NULL, str);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
(*nold)++;
}
Fix crash with e.g. -vf scale=:: git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@15744 b3059339-0415-0410-9bf9-f77b7e298cf2
2005-06-17 08:15:08 +00:00
return 1;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int get_obj_params(struct bstr opt_name, struct bstr name,
struct bstr params, const m_struct_t *desc,
char separator, char ***_ret)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int n = 0, nold = 0, nopts;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
char **ret;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(params, "help")) { // Help
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
char min[50], max[50];
if (!desc->fields) {
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO,
"%.*s doesn't have any options.\n\n", BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_EXIT - 1;
}
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO,
"\n Name Type Min Max\n\n");
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (n = 0; desc->fields[n].name; n++) {
const m_option_t *opt = &desc->fields[n];
if (opt->type->flags & M_OPT_TYPE_HAS_CHILD)
continue;
if (opt->flags & M_OPT_MIN)
sprintf(min, "%-8.0f", opt->min);
else
strcpy(min, "No");
if (opt->flags & M_OPT_MAX)
sprintf(max, "%-8.0f", opt->max);
else
strcpy(max, "No");
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO,
" %-20.20s %-15.15s %-10.10s %-10.10s\n",
opt->name, opt->type->name, min, max);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_EXIT - 1;
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (nopts = 0; desc->fields[nopts].name; nopts++)
/* NOP */;
// TODO : Check that each opt can be parsed
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr s = params;
while (1) {
bool end = false;
int idx = bstrchr(s, separator);
if (idx < 0) {
idx = s.len;
end = true;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr field = bstr_splice(s, 0, idx);
s = bstr_cut(s, idx + 1);
if (field.len == 0) { // Empty field, count it and go on
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
nold++;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
} else {
int r = get_obj_param(opt_name, name, desc, field, &nold, nopts,
NULL);
if (r < 0)
return r;
n++;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (end)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
break;
}
if (nold > nopts) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Too many options for %.*s\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_OUT_OF_RANGE;
}
if (!_ret) // Just test
return 1;
if (n == 0) // No options or only empty options
return 1;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
ret = talloc_array(NULL, char *, (n + 2) * 2);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n = nold = 0;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
s = params;
while (s.len > 0) {
int idx = bstrchr(s, separator);
if (idx < 0)
idx = s.len;
struct bstr field = bstr_splice(s, 0, idx);
s = bstr_cut(s, idx + 1);
if (field.len == 0) { // Empty field, count it and go on
nold++;
} else {
get_obj_param(opt_name, name, desc, field, &nold, nopts,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
&ret[n * 2]);
n++;
}
}
ret[n * 2] = ret[n * 2 + 1] = NULL;
*_ret = ret;
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
Fix crash with e.g. -vf scale=:: git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@15744 b3059339-0415-0410-9bf9-f77b7e298cf2
2005-06-17 08:15:08 +00:00
return 1;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_obj_params(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
char **opts;
int r;
m_obj_params_t *p = opt->priv;
const m_struct_t *desc;
// We need the object desc
if (!p)
return M_OPT_INVALID;
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
desc = p->desc;
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
r = get_obj_params(name, bstr0(desc->name), param, desc, p->separator,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
dst ? &opts : NULL);
if (r < 0)
return r;
if (!dst)
return 1;
if (!opts) // no arguments given
return 1;
for (r = 0; opts[r]; r += 2)
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
m_struct_set(desc, dst, opts[r], bstr0(opts[r + 1]));
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_obj_params = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Object params",
.parse = parse_obj_params,
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
};
spelling and grammar fixes galore git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@10642 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-08-17 13:51:04 +00:00
/// Some predefined types as a definition would be quite lengthy
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
/// Span arguments
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static const m_span_t m_span_params_dflts = {
-1, -1
};
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
static const m_option_t m_span_params_fields[] = {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{"start", M_ST_OFF(m_span_t, start), CONF_TYPE_INT, M_OPT_MIN, 1, 0, NULL},
{"end", M_ST_OFF(m_span_t, end), CONF_TYPE_INT, M_OPT_MIN, 1, 0, NULL},
{ NULL, NULL, 0, 0, 0, 0, NULL }
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
};
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
static const struct m_struct_st m_span_opts = {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
"m_span",
sizeof(m_span_t),
&m_span_params_dflts,
m_span_params_fields
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
};
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_obj_params_t m_span_params_def = {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
&m_span_opts,
'-'
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
};
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_obj_settings(struct bstr opt, struct bstr str,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
const m_obj_list_t *list,
m_obj_settings_t **_ret, int ret_n)
{
int r;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
char **plist = NULL;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
const m_struct_t *desc;
m_obj_settings_t *ret = _ret ? *_ret : NULL;
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
struct bstr param = bstr0(NULL);
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int idx = bstrchr(str, '=');
if (idx >= 0) {
param = bstr_cut(str, idx + 1);
str = bstr_splice(str, 0, idx);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!find_obj_desc(str, list, &desc)) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: %.*s doesn't exist.\n",
BSTR_P(opt), BSTR_P(str));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.start) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!desc && _ret) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(param, "help")) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: %.*s have no option description.\n",
BSTR_P(opt), BSTR_P(str));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_EXIT - 1;
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
plist = talloc_zero_array(NULL, char *, 4);
plist[0] = talloc_strdup(NULL, "_oldargs_");
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
plist[1] = bstrdup0(NULL, param);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
} else if (desc) {
r = get_obj_params(opt, str, param, desc, ':',
_ret ? &plist : NULL);
if (r < 0)
return r;
}
}
if (!_ret)
return 1;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
ret = talloc_realloc(NULL, ret, struct m_obj_settings, ret_n + 2);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
memset(&ret[ret_n], 0, 2 * sizeof(m_obj_settings_t));
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
ret[ret_n].name = bstrdup0(NULL, str);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
ret[ret_n].attribs = plist;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
*_ret = ret;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
return 1;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int obj_settings_list_del(struct bstr opt_name, struct bstr param,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
char **str_list = NULL;
int r, i, idx_max = 0;
char *rem_id = "_removed_marker_";
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
char name[100];
assert(opt_name.len < 100);
memcpy(name, opt_name.start, opt_name.len);
name[opt_name.len] = 0;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
const m_option_t list_opt = {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
name, NULL, CONF_TYPE_STRING_LIST,
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
0, 0, 0, NULL
};
m_obj_settings_t *obj_list = dst ? VAL(dst) : NULL;
if (dst && !obj_list) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %.*s: the list is empty.\n",
BSTR_P(opt_name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
} else if (obj_list) {
for (idx_max = 0; obj_list[idx_max].name != NULL; idx_max++)
/* NOP */;
}
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
r = m_option_parse(&list_opt, opt_name, param, &str_list);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0 || !str_list)
return r;
for (r = 0; str_list[r]; r++) {
int id;
char *endptr;
id = strtol(str_list[r], &endptr, 0);
if (endptr == str_list[r]) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: invalid parameter. We need a list of integers which are the indices of the elements to remove.\n", BSTR_P(opt_name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
m_option_free(&list_opt, &str_list);
return M_OPT_INVALID;
}
if (!obj_list)
continue;
if (id >= idx_max || id < -idx_max) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Index %d is out of range.\n",
BSTR_P(opt_name), id);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
continue;
}
if (id < 0)
id = idx_max + id;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(obj_list[id].name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
free_str_list(&(obj_list[id].attribs));
obj_list[id].name = rem_id;
}
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!dst) {
m_option_free(&list_opt, &str_list);
return 1;
}
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (i = 0; obj_list[i].name; i++) {
while (obj_list[i].name == rem_id) {
memmove(&obj_list[i], &obj_list[i + 1],
sizeof(m_obj_settings_t) * (idx_max - i));
idx_max--;
}
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
obj_list = talloc_realloc(NULL, obj_list, struct m_obj_settings,
idx_max + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = obj_list;
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
Add suffix support to the object list type. So now -vf-clr destroy the list -vf-add filer1=blah,filter append these 2 filters, -vf-pre ... will 'prepend' them. Finnaly -vf-del 2,3,-1 will delete the filters at at given indexs It start from 0, negative number start from the end of the list (so -1 is the last one). git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9914 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-12 13:45:43 +00:00
}
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static void free_obj_settings_list(void *dst)
{
int n;
m_obj_settings_t *d;
Move code to avoid forward declarations in top-level .c files git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@32421 b3059339-0415-0410-9bf9-f77b7e298cf2
2010-10-01 18:29:35 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!dst || !VAL(dst))
return;
Move code to avoid forward declarations in top-level .c files git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@32421 b3059339-0415-0410-9bf9-f77b7e298cf2
2010-10-01 18:29:35 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
d = VAL(dst);
for (n = 0; d[n].name; n++) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(d[n].name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
free_str_list(&(d[n].attribs));
}
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(d);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = NULL;
Move code to avoid forward declarations in top-level .c files git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@32421 b3059339-0415-0410-9bf9-f77b7e298cf2
2010-10-01 18:29:35 +00:00
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_obj_settings_list(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr param, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int len = strlen(opt->name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
m_obj_settings_t *res = NULL, *queue = NULL, *head = NULL;
int op = OP_NONE;
// We need the objects list
if (!opt->priv)
return M_OPT_INVALID;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (opt->name[len - 1] == '*' && (name.len > len - 1)) {
struct bstr suffix = bstr_cut(name, len - 1);
if (bstrcasecmp0(suffix, "-add") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_ADD;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-pre") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_PRE;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-del") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_DEL;
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
else if (bstrcasecmp0(suffix, "-clr") == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
op = OP_CLR;
else {
char prefix[len];
strncpy(prefix, opt->name, len - 1);
prefix[len - 1] = '\0';
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: unknown postfix %.*s\n"
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
"Supported postfixes are:\n"
" %s-add\n"
" Append the given list to the current list\n\n"
" %s-pre\n"
" Prepend the given list to the current list\n\n"
" %s-del x,y,...\n"
" Remove the given elements. Take the list element index (starting from 0).\n"
" Negative index can be used (i.e. -1 is the last element)\n\n"
" %s-clr\n"
" Clear the current list.\n",
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
BSTR_P(name), BSTR_P(suffix), prefix, prefix, prefix, prefix);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_UNKNOWN;
}
}
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// Clear the list ??
if (op == OP_CLR) {
if (dst)
free_obj_settings_list(dst);
return 0;
}
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (param.len == 0)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_MISSING_PARAM;
switch (op) {
case OP_ADD:
if (dst)
head = VAL(dst);
break;
case OP_PRE:
if (dst)
queue = VAL(dst);
break;
case OP_DEL:
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
return obj_settings_list_del(name, param, dst);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
case OP_NONE:
if (dst && VAL(dst))
free_obj_settings_list(dst);
break;
default:
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: FIXME\n", BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_UNKNOWN;
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (!bstrcmp0(param, "help")) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
m_obj_list_t *ol = opt->priv;
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available video filters:\n");
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
for (int n = 0; ol->list[n]; n++)
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %-15s: %s\n",
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
M_ST_MB(char *, ol->list[n], ol->name_off),
M_ST_MB(char *, ol->list[n], ol->info_off));
options: commandline: don't print video filter list twice Video filter help output was printed twice since it used a MSGT type that was not suppressed during preparsing. Fix. This removes a "ID_VIDEO_FILTERS" line that was printed --identify, but I'm not aware of anything using that and other things like audio filters have no such ID_ output either. Also change some printf() calls to mp_msg() in code printing filter-specific help.
2011-07-31 17:40:05 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_EXIT - 1;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr s = bstrdup(NULL, param);
char *allocptr = s.start;
int n = 0;
while (s.len > 0) {
struct bstr el = get_nextsep(&s, OPTION_LIST_SEPARATOR, 1);
int r = parse_obj_settings(name, el, opt->priv, dst ? &res : NULL, n);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
talloc_free(allocptr);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
s = bstr_cut(s, 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
n++;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
talloc_free(allocptr);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (n == 0)
return M_OPT_INVALID;
if (((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
((opt->flags & M_OPT_MAX) && (n > opt->max)))
return M_OPT_OUT_OF_RANGE;
if (dst) {
if (queue) {
int qsize;
for (qsize = 0; queue[qsize].name; qsize++)
/* NOP */;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
res = talloc_realloc(NULL, res, struct m_obj_settings,
qsize + n + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
memcpy(&res[n], queue, (qsize + 1) * sizeof(m_obj_settings_t));
n += qsize;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(queue);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
if (head) {
int hsize;
for (hsize = 0; head[hsize].name; hsize++)
/* NOP */;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
head = talloc_realloc(NULL, head, struct m_obj_settings,
hsize + n + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
memcpy(&head[hsize], res, (n + 1) * sizeof(m_obj_settings_t));
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
talloc_free(res);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
res = head;
}
VAL(dst) = res;
}
return 1;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
static void copy_obj_settings_list(const m_option_t *opt, void *dst,
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
const void *src)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
m_obj_settings_t *d, *s;
int n;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!(dst && src))
return;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
s = VAL(src);
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (VAL(dst))
free_obj_settings_list(dst);
if (!s)
return;
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (n = 0; s[n].name; n++)
/* NOP */;
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
d = talloc_array(NULL, struct m_obj_settings, n + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
for (n = 0; s[n].name; n++) {
options: allocate dynamic options with talloc Allocate data structures for dynamic option values with talloc. Hopefully there's no code left that tries to modify those dynamic option values outside the option parser and relies on them being malloc-allocated. Currently talloc functionality isn't used much and the allocations are not hierarchical, so the main practical use for now is just to allow very easy checking for memory leaks.
2011-07-05 22:24:24 +00:00
d[n].name = talloc_strdup(NULL, s[n].name);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
d[n].attribs = NULL;
options: revert passing around talloc contexts This reverts commit 48f0692ab9 "options: make option struct the talloc parent of options". This made things actually more complicated. It introduced a new parameter to the option parse and copy functions, which was used inconsistently. Some code passed a parent, some not. Morever, you have to call m_option_free() anyway, because not all options actually respect the talloc parent. There is also the question whether passing NULL as parent is supposed to work, or if you still have to implement m_config_free(). On the other hand, this simplifies nothing. I assume the intention was being able to free all option values with a single talloc_free() call, but the same goal can be reached by simply freeing the m_config struct. (The m_config talloc destructor will free each option values.) Get rid of the talloc parent context parameter. This essentially reverts commit 48f0692ab9 ("options: make option struct the talloc parent of options"). In video_out.c, make the VO priv struct the talloc parent for the m_config object, so that destroying the VO will free the options. The ability to free the m_config struct and all its managed options was introduced in commit 89a17bcda6c.
2012-08-04 09:14:38 +00:00
copy_str_list(NULL, &(d[n].attribs), &(s[n].attribs));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
d[n].name = NULL;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
d[n].attribs = NULL;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
VAL(dst) = d;
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
}
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_obj_settings_list = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Object settings list",
.size = sizeof(m_obj_settings_t *),
.flags = M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
.parse = parse_obj_settings_list,
.copy = copy_obj_settings_list,
.free = free_obj_settings_list,
Add the new -vf option wich is the same as vop in reverse order. Syntax is we decided, so you can give the nomes or not with both vop and vf. vf take precedence over vop. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9594 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-03-15 18:01:02 +00:00
};
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
static int parse_custom_url(const m_option_t *opt, struct bstr name,
options: get rid of ambiguous option parsing Options parsing used to be ambiguous, as in the splitting into option and values pairs was ambiguous. Example: -option -something It wasn't clear whether -option actually takes an argument or not. The string "-something" could either be a separate option, or an argument to "-option". The code had to call the option specific parser function to resolve this. This made everything complicated and didn't even have a real use. There was only one case where this was actually used: string lists (m_option_type_string_list) and options based on it. That is because this option type actually turns a single option into a proxy for several real arguments, e.g. "vf*" can handle "-vf-add" and "-vf-clr". Options suffixed with "-clr" are the only options of this group which take no arguments. This is ambiguous only with the "old syntax" (as shown above). The "new" option syntax always puts option name and value into same argument. (E.g. "--option=--something" or "--option" "--something".) Simplify the code by making it statically known whether an option takes a parameter or not with the flag M_OPT_TYPE_OLD_SYNTAX_NO_PARAM. If it's set, the option parser assumes the option takes no argument. The only real ambiguity left, string list options that end on "-clr", are special cased in the parser. Remove some duplication of the logic in the command line parser by moving all argument splitting logic into split_opt(). (It's arguable whether that can be considered code duplication, but now the code is a bit simpler anyway. This might be subjective.) Remove the "ambiguous" parameter from all option parsing related code. Make m_config unaware of the pre-parsing concept. Make most CONF_NOCFG options also CONF_GLOBAL (except those explicitly usable as per-file options.)
2012-08-05 21:34:28 +00:00
struct bstr url, void *dst)
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
{
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int r;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
m_struct_t *desc = opt->priv;
if (!desc) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %.*s: Custom URL needs "
"a pointer to a m_struct_t in the priv field.\n", BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_PARSER_ERR;
}
// extract the protocol
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int idx = bstr_find0(url, "://");
if (idx < 0) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// Filename only
if (m_option_list_find(desc->fields, "filename")) {
m_struct_set(desc, dst, "filename", url);
return 1;
}
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: URL doesn't have a valid protocol!\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return M_OPT_INVALID;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
struct bstr ptr1 = bstr_cut(url, idx + 3);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (m_option_list_find(desc->fields, "string")) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (ptr1.len > 0) {
m_struct_set(desc, dst, "string", ptr1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return 1;
}
}
if (dst && m_option_list_find(desc->fields, "protocol")) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
r = m_struct_set(desc, dst, "protocol", bstr_splice(url, 0, idx));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting protocol.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
}
// check if a username:password is given
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
idx = bstrchr(ptr1, '/');
if (idx < 0)
idx = ptr1.len;
struct bstr hostpart = bstr_splice(ptr1, 0, idx);
struct bstr path = bstr_cut(ptr1, idx);
idx = bstrchr(hostpart, '@');
if (idx >= 0) {
options: fix URL user/password parsing Code parsing the optional user/password part for some URL types given as files to play, such as "ftp://user:password@host/filename", was broken. Fix. I guess this isn't used much as nobody reported it earlier.
2012-09-20 23:30:24 +00:00
struct bstr userpass = bstr_splice(hostpart, 0, idx);
hostpart = bstr_cut(hostpart, idx + 1);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// We got something, at least a username...
if (!m_option_list_find(desc->fields, "username")) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: This URL doesn't have a username part.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// skip
} else {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
idx = bstrchr(userpass, ':');
if (idx >= 0) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// We also have a password
if (!m_option_list_find(desc->fields, "password")) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: This URL doesn't have a password part.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// skip
} else { // Username and password
if (dst) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
r = m_struct_set(desc, dst, "username",
bstr_splice(userpass, 0, idx));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting username.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
r = m_struct_set(desc, dst, "password",
bstr_splice(userpass, idx+1,
userpass.len));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting password.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
}
}
} else { // User name only
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
r = m_struct_set(desc, dst, "username", userpass);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting username.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
}
}
}
// Before looking for a port number check if we have an IPv6 type
// numeric address.
// In an IPv6 URL the numeric address should be inside square braces.
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int idx1 = bstrchr(hostpart, '[');
int idx2 = bstrchr(hostpart, ']');
struct bstr portstr = hostpart;
bool v6addr = false;
if (idx1 >= 0 && idx2 >= 0 && idx1 < idx2) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// we have an IPv6 numeric address
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
portstr = bstr_cut(hostpart, idx2);
hostpart = bstr_splice(hostpart, idx1 + 1, idx2);
v6addr = true;
}
idx = bstrchr(portstr, ':');
if (idx >= 0) {
if (!v6addr)
hostpart = bstr_splice(hostpart, 0, idx);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// We have an URL beginning like http://www.hostname.com:1212
// Get the port number
if (!m_option_list_find(desc->fields, "port")) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: This URL doesn't have a port part.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// skip
} else {
if (dst) {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
int p = bstrtoll(bstr_cut(portstr, idx + 1), NULL, 0);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
char tmp[100];
snprintf(tmp, 99, "%d", p);
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
r = m_struct_set(desc, dst, "port", bstr0(tmp));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting port.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
}
}
}
// Get the hostname
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (hostpart.len > 0) {
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (!m_option_list_find(desc->fields, "hostname")) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: This URL doesn't have a hostname part.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
// skip
} else {
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
r = m_struct_set(desc, dst, "hostname", hostpart);
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
"Option %.*s: Error while setting hostname.\n",
BSTR_P(name));
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
return r;
}
}
}
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
// Look if a path is given
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
if (path.len > 1) { // not just "/"
// copy the path/filename in the URL container
if (!m_option_list_find(desc->fields, "filename")) {
mp_msg(MSGT_CFGPARSER, MSGL_WARN,
"Option %.*s: This URL doesn't have a filename part.\n",
BSTR_P(name));
// skip
} else {
if (dst) {
char *fname = bstrdup0(NULL, bstr_cut(path, 1));
url_unescape_string(fname, fname);
bstr: rename bstr() function to bstr0(), and typedef bstr to struct bstr Replace all uses of bstr() with bstr0(). Also remove the ridiculous C++ workaround.
2012-07-28 21:47:42 +00:00
r = m_struct_set(desc, dst, "filename", bstr0(fname));
options: change option parsing to use bstr Using bstr allows simpler parsing code, especially because it avoids the need to modify or copy strings just to terminate extracted substrings.
2011-07-28 08:07:47 +00:00
talloc_free(fname);
if (r < 0) {
mp_msg(MSGT_CFGPARSER, MSGL_ERR,
"Option %.*s: Error while setting filename.\n",
BSTR_P(name));
return r;
cosmetics: reformat demux_lavf.c, m_option.[ch] and m_property.c
2011-07-03 12:42:04 +00:00
}
}
}
}
return 1;
Fix some 10L typo in header (m_struct_s instead of m_struct_st). Add on/off for flag params Remove the span stuff (unused, never finished, etc) Add object setting option (syntax like -vf but with a settable separator) Add a 'custom url' option type (url where each part can be any kind of option) Replace all exit() with a return code, exit will be done in the cmd line parser git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@9792 b3059339-0415-0410-9bf9-f77b7e298cf2
2003-04-02 16:11:15 +00:00
}
/// TODO : Write the other needed funcs for 'normal' options
correct const usage in the option handling code so that tables can be declared const and moved from .data to .text/rodata sections. git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24994 b3059339-0415-0410-9bf9-f77b7e298cf2
2007-11-09 06:50:53 +00:00
const m_option_type_t m_option_type_custom_url = {
options: simplify option parsing/setting machinery Each option type had three separate operations to copy option values between memory locations: copy between general memory locations ("copy"), copy from general memory to active configuration of the program ("set"), and in the other direction ("save"). No normal option depends on this distinction any more. Change everything to define and use a single "copy" operation only. Change the special options "include" and "profile", which depended on hacky option types, to be special-cased directly in option parsing instead. Remove the now unused option types m_option_type_func and m_option_type_func_param.
2012-05-07 23:10:39 +00:00
.name = "Custom URL",
.parse = parse_custom_url,
Remove trailing whitespace from most files
2009-07-06 23:26:13 +00:00
};