2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
33 //#include "m_config.h"
35 #include "stream/url.h"
36 #include "libavutil/avstring.h"
38 // Don't free for 'production' atm
43 const m_option_t
* m_option_list_find(const m_option_t
* list
,const char* name
) {
46 for(i
= 0 ; list
[i
].name
; i
++) {
47 int l
= strlen(list
[i
].name
) - 1;
48 if((list
[i
].type
->flags
& M_OPT_TYPE_ALLOW_WILDCARD
) &&
49 (l
> 0) && (list
[i
].name
[l
] == '*')) {
50 if(strncasecmp(list
[i
].name
,name
,l
) == 0)
52 } else if(strcasecmp(list
[i
].name
,name
) == 0)
58 // Default function that just does a memcpy
60 static void copy_opt(const m_option_t
* opt
,void* dst
,const void* src
) {
62 memcpy(dst
,src
,opt
->type
->size
);
65 // Helper for the print funcs (from man printf)
66 static char* dup_printf(const char *fmt
, ...) {
67 /* Guess we need no more than 50 bytes. */
71 if ((p
= malloc (size
)) == NULL
)
74 /* Try to print in the allocated space. */
76 n
= vsnprintf (p
, size
, fmt
, ap
);
78 /* If that worked, return the string. */
79 if (n
> -1 && n
< size
)
81 /* Else try again with more space. */
82 if (n
> -1) /* glibc 2.1 */
83 size
= n
+1; /* precisely what is needed */
85 size
*= 2; /* twice the old size */
86 if ((p
= realloc (p
, size
)) == NULL
)
94 #define VAL(x) (*(int*)(x))
96 static int parse_flag(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
97 if (src
== M_CONFIG_FILE
) {
98 if(!param
) return M_OPT_MISSING_PARAM
;
99 if (!strcasecmp(param
, "yes") || /* any other language? */
100 !strcasecmp(param
, "on") ||
101 !strcasecmp(param
, "ja") ||
102 !strcasecmp(param
, "si") ||
103 !strcasecmp(param
, "igen") ||
104 !strcasecmp(param
, "y") ||
105 !strcasecmp(param
, "j") ||
106 !strcasecmp(param
, "i") ||
107 !strcasecmp(param
, "tak") ||
108 !strcasecmp(param
, "ja") ||
109 !strcasecmp(param
, "true") ||
110 !strcmp(param
, "1")) {
111 if(dst
) VAL(dst
) = opt
->max
;
112 } else if (!strcasecmp(param
, "no") ||
113 !strcasecmp(param
, "off") ||
114 !strcasecmp(param
, "nein") ||
115 !strcasecmp(param
, "nicht") ||
116 !strcasecmp(param
, "nem") ||
117 !strcasecmp(param
, "n") ||
118 !strcasecmp(param
, "nie") ||
119 !strcasecmp(param
, "nej") ||
120 !strcasecmp(param
, "false") ||
121 !strcmp(param
, "0")) {
122 if(dst
) VAL(dst
) = opt
->min
;
124 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid parameter for %s flag: %s\n",name
, param
);
125 return M_OPT_INVALID
;
129 if(dst
) VAL(dst
) = opt
->max
;
134 static char* print_flag(const m_option_t
* opt
, const void* val
) {
135 if(VAL(val
) == opt
->min
)
138 return strdup("yes");
141 const m_option_type_t m_option_type_flag
= {
143 "need yes or no in config files",
156 static int parse_int(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
162 return M_OPT_MISSING_PARAM
;
164 tmp_int
= strtoll(param
, &endptr
, 10);
166 tmp_int
= strtoll(param
, &endptr
, 0);
168 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be an integer: %s\n",name
, param
);
169 return M_OPT_INVALID
;
172 if ((opt
->flags
& M_OPT_MIN
) && (tmp_int
< opt
->min
)) {
173 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be >= %d: %s\n", name
, (int) opt
->min
, param
);
174 return M_OPT_OUT_OF_RANGE
;
177 if ((opt
->flags
& M_OPT_MAX
) && (tmp_int
> opt
->max
)) {
178 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be <= %d: %s\n",name
, (int) opt
->max
, param
);
179 return M_OPT_OUT_OF_RANGE
;
183 if (opt
->type
->size
== sizeof(int64_t))
184 *(int64_t *)dst
= tmp_int
;
192 static char* print_int(const m_option_t
* opt
, const void* val
) {
193 if (opt
->type
->size
== sizeof(int64_t))
194 return dup_printf("%"PRId64
, *(const int64_t *)val
);
195 return dup_printf("%d",VAL(val
));
198 const m_option_type_t m_option_type_int
= {
211 const m_option_type_t m_option_type_int64
= {
227 #define VAL(x) (*(double*)(x))
229 static int parse_double(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
235 return M_OPT_MISSING_PARAM
;
237 tmp_float
= strtod(param
, &endptr
);
242 tmp_float
/= strtod(endptr
+1, &endptr
);
246 /* we also handle floats specified with
247 * non-locale decimal point ::atmos
250 tmp_float
-= 1.0/pow(10,strlen(endptr
+1)) * strtod(endptr
+1, &endptr
);
252 tmp_float
+= 1.0/pow(10,strlen(endptr
+1)) * strtod(endptr
+1, &endptr
);
257 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be a floating point "
258 "number or a ratio (numerator[:/]denominator): %s\n",name
, param
);
259 return M_OPT_INVALID
;
262 if (opt
->flags
& M_OPT_MIN
)
263 if (tmp_float
< opt
->min
) {
264 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be >= %f: %s\n", name
, opt
->min
, param
);
265 return M_OPT_OUT_OF_RANGE
;
268 if (opt
->flags
& M_OPT_MAX
)
269 if (tmp_float
> opt
->max
) {
270 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be <= %f: %s\n", name
, opt
->max
, param
);
271 return M_OPT_OUT_OF_RANGE
;
274 if(dst
) VAL(dst
) = tmp_float
;
278 static char* print_double(const m_option_t
* opt
, const void* val
) {
280 return dup_printf("%f",VAL(val
));
283 const m_option_type_t m_option_type_double
= {
285 "double precission floating point number or ratio (numerator[:/]denominator)",
297 #define VAL(x) (*(float*)(x))
299 static int parse_float(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
301 int r
= parse_double(opt
, name
, param
, &tmp
, src
);
302 if(r
==1 && dst
) VAL(dst
) = tmp
;
306 static char* print_float(const m_option_t
* opt
, const void* val
) {
308 return dup_printf("%f",VAL(val
));
311 const m_option_type_t m_option_type_float
= {
313 "floating point number or ratio (numerator[:/]denominator)",
324 ///////////// Position
326 #define VAL(x) (*(off_t*)(x))
328 static int parse_position(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
333 return M_OPT_MISSING_PARAM
;
334 if (sscanf(param
, sizeof(off_t
) == sizeof(int) ?
335 "%d%c" : "%"PRId64
"%c", &tmp_off
, &dummy
) != 1) {
336 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be an integer: %s\n",opt
->name
,param
);
337 return M_OPT_INVALID
;
340 if (opt
->flags
& M_OPT_MIN
)
341 if (tmp_off
< opt
->min
) {
342 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,
343 "The %s option must be >= %"PRId64
": %s\n",
344 name
, (int64_t) opt
->min
, param
);
345 return M_OPT_OUT_OF_RANGE
;
348 if (opt
->flags
& M_OPT_MAX
)
349 if (tmp_off
> opt
->max
) {
350 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,
351 "The %s option must be <= %"PRId64
": %s\n",
352 name
, (int64_t) opt
->max
, param
);
353 return M_OPT_OUT_OF_RANGE
;
361 static char* print_position(const m_option_t
* opt
, const void* val
) {
362 return dup_printf("%"PRId64
,(int64_t)VAL(val
));
365 const m_option_type_t m_option_type_position
= {
382 #define VAL(x) (*(char**)(x))
384 static int parse_str(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
388 return M_OPT_MISSING_PARAM
;
390 if ((opt
->flags
& M_OPT_MIN
) && (strlen(param
) < opt
->min
)) {
391 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Parameter must be >= %d chars: %s\n",
392 (int) opt
->min
, param
);
393 return M_OPT_OUT_OF_RANGE
;
396 if ((opt
->flags
& M_OPT_MAX
) && (strlen(param
) > opt
->max
)) {
397 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Parameter must be <= %d chars: %s\n",
398 (int) opt
->max
, param
);
399 return M_OPT_OUT_OF_RANGE
;
405 VAL(dst
) = strdup(param
);
412 static char* print_str(const m_option_t
* opt
, const void* val
) {
413 return (val
&& VAL(val
) && strlen(VAL(val
)) > 0) ? strdup(VAL(val
)) : NULL
;
416 static void copy_str(const m_option_t
* opt
,void* dst
, const void* src
) {
419 if(VAL(dst
)) free(VAL(dst
)); //FIXME!!!
421 VAL(dst
) = VAL(src
) ? strdup(VAL(src
)) : NULL
;
425 static void free_str(void* src
) {
428 free(VAL(src
)); //FIXME!!!
434 const m_option_type_t m_option_type_string
= {
447 //////////// String list
449 #define LIST_SEPARATOR ','
451 #define VAL(x) (*(char***)(x))
459 static void free_str_list(void* dst
) {
463 if(!dst
|| !VAL(dst
)) return;
468 for(i
= 0 ; d
[i
] != NULL
; i
++)
475 static int str_list_add(char** add
, int n
,void* dst
,int pre
) {
476 char** lst
= VAL(dst
);
479 if(!dst
) return M_OPT_PARSER_ERR
;
482 for(ln
= 0 ; lst
&& lst
[ln
] ; ln
++)
485 lst
= realloc(lst
,(n
+ln
+1)*sizeof(char*));
488 memmove(&lst
[n
],lst
,(ln
+1)*sizeof(char*));
489 memcpy(lst
,add
,n
*sizeof(char*));
491 memcpy(&lst
[ln
],add
,(n
+1)*sizeof(char*));
500 static int str_list_del(char** del
, int n
,void* dst
) {
505 if(!dst
) return M_OPT_PARSER_ERR
;
508 for(ln
= 0 ; lst
&& lst
[ln
] ; ln
++)
512 for(i
= 0 ; del
[i
] != NULL
; i
++) {
513 idx
= strtol(del
[i
], &ep
, 0);
515 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid index: %s\n",del
[i
]);
520 if(idx
< 0 || idx
>= ln
) {
521 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Index %ld is out of range.\n",idx
);
537 d
= calloc(s
+1,sizeof(char*));
538 for(i
= 0, n
= 0 ; i
< ln
; i
++) {
539 if(!lst
[i
]) continue;
551 static char *get_nextsep(char *ptr
, char sep
, int modify
) {
552 char *last_ptr
= ptr
;
554 ptr
= strchr(ptr
, sep
);
555 if(ptr
&& ptr
>last_ptr
&& ptr
[-1]=='\\'){
556 if (modify
) memmove(ptr
-1, ptr
, strlen(ptr
)+1);
564 static int parse_str_list(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
565 int n
= 0,len
= strlen(opt
->name
);
567 char *ptr
= (char *)param
, *last_ptr
, **res
;
570 if(opt
->name
[len
-1] == '*' && ((int)strlen(name
) > len
- 1)) {
571 const char* n
= &name
[len
-1];
572 if(strcasecmp(n
,"-add") == 0)
574 else if(strcasecmp(n
,"-pre") == 0)
576 else if(strcasecmp(n
,"-del") == 0)
578 else if(strcasecmp(n
,"-clr") == 0)
581 return M_OPT_UNKNOWN
;
591 // All other ops need a param
592 if (param
== NULL
|| strlen(param
) == 0)
593 return M_OPT_MISSING_PARAM
;
596 while(ptr
[0] != '\0') {
597 ptr
= get_nextsep(ptr
, LIST_SEPARATOR
, 0);
606 return M_OPT_INVALID
;
607 if( ((opt
->flags
& M_OPT_MIN
) && (n
< opt
->min
)) ||
608 ((opt
->flags
& M_OPT_MAX
) && (n
> opt
->max
)) )
609 return M_OPT_OUT_OF_RANGE
;
613 res
= malloc((n
+2)*sizeof(char*));
614 ptr
= str
= strdup(param
);
619 ptr
= get_nextsep(ptr
, LIST_SEPARATOR
, 1);
621 res
[n
] = strdup(last_ptr
);
625 len
= ptr
- last_ptr
;
626 res
[n
] = malloc(len
+ 1);
627 if(len
) strncpy(res
[n
],last_ptr
,len
);
637 return str_list_add(res
,n
,dst
,0);
639 return str_list_add(res
,n
,dst
,1);
641 return str_list_del(res
,n
,dst
);
651 static void copy_str_list(const m_option_t
* opt
,void* dst
, const void* src
) {
655 if(!(dst
&& src
)) return;
666 for(n
= 0 ; s
[n
] != NULL
; n
++)
668 d
= malloc((n
+1)*sizeof(char*));
670 d
[n
] = s
[n
] ? strdup(s
[n
]) : NULL
;
675 static char* print_str_list(const m_option_t
* opt
, const void* src
) {
677 char *ret
= NULL
,*last
= NULL
;
680 if(!(src
&& VAL(src
))) return NULL
;
683 for(i
= 0 ; lst
[i
] ; i
++) {
685 ret
= dup_printf("%s,%s",last
,lst
[i
]);
688 ret
= strdup(lst
[i
]);
691 if(last
&& last
!= ret
) free(last
);
695 const m_option_type_t m_option_type_string_list
= {
697 "A list of strings separated by ','\n"
698 "Option with a name ending in an * permits using the following suffix: \n"
699 "\t-add: Add the given parameters at the end of the list.\n"
700 "\t-pre: Add the given parameters at the beginning of the list.\n"
701 "\t-del: Remove the entry at the given indices.\n"
702 "\t-clr: Clear the list.\n"
703 "e.g: -vf-add flip,mirror -vf-del 2,5\n",
705 M_OPT_TYPE_DYNAMIC
| M_OPT_TYPE_ALLOW_WILDCARD
,
715 /////////////////// Func based options
717 // A chained list to save the various calls for func_param and func_full
718 typedef struct m_func_save m_func_save_t
;
726 #define VAL(x) (*(m_func_save_t**)(x))
728 static void free_func_pf(void* src
) {
738 if(s
->param
) free(s
->param
);
745 // Parser for func_param and func_full
746 static int parse_func_pf(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
752 s
= calloc(1,sizeof(m_func_save_t
));
753 s
->name
= strdup(name
);
754 s
->param
= param
? strdup(param
) : NULL
;
758 for( ; p
->next
!= NULL
; p
= p
->next
)
767 static void copy_func_pf(const m_option_t
* opt
,void* dst
, const void* src
) {
768 m_func_save_t
*d
= NULL
, *s
,* last
= NULL
;
770 if(!(dst
&& src
)) return;
777 d
= calloc(1,sizeof(m_func_save_t
));
778 d
->name
= strdup(s
->name
);
779 d
->param
= s
->param
? strdup(s
->param
) : NULL
;
791 /////////////////// Func_param
793 static void set_func_param(const m_option_t
* opt
, void* dst
, const void* src
) {
802 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,opt
->name
);
803 for( ; s
!= NULL
; s
= s
->next
)
804 ((m_opt_func_param_t
) opt
->p
)(opt
,s
->param
);
807 const m_option_type_t m_option_type_func_param
= {
810 sizeof(m_func_save_t
*),
814 NULL
, // Nothing to do on save
820 /////////////////// Func_full
822 static void set_func_full(const m_option_t
* opt
, void* dst
, const void* src
) {
827 for(s
= VAL(src
) ; s
; s
= s
->next
) {
829 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,s
->name
);
830 ((m_opt_func_full_t
) opt
->p
)(opt
,s
->name
,s
->param
);
834 const m_option_type_t m_option_type_func_full
= {
837 sizeof(m_func_save_t
*),
838 M_OPT_TYPE_ALLOW_WILDCARD
|M_OPT_TYPE_INDIRECT
,
841 NULL
, // Nothing to do on save
850 #define VAL(x) (*(int*)(x))
852 static int parse_func(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
858 static void set_func(const m_option_t
* opt
,void* dst
, const void* src
) {
860 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,opt
->name
);
861 for(i
= 0 ; i
< VAL(src
) ; i
++)
862 ((m_opt_func_t
) opt
->p
)(opt
);
865 const m_option_type_t m_option_type_func
= {
872 NULL
, // Nothing to do on save
878 /////////////////// Print
880 static int parse_print(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
881 if(opt
->type
== CONF_TYPE_PRINT_INDIRECT
)
882 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "%s", *(char **) opt
->p
);
883 else if(opt
->type
== CONF_TYPE_PRINT_FUNC
)
884 return ((m_opt_func_full_t
) opt
->p
)(opt
,name
,param
);
886 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "%s", (char *) opt
->p
);
888 if(opt
->priv
== NULL
)
893 const m_option_type_t m_option_type_print
= {
906 const m_option_type_t m_option_type_print_indirect
= {
919 const m_option_type_t m_option_type_print_func
= {
923 M_OPT_TYPE_ALLOW_WILDCARD
,
933 /////////////////////// Subconfig
935 #define VAL(x) (*(char***)(x))
937 static int parse_subconf(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
941 const m_option_t
*subopts
;
945 if (param
== NULL
|| strlen(param
) == 0)
946 return M_OPT_MISSING_PARAM
;
948 subparam
= malloc(strlen(param
)+1);
949 subopt
= malloc(strlen(param
)+1);
957 int optlen
= strcspn(p
, ":=");
959 subopt
[0] = subparam
[0] = 0;
960 av_strlcpy(subopt
, p
, optlen
+ 1);
967 optlen
= strcspn(p
, "\"");
968 av_strlcpy(subparam
, p
, optlen
+ 1);
971 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Terminating '\"' missing for '%s'\n", subopt
);
972 return M_OPT_INVALID
;
975 } else if (p
[0] == '%') {
977 optlen
= (int)strtol(p
, (char**)&p
, 0);
978 if (!p
|| p
[0] != '%' || (optlen
> strlen(p
) - 1)) {
979 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid length %i for '%s'\n", optlen
, subopt
);
980 return M_OPT_INVALID
;
983 av_strlcpy(subparam
, p
, optlen
+ 1);
986 optlen
= strcspn(p
, ":");
987 av_strlcpy(subparam
, p
, optlen
+ 1);
994 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Incorrect termination for '%s'\n", subopt
);
995 return M_OPT_INVALID
;
1003 for(i
= 0 ; subopts
[i
].name
; i
++) {
1004 if(!strcmp(subopts
[i
].name
,subopt
)) break;
1006 if(!subopts
[i
].name
) {
1007 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Unknown suboption %s\n",name
,subopt
);
1008 return M_OPT_UNKNOWN
;
1010 r
= m_option_parse(&subopts
[i
],subopt
,
1011 subparam
[0] == 0 ? NULL
: subparam
,NULL
,src
);
1014 lst
= realloc(lst
,2 * (nr
+2) * sizeof(char*));
1015 lst
[2*nr
] = strdup(subopt
);
1016 lst
[2*nr
+1] = subparam
[0] == 0 ? NULL
: strdup(subparam
);
1017 memset(&lst
[2*(nr
+1)],0,2*sizeof(char*));
1032 const m_option_type_t m_option_type_subconfig
= {
1034 "The syntax is -option opt1=foo:flag:opt2=blah",
1036 M_OPT_TYPE_HAS_CHILD
,
1045 #include "libmpcodecs/img_format.h"
1047 /* FIXME: snyc with img_format.h */
1051 } mp_imgfmt_list
[] = {
1052 {"444p16le", IMGFMT_444P16_LE
},
1053 {"444p16be", IMGFMT_444P16_BE
},
1054 {"422p16le", IMGFMT_422P16_LE
},
1055 {"422p16be", IMGFMT_422P16_BE
},
1056 {"420p16le", IMGFMT_420P16_LE
},
1057 {"420p16be", IMGFMT_420P16_BE
},
1058 {"444p16", IMGFMT_444P16
},
1059 {"422p16", IMGFMT_422P16
},
1060 {"420p16", IMGFMT_420P16
},
1061 {"420a", IMGFMT_420A
},
1062 {"444p", IMGFMT_444P
},
1063 {"422p", IMGFMT_422P
},
1064 {"411p", IMGFMT_411P
},
1065 {"440p", IMGFMT_440P
},
1066 {"yuy2", IMGFMT_YUY2
},
1067 {"uyvy", IMGFMT_UYVY
},
1068 {"yvu9", IMGFMT_YVU9
},
1069 {"if09", IMGFMT_IF09
},
1070 {"yv12", IMGFMT_YV12
},
1071 {"i420", IMGFMT_I420
},
1072 {"iyuv", IMGFMT_IYUV
},
1073 {"clpl", IMGFMT_CLPL
},
1074 {"hm12", IMGFMT_HM12
},
1075 {"y800", IMGFMT_Y800
},
1077 {"nv12", IMGFMT_NV12
},
1078 {"nv21", IMGFMT_NV21
},
1079 {"bgr24", IMGFMT_BGR24
},
1080 {"bgr32", IMGFMT_BGR32
},
1081 {"bgr16", IMGFMT_BGR16
},
1082 {"bgr15", IMGFMT_BGR15
},
1083 {"bgr12", IMGFMT_BGR12
},
1084 {"bgr8", IMGFMT_BGR8
},
1085 {"bgr4", IMGFMT_BGR4
},
1086 {"bg4b", IMGFMT_BG4B
},
1087 {"bgr1", IMGFMT_BGR1
},
1088 {"rgb48be", IMGFMT_RGB48BE
},
1089 {"rgb48le", IMGFMT_RGB48LE
},
1090 {"rgb48ne", IMGFMT_RGB48NE
},
1091 {"rgb24", IMGFMT_RGB24
},
1092 {"rgb32", IMGFMT_RGB32
},
1093 {"rgb16", IMGFMT_RGB16
},
1094 {"rgb15", IMGFMT_RGB15
},
1095 {"rgb12", IMGFMT_RGB12
},
1096 {"rgb8", IMGFMT_RGB8
},
1097 {"rgb4", IMGFMT_RGB4
},
1098 {"rg4b", IMGFMT_RG4B
},
1099 {"rgb1", IMGFMT_RGB1
},
1100 {"rgba", IMGFMT_RGBA
},
1101 {"argb", IMGFMT_ARGB
},
1102 {"bgra", IMGFMT_BGRA
},
1103 {"abgr", IMGFMT_ABGR
},
1104 {"mjpeg", IMGFMT_MJPEG
},
1105 {"mjpg", IMGFMT_MJPEG
},
1109 static int parse_imgfmt(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
1113 if (param
== NULL
|| strlen(param
) == 0)
1114 return M_OPT_MISSING_PARAM
;
1116 if(!strcmp(param
,"help")) {
1117 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Available formats:");
1118 for(i
= 0 ; mp_imgfmt_list
[i
].name
; i
++)
1119 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, " %s",mp_imgfmt_list
[i
].name
);
1120 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "\n");
1121 return M_OPT_EXIT
- 1;
1124 if (sscanf(param
, "0x%x", &fmt
) != 1)
1126 for(i
= 0 ; mp_imgfmt_list
[i
].name
; i
++) {
1127 if(!strcasecmp(param
,mp_imgfmt_list
[i
].name
)) {
1128 fmt
=mp_imgfmt_list
[i
].fmt
;
1132 if(!mp_imgfmt_list
[i
].name
) {
1133 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: unknown format name: '%s'\n",name
,param
);
1134 return M_OPT_INVALID
;
1139 *((uint32_t*)dst
) = fmt
;
1144 const m_option_type_t m_option_type_imgfmt
= {
1146 "Please report any missing colorspaces.",
1157 #include "libaf/af_format.h"
1159 /* FIXME: snyc with af_format.h */
1163 } mp_afmt_list
[] = {
1165 {"mulaw", AF_FORMAT_MU_LAW
},
1166 {"alaw", AF_FORMAT_A_LAW
},
1167 {"mpeg2", AF_FORMAT_MPEG2
},
1168 {"ac3le", AF_FORMAT_AC3_LE
},
1169 {"ac3be", AF_FORMAT_AC3_BE
},
1170 {"ac3ne", AF_FORMAT_AC3_NE
},
1171 {"imaadpcm", AF_FORMAT_IMA_ADPCM
},
1173 {"u8", AF_FORMAT_U8
},
1174 {"s8", AF_FORMAT_S8
},
1175 {"u16le", AF_FORMAT_U16_LE
},
1176 {"u16be", AF_FORMAT_U16_BE
},
1177 {"u16ne", AF_FORMAT_U16_NE
},
1178 {"s16le", AF_FORMAT_S16_LE
},
1179 {"s16be", AF_FORMAT_S16_BE
},
1180 {"s16ne", AF_FORMAT_S16_NE
},
1181 {"u24le", AF_FORMAT_U24_LE
},
1182 {"u24be", AF_FORMAT_U24_BE
},
1183 {"u24ne", AF_FORMAT_U24_NE
},
1184 {"s24le", AF_FORMAT_S24_LE
},
1185 {"s24be", AF_FORMAT_S24_BE
},
1186 {"s24ne", AF_FORMAT_S24_NE
},
1187 {"u32le", AF_FORMAT_U32_LE
},
1188 {"u32be", AF_FORMAT_U32_BE
},
1189 {"u32ne", AF_FORMAT_U32_NE
},
1190 {"s32le", AF_FORMAT_S32_LE
},
1191 {"s32be", AF_FORMAT_S32_BE
},
1192 {"s32ne", AF_FORMAT_S32_NE
},
1193 {"floatle", AF_FORMAT_FLOAT_LE
},
1194 {"floatbe", AF_FORMAT_FLOAT_BE
},
1195 {"floatne", AF_FORMAT_FLOAT_NE
},
1199 static int parse_afmt(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
1203 if (param
== NULL
|| strlen(param
) == 0)
1204 return M_OPT_MISSING_PARAM
;
1206 if(!strcmp(param
,"help")) {
1207 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Available formats:");
1208 for(i
= 0 ; mp_afmt_list
[i
].name
; i
++)
1209 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, " %s",mp_afmt_list
[i
].name
);
1210 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "\n");
1211 return M_OPT_EXIT
- 1;
1214 if (sscanf(param
, "0x%x", &fmt
) != 1)
1216 for(i
= 0 ; mp_afmt_list
[i
].name
; i
++) {
1217 if(!strcasecmp(param
,mp_afmt_list
[i
].name
)) {
1218 fmt
=mp_afmt_list
[i
].fmt
;
1222 if(!mp_afmt_list
[i
].name
) {
1223 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: unknown format name: '%s'\n",name
,param
);
1224 return M_OPT_INVALID
;
1229 *((uint32_t*)dst
) = fmt
;
1234 const m_option_type_t m_option_type_afmt
= {
1236 "Please report any missing formats.",
1248 static double parse_timestring(const char *str
)
1252 if (sscanf(str
, "%d:%d:%lf", &a
, &b
, &d
) == 3)
1253 return 3600*a
+ 60*b
+ d
;
1254 else if (sscanf(str
, "%d:%lf", &a
, &d
) == 2)
1256 else if (sscanf(str
, "%lf", &d
) == 1)
1262 static int parse_time(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
)
1266 if (param
== NULL
|| strlen(param
) == 0)
1267 return M_OPT_MISSING_PARAM
;
1269 time
= parse_timestring(param
);
1270 if (time
== -1e100
) {
1271 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: invalid time: '%s'\n",
1273 return M_OPT_INVALID
;
1277 *(double *)dst
= time
;
1281 const m_option_type_t m_option_type_time
= {
1295 // Time or size (-endpos)
1297 static int parse_time_size(const m_option_t
* opt
,const char *name
, const char *param
, void* dst
, int src
) {
1302 if (param
== NULL
|| strlen(param
) == 0)
1303 return M_OPT_MISSING_PARAM
;
1306 /* End at size parsing */
1307 if(sscanf(param
, "%lf%3s", &end_at
, unit
) == 2) {
1308 ts
.type
= END_AT_SIZE
;
1309 if(!strcasecmp(unit
, "b"))
1311 else if(!strcasecmp(unit
, "kb"))
1313 else if(!strcasecmp(unit
, "mb"))
1314 end_at
*= 1024*1024;
1315 else if(!strcasecmp(unit
, "gb"))
1316 end_at
*= 1024*1024*1024;
1318 ts
.type
= END_AT_NONE
;
1320 if (ts
.type
== END_AT_SIZE
) {
1326 /* End at time parsing. This has to be last because the parsing accepts
1327 * even a number followed by garbage */
1328 if ((end_at
= parse_timestring(param
)) == -1e100
) {
1329 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: invalid time or size: '%s'\n",
1331 return M_OPT_INVALID
;
1334 ts
.type
= END_AT_TIME
;
1338 *(m_time_size_t
*)dst
= ts
;
1342 const m_option_type_t m_option_type_time_size
= {
1345 sizeof(m_time_size_t
),
1356 //// Objects (i.e. filters, etc) settings
1358 #include "m_struct.h"
1361 #define VAL(x) (*(m_obj_settings_t**)(x))
1363 static int find_obj_desc(const char* name
,const m_obj_list_t
* l
,const m_struct_t
** ret
) {
1367 for(i
= 0 ; l
->list
[i
] ; i
++) {
1368 n
= M_ST_MB(char*,l
->list
[i
],l
->name_off
);
1369 if(!strcmp(n
,name
)) {
1370 *ret
= M_ST_MB(m_struct_t
*,l
->list
[i
],l
->desc_off
);
1377 static int get_obj_param(const char* opt_name
,const char* obj_name
, const m_struct_t
* desc
,
1378 char* str
,int* nold
,int oldmax
,char** dst
) {
1380 const m_option_t
* opt
;
1383 eq
= strchr(str
,'=');
1389 if(p
[0] == '\0') p
= NULL
;
1391 opt
= m_option_list_find(desc
->fields
,str
);
1393 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s doesn't have a %s parameter.\n",opt_name
,obj_name
,str
);
1394 return M_OPT_UNKNOWN
;
1396 r
= m_option_parse(opt
,str
,p
,NULL
,M_CONFIG_FILE
);
1399 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name
,obj_name
,str
,p
);
1404 dst
[0] = strdup(str
);
1405 dst
[1] = p
? strdup(p
) : NULL
;
1409 if((*nold
) >= oldmax
) {
1410 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
1411 opt_name
,obj_name
,oldmax
,oldmax
);
1412 return M_OPT_OUT_OF_RANGE
;
1414 opt
= &desc
->fields
[(*nold
)];
1415 r
= m_option_parse(opt
,opt
->name
,str
,NULL
,M_CONFIG_FILE
);
1418 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name
,obj_name
,opt
->name
,str
);
1422 dst
[0] = strdup(opt
->name
);
1423 dst
[1] = strdup(str
);
1430 static int get_obj_params(const char* opt_name
, const char* name
,char* params
,
1431 const m_struct_t
* desc
,char separator
, char*** _ret
) {
1432 int n
= 0,nold
= 0, nopts
,r
;
1433 char* ptr
,*last_ptr
= params
;
1436 if(!strcmp(params
,"help")) { // Help
1437 char min
[50],max
[50];
1439 printf("%s doesn't have any options.\n\n",name
);
1440 return M_OPT_EXIT
- 1;
1442 printf("\n Name Type Min Max\n\n");
1443 for(n
= 0 ; desc
->fields
[n
].name
; n
++) {
1444 const m_option_t
* opt
= &desc
->fields
[n
];
1445 if(opt
->type
->flags
& M_OPT_TYPE_HAS_CHILD
) continue;
1446 if(opt
->flags
& M_OPT_MIN
)
1447 sprintf(min
,"%-8.0f",opt
->min
);
1450 if(opt
->flags
& M_OPT_MAX
)
1451 sprintf(max
,"%-8.0f",opt
->max
);
1454 printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
1461 return M_OPT_EXIT
- 1;
1464 for(nopts
= 0 ; desc
->fields
[nopts
].name
; nopts
++)
1467 // TODO : Check that each opt can be parsed
1469 while(last_ptr
&& last_ptr
[0] != '\0') {
1470 ptr
= strchr(last_ptr
,separator
);
1472 r
= get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,NULL
);
1476 if(ptr
== last_ptr
) { // Empty field, count it and go on
1482 r
= get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,NULL
);
1489 if (!last_ptr
[0]) // count an empty field at the end, too
1492 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Too many options for %s\n", name
);
1493 return M_OPT_OUT_OF_RANGE
;
1495 if(!_ret
) // Just test
1497 if (n
== 0) // No options or only empty options
1500 ret
= malloc((n
+2)*2*sizeof(char*));
1504 while(last_ptr
&& last_ptr
[0] != '\0') {
1505 ptr
= strchr(last_ptr
,separator
);
1507 get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,&ret
[n
*2]);
1511 if(ptr
== last_ptr
) { // Empty field, count it and go on
1517 get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,&ret
[n
*2]);
1521 ret
[n
*2] = ret
[n
*2+1] = NULL
;
1527 static int parse_obj_params(const m_option_t
* opt
,const char *name
,
1528 const char *param
, void* dst
, int src
) {
1531 m_obj_params_t
* p
= opt
->priv
;
1532 const m_struct_t
* desc
;
1535 // We need the object desc
1537 return M_OPT_INVALID
;
1540 cpy
= strdup(param
);
1541 r
= get_obj_params(name
,desc
->name
,cpy
,desc
,p
->separator
,dst
? &opts
: NULL
);
1547 if (!opts
) // no arguments given
1550 for(r
= 0 ; opts
[r
] ; r
+= 2)
1551 m_struct_set(desc
,dst
,opts
[r
],opts
[r
+1]);
1557 const m_option_type_t m_option_type_obj_params
= {
1570 /// Some predefined types as a definition would be quite lengthy
1573 static const m_span_t m_span_params_dflts
= { -1, -1 };
1574 static const m_option_t m_span_params_fields
[] = {
1575 {"start", M_ST_OFF(m_span_t
,start
), CONF_TYPE_INT
, M_OPT_MIN
, 1 ,0, NULL
},
1576 {"end", M_ST_OFF(m_span_t
,end
), CONF_TYPE_INT
, M_OPT_MIN
, 1 ,0, NULL
},
1577 { NULL
, NULL
, 0, 0, 0, 0, NULL
}
1579 static const struct m_struct_st m_span_opts
= {
1582 &m_span_params_dflts
,
1583 m_span_params_fields
1585 const m_obj_params_t m_span_params_def
= {
1590 static int parse_obj_settings(const char* opt
,char* str
,const m_obj_list_t
* list
,
1591 m_obj_settings_t
**_ret
, int ret_n
) {
1593 char *param
,**plist
= NULL
;
1594 const m_struct_t
* desc
;
1595 m_obj_settings_t
*ret
= _ret
? *_ret
: NULL
;
1598 // Now check that the object exists
1599 param
= strchr(str
,'=');
1603 if(strlen(param
) <= 0)
1608 if(!find_obj_desc(str
,list
,&desc
)) {
1609 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s doesn't exist.\n",opt
,str
);
1610 return M_OPT_INVALID
;
1615 if(!strcmp(param
,"help")) {
1616 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Option %s: %s have no option description.\n",opt
,str
);
1617 return M_OPT_EXIT
- 1;
1619 plist
= calloc(4,sizeof(char*));
1620 plist
[0] = strdup("_oldargs_");
1621 plist
[1] = strdup(param
);
1623 r
= get_obj_params(opt
,str
,param
,desc
,':',_ret
? &plist
: NULL
);
1631 ret
= realloc(ret
,(ret_n
+2)*sizeof(m_obj_settings_t
));
1632 memset(&ret
[ret_n
],0,2*sizeof(m_obj_settings_t
));
1633 ret
[ret_n
].name
= strdup(str
);
1634 ret
[ret_n
].attribs
= plist
;
1640 static void free_obj_settings_list(void* dst
);
1642 static int obj_settings_list_del(const char *opt_name
,const char *param
,void* dst
, int src
) {
1643 char** str_list
= NULL
;
1644 int r
,i
,idx_max
= 0;
1645 char* rem_id
= "_removed_marker_";
1646 const m_option_t list_opt
= {opt_name
, NULL
, CONF_TYPE_STRING_LIST
,
1648 m_obj_settings_t
* obj_list
= dst
? VAL(dst
) : NULL
;
1650 if(dst
&& !obj_list
) {
1651 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: the list is empty.\n",opt_name
);
1653 } else if(obj_list
) {
1654 for(idx_max
= 0 ; obj_list
[idx_max
].name
!= NULL
; idx_max
++)
1658 r
= m_option_parse(&list_opt
,opt_name
,param
,&str_list
,src
);
1659 if(r
< 0 || !str_list
)
1662 for(r
= 0 ; str_list
[r
] ; r
++) {
1665 id
= strtol(str_list
[r
],&endptr
,0);
1666 if(endptr
== str_list
[r
]) {
1667 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",opt_name
);
1668 m_option_free(&list_opt
,&str_list
);
1669 return M_OPT_INVALID
;
1671 if(!obj_list
) continue;
1672 if(id
>= idx_max
|| id
< -idx_max
) {
1673 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: Index %d is out of range.\n",opt_name
,id
);
1678 free(obj_list
[id
].name
);
1679 free_str_list(&(obj_list
[id
].attribs
));
1680 obj_list
[id
].name
= rem_id
;
1684 m_option_free(&list_opt
,&str_list
);
1688 for(i
= 0 ; obj_list
[i
].name
; i
++) {
1689 while(obj_list
[i
].name
== rem_id
) {
1690 memmove(&obj_list
[i
],&obj_list
[i
+1],sizeof(m_obj_settings_t
)*(idx_max
- i
));
1694 obj_list
= realloc(obj_list
,sizeof(m_obj_settings_t
)*(idx_max
+1));
1695 VAL(dst
) = obj_list
;
1700 static int parse_obj_settings_list(const m_option_t
* opt
,const char *name
,
1701 const char *param
, void* dst
, int src
) {
1702 int n
= 0,r
,len
= strlen(opt
->name
);
1704 char *ptr
, *last_ptr
;
1705 m_obj_settings_t
*res
= NULL
,*queue
= NULL
,*head
= NULL
;
1708 // We need the objects list
1710 return M_OPT_INVALID
;
1712 if(opt
->name
[len
-1] == '*' && ((int)strlen(name
) > len
- 1)) {
1713 const char* n
= &name
[len
-1];
1714 if(strcasecmp(n
,"-add") == 0)
1716 else if(strcasecmp(n
,"-pre") == 0)
1718 else if(strcasecmp(n
,"-del") == 0)
1720 else if(strcasecmp(n
,"-clr") == 0)
1724 strncpy(prefix
,opt
->name
,len
-1);
1725 prefix
[len
-1] = '\0';
1726 mp_msg(MSGT_VFILTER
,MSGL_ERR
, "Option %s: unknown postfix %s\n"
1727 "Supported postfixes are:\n"
1729 " Append the given list to the current list\n\n"
1731 " Prepend the given list to the current list\n\n"
1733 " Remove the given elements. Take the list element index (starting from 0).\n"
1734 " Negative index can be used (i.e. -1 is the last element)\n\n"
1736 " Clear the current list.\n",name
,n
,prefix
,prefix
,prefix
,prefix
);
1738 return M_OPT_UNKNOWN
;
1742 // Clear the list ??
1745 free_obj_settings_list(dst
);
1749 if (param
== NULL
|| strlen(param
) == 0)
1750 return M_OPT_MISSING_PARAM
;
1754 if(dst
) head
= VAL(dst
);
1757 if(dst
) queue
= VAL(dst
);
1760 return obj_settings_list_del(name
,param
,dst
,src
);
1763 free_obj_settings_list(dst
);
1766 mp_msg(MSGT_VFILTER
,MSGL_ERR
, "Option %s: FIXME\n",name
);
1767 return M_OPT_UNKNOWN
;
1770 if(!strcmp(param
,"help")) {
1771 m_obj_list_t
* ol
= opt
->priv
;
1772 mp_msg(MSGT_VFILTER
,MSGL_INFO
,"Available video filters:\n");
1773 mp_msg(MSGT_IDENTIFY
, MSGL_INFO
, "ID_VIDEO_FILTERS\n");
1774 for(n
= 0 ; ol
->list
[n
] ; n
++)
1775 mp_msg(MSGT_VFILTER
,MSGL_INFO
," %-15s: %s\n",
1776 M_ST_MB(char*,ol
->list
[n
],ol
->name_off
),
1777 M_ST_MB(char*,ol
->list
[n
],ol
->info_off
));
1778 mp_msg(MSGT_VFILTER
,MSGL_INFO
,"\n");
1779 return M_OPT_EXIT
- 1;
1781 ptr
= str
= strdup(param
);
1783 while(ptr
[0] != '\0') {
1785 ptr
= get_nextsep(ptr
, LIST_SEPARATOR
, 1);
1788 r
= parse_obj_settings(name
,last_ptr
,opt
->priv
,dst
? &res
: NULL
,n
);
1797 r
= parse_obj_settings(name
,last_ptr
,opt
->priv
,dst
? &res
: NULL
,n
);
1807 return M_OPT_INVALID
;
1809 if( ((opt
->flags
& M_OPT_MIN
) && (n
< opt
->min
)) ||
1810 ((opt
->flags
& M_OPT_MAX
) && (n
> opt
->max
)) )
1811 return M_OPT_OUT_OF_RANGE
;
1816 for(qsize
= 0 ; queue
[qsize
].name
; qsize
++)
1818 res
= realloc(res
,(qsize
+n
+1)*sizeof(m_obj_settings_t
));
1819 memcpy(&res
[n
],queue
,(qsize
+1)*sizeof(m_obj_settings_t
));
1825 for(hsize
= 0 ; head
[hsize
].name
; hsize
++)
1827 head
= realloc(head
,(hsize
+n
+1)*sizeof(m_obj_settings_t
));
1828 memcpy(&head
[hsize
],res
,(n
+1)*sizeof(m_obj_settings_t
));
1837 static void free_obj_settings_list(void* dst
) {
1839 m_obj_settings_t
*d
;
1841 if(!dst
|| !VAL(dst
)) return;
1845 for(n
= 0 ; d
[n
].name
; n
++) {
1847 free_str_list(&(d
[n
].attribs
));
1854 static void copy_obj_settings_list(const m_option_t
* opt
,void* dst
, const void* src
) {
1855 m_obj_settings_t
*d
,*s
;
1864 free_obj_settings_list(dst
);
1869 for(n
= 0 ; s
[n
].name
; n
++)
1871 d
= malloc((n
+1)*sizeof(m_obj_settings_t
));
1872 for(n
= 0 ; s
[n
].name
; n
++) {
1873 d
[n
].name
= strdup(s
[n
].name
);
1874 d
[n
].attribs
= NULL
;
1875 copy_str_list(NULL
,&(d
[n
].attribs
),&(s
[n
].attribs
));
1878 d
[n
].attribs
= NULL
;
1882 const m_option_type_t m_option_type_obj_settings_list
= {
1883 "Object settings list",
1885 sizeof(m_obj_settings_t
*),
1886 M_OPT_TYPE_DYNAMIC
|M_OPT_TYPE_ALLOW_WILDCARD
,
1887 parse_obj_settings_list
,
1889 copy_obj_settings_list
,
1890 copy_obj_settings_list
,
1891 copy_obj_settings_list
,
1892 free_obj_settings_list
,
1897 static int parse_obj_presets(const m_option_t
* opt
,const char *name
,
1898 const char *param
, void* dst
, int src
) {
1899 m_obj_presets_t
* obj_p
= (m_obj_presets_t
*)opt
->priv
;
1900 m_struct_t
*in_desc
,*out_desc
;
1903 char* pre_name
= NULL
;
1906 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Presets need a pointer to a m_obj_presets_t in the priv field.\n",name
);
1907 return M_OPT_PARSER_ERR
;
1911 return M_OPT_MISSING_PARAM
;
1913 pre
= obj_p
->presets
;
1914 in_desc
= obj_p
->in_desc
;
1915 out_desc
= obj_p
->out_desc
? obj_p
->out_desc
: obj_p
->in_desc
;
1918 if(!strcmp(param
,"help")) {
1919 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Available presets for %s->%s:",out_desc
->name
,name
);
1920 for(pre
= obj_p
->presets
;(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) ;
1922 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, " %s",pre_name
);
1923 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "\n");
1924 return M_OPT_EXIT
- 1;
1927 for(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
) ; pre_name
;
1928 pre
+= s
, pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) {
1929 if(!strcmp(pre_name
,param
)) break;
1932 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: There is no preset named %s\n"
1933 "Available presets are:",name
,param
);
1934 for(pre
= obj_p
->presets
;(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) ;
1936 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, " %s",pre_name
);
1937 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "\n");
1938 return M_OPT_INVALID
;
1943 for(i
= 0 ; in_desc
->fields
[i
].name
; i
++) {
1944 const m_option_t
* out_opt
= m_option_list_find(out_desc
->fields
,
1945 in_desc
->fields
[i
].name
);
1947 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Unable to find the target option for field %s.\nPlease report this to the developers.\n",name
,in_desc
->fields
[i
].name
);
1948 return M_OPT_PARSER_ERR
;
1950 m_option_copy(out_opt
,M_ST_MB_P(dst
,out_opt
->p
),M_ST_MB_P(pre
,in_desc
->fields
[i
].p
));
1956 const m_option_type_t m_option_type_obj_presets
= {
1969 static int parse_custom_url(const m_option_t
* opt
,const char *name
,
1970 const char *url
, void* dst
, int src
) {
1971 int pos1
, pos2
, r
, v6addr
= 0;
1972 char *ptr1
=NULL
, *ptr2
=NULL
, *ptr3
=NULL
, *ptr4
=NULL
;
1973 m_struct_t
* desc
= opt
->priv
;
1976 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Custom URL needs a pointer to a m_struct_t in the priv field.\n",name
);
1977 return M_OPT_PARSER_ERR
;
1980 // extract the protocol
1981 ptr1
= strstr(url
, "://");
1984 if(m_option_list_find(desc
->fields
,"filename")) {
1985 m_struct_set(desc
,dst
,"filename",url
);
1988 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,"Option %s: URL doesn't have a valid protocol!\n",name
);
1989 return M_OPT_INVALID
;
1991 if(m_option_list_find(desc
->fields
,"string")) {
1992 if(strlen(ptr1
)>3) {
1993 m_struct_set(desc
,dst
,"string",ptr1
+3);
1998 if(dst
&& m_option_list_find(desc
->fields
,"protocol")) {
2000 r
= m_struct_set(desc
,dst
,"protocol",url
);
2003 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting protocol.\n",name
);
2012 // check if a username:password is given
2013 ptr2
= strstr(ptr1
, "@");
2014 ptr3
= strstr(ptr1
, "/");
2015 if( ptr3
!=NULL
&& ptr3
<ptr2
) {
2016 // it isn't really a username but rather a part of the path
2021 // We got something, at least a username...
2022 if(!m_option_list_find(desc
->fields
,"username")) {
2023 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a username part.\n",name
);
2026 ptr3
= strstr(ptr1
, ":");
2027 if( ptr3
!=NULL
&& ptr3
<ptr2
) {
2028 // We also have a password
2029 if(!m_option_list_find(desc
->fields
,"password")) {
2030 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a password part.\n",name
);
2032 } else { // Username and password
2035 r
= m_struct_set(desc
,dst
,"username",ptr1
);
2038 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting username.\n",name
);
2042 r
= m_struct_set(desc
,dst
,"password",ptr3
+1);
2045 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting password.\n",name
);
2050 } else { // User name only
2052 r
= m_struct_set(desc
,dst
,"username",ptr1
);
2055 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting username.\n",name
);
2064 // before looking for a port number check if we have an IPv6 type numeric address
2065 // in an IPv6 URL the numeric address should be inside square braces.
2066 ptr2
= strstr(ptr1
, "[");
2067 ptr3
= strstr(ptr1
, "]");
2068 // If the [] is after the first it isn't the hostname
2069 ptr4
= strstr(ptr1
, "/");
2070 if( ptr2
!=NULL
&& ptr3
!=NULL
&& (ptr2
< ptr3
) && (!ptr4
|| ptr4
> ptr3
)) {
2071 // we have an IPv6 numeric address
2080 // look if the port is given
2081 ptr2
= strstr(ptr2
, ":");
2082 // If the : is after the first / it isn't the port
2083 ptr3
= strstr(ptr1
, "/");
2084 if(ptr3
&& ptr3
- ptr2
< 0) ptr2
= NULL
;
2087 // Look if a path is given
2090 // So we have an URL like http://www.hostname.com
2093 // We have an URL like http://www.hostname.com/file.txt
2097 // We have an URL beginning like http://www.hostname.com:1212
2098 // Get the port number
2099 if(!m_option_list_find(desc
->fields
,"port")) {
2100 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a port part.\n",name
);
2104 int p
= atoi(ptr2
+1);
2106 snprintf(tmp
,99,"%d",p
);
2107 r
= m_struct_set(desc
,dst
,"port",tmp
);
2109 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting port.\n",name
);
2116 if( v6addr
) pos2
--;
2119 if(!m_option_list_find(desc
->fields
,"hostname")) {
2120 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a hostname part.\n",name
);
2123 char tmp
[pos2
-pos1
+1];
2124 strncpy(tmp
,ptr1
, pos2
-pos1
);
2125 tmp
[pos2
-pos1
] = '\0';
2126 r
= m_struct_set(desc
,dst
,"hostname",tmp
);
2128 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting hostname.\n",name
);
2133 // Look if a path is given
2134 ptr2
= strstr(ptr1
, "/");
2136 // A path/filename is given
2137 // check if it's not a trailing '/'
2138 if( strlen(ptr2
)>1 ) {
2139 // copy the path/filename in the URL container
2140 if(!m_option_list_find(desc
->fields
,"filename")) {
2141 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a hostname part.\n",name
);
2145 int l
= strlen(ptr2
+1) + 1;
2146 char* fname
= ptr2
+1;
2149 url_unescape_string(fname
,ptr2
+1);
2151 r
= m_struct_set(desc
,dst
,"filename",fname
);
2155 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting filename.\n",name
);
2165 /// TODO : Write the other needed funcs for 'normal' options
2166 const m_option_type_t m_option_type_custom_url
= {