12 //#include "m_config.h"
14 #include "libmpdemux/url.h"
16 // Don't free for 'production' atm
21 m_option_t
* m_option_list_find(m_option_t
* list
,char* name
) {
24 for(i
= 0 ; list
[i
].name
; i
++) {
25 int l
= strlen(list
[i
].name
) - 1;
26 if((list
[i
].type
->flags
& M_OPT_TYPE_ALLOW_WILDCARD
) &&
27 (l
> 0) && (list
[i
].name
[l
] == '*')) {
28 if(strncasecmp(list
[i
].name
,name
,l
) == 0)
30 } else if(strcasecmp(list
[i
].name
,name
) == 0)
36 // Default function that just does a memcpy
38 static void copy_opt(m_option_t
* opt
,void* dst
,void* src
) {
40 memcpy(dst
,src
,opt
->type
->size
);
43 // Helper for the print funcs (from man printf)
44 static char* dup_printf(const char *fmt
, ...) {
45 /* Guess we need no more than 50 bytes. */
49 if ((p
= malloc (size
)) == NULL
)
52 /* Try to print in the allocated space. */
54 n
= vsnprintf (p
, size
, fmt
, ap
);
56 /* If that worked, return the string. */
57 if (n
> -1 && n
< size
)
59 /* Else try again with more space. */
60 if (n
> -1) /* glibc 2.1 */
61 size
= n
+1; /* precisely what is needed */
63 size
*= 2; /* twice the old size */
64 if ((p
= realloc (p
, size
)) == NULL
)
72 #define VAL(x) (*(int*)(x))
74 static int parse_flag(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
75 if (src
== M_CONFIG_FILE
) {
76 if(!param
) return M_OPT_MISSING_PARAM
;
77 if (!strcasecmp(param
, "yes") || /* any other language? */
78 !strcasecmp(param
, "on") ||
79 !strcasecmp(param
, "ja") ||
80 !strcasecmp(param
, "si") ||
81 !strcasecmp(param
, "igen") ||
82 !strcasecmp(param
, "y") ||
83 !strcasecmp(param
, "j") ||
84 !strcasecmp(param
, "i") ||
85 !strcasecmp(param
, "tak") ||
86 !strcasecmp(param
, "ja") ||
87 !strcasecmp(param
, "true") ||
88 !strcmp(param
, "1")) {
89 if(dst
) VAL(dst
) = opt
->max
;
90 } else if (!strcasecmp(param
, "no") ||
91 !strcasecmp(param
, "off") ||
92 !strcasecmp(param
, "nein") ||
93 !strcasecmp(param
, "nicht") ||
94 !strcasecmp(param
, "nem") ||
95 !strcasecmp(param
, "n") ||
96 !strcasecmp(param
, "nie") ||
97 !strcasecmp(param
, "nej") ||
98 !strcasecmp(param
, "false") ||
99 !strcmp(param
, "0")) {
100 if(dst
) VAL(dst
) = opt
->min
;
102 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid parameter for %s flag: %s\n",name
, param
);
103 return M_OPT_INVALID
;
107 if(dst
) VAL(dst
) = opt
->max
;
112 static char* print_flag(m_option_t
* opt
, void* val
) {
113 if(VAL(val
) == opt
->min
)
116 return strdup("yes");
119 m_option_type_t m_option_type_flag
= {
121 "need yes or no in config files",
134 static int parse_int(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
140 return M_OPT_MISSING_PARAM
;
142 tmp_int
= strtol(param
, &endptr
, 0);
144 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be an integer: %s\n",name
, param
);
145 return M_OPT_INVALID
;
148 if ((opt
->flags
& M_OPT_MIN
) && (tmp_int
< opt
->min
)) {
149 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be >= %d: %s\n", name
, (int) opt
->min
, param
);
150 return M_OPT_OUT_OF_RANGE
;
153 if ((opt
->flags
& M_OPT_MAX
) && (tmp_int
> opt
->max
)) {
154 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be <= %d: %s\n",name
, (int) opt
->max
, param
);
155 return M_OPT_OUT_OF_RANGE
;
158 if(dst
) VAL(dst
) = tmp_int
;
163 static char* print_int(m_option_t
* opt
, void* val
) {
165 return dup_printf("%d",VAL(val
));
168 m_option_type_t m_option_type_int
= {
184 #define VAL(x) (*(double*)(x))
186 static int parse_double(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
192 return M_OPT_MISSING_PARAM
;
194 tmp_float
= strtod(param
, &endptr
);
199 tmp_float
/= strtod(endptr
+1, &endptr
);
203 /* we also handle floats specified with
204 * non-locale decimal point ::atmos
207 tmp_float
-= 1.0/pow(10,strlen(endptr
+1)) * strtod(endptr
+1, &endptr
);
209 tmp_float
+= 1.0/pow(10,strlen(endptr
+1)) * strtod(endptr
+1, &endptr
);
214 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be a floating point "
215 "number or a ratio (numerator[:/]denominator): %s\n",name
, param
);
216 return M_OPT_INVALID
;
219 if (opt
->flags
& M_OPT_MIN
)
220 if (tmp_float
< opt
->min
) {
221 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be >= %f: %s\n", name
, opt
->min
, param
);
222 return M_OPT_OUT_OF_RANGE
;
225 if (opt
->flags
& M_OPT_MAX
)
226 if (tmp_float
> opt
->max
) {
227 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be <= %f: %s\n", name
, opt
->max
, param
);
228 return M_OPT_OUT_OF_RANGE
;
231 if(dst
) VAL(dst
) = tmp_float
;
235 static char* print_double(m_option_t
* opt
, void* val
) {
237 return dup_printf("%f",VAL(val
));
240 m_option_type_t m_option_type_double
= {
242 "double precission floating point number or ratio (numerator[:/]denominator)",
254 #define VAL(x) (*(float*)(x))
256 static int parse_float(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
258 int r
= parse_double(opt
, name
, param
, &tmp
, src
);
259 if(r
==1 && dst
) VAL(dst
) = tmp
;
263 static char* print_float(m_option_t
* opt
, void* val
) {
265 return dup_printf("%f",VAL(val
));
268 m_option_type_t m_option_type_float
= {
270 "floating point number or ratio (numerator[:/]denominator)",
281 ///////////// Position
283 #define VAL(x) (*(off_t*)(x))
285 static int parse_position(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
290 return M_OPT_MISSING_PARAM
;
291 if (sscanf(param
, sizeof(off_t
) == sizeof(int) ?
292 "%d%c" : "%lld%c", &tmp_off
, &dummy
) != 1) {
293 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "The %s option must be an integer: %s\n",opt
->name
,param
);
294 return M_OPT_INVALID
;
297 if (opt
->flags
& M_OPT_MIN
)
298 if (tmp_off
< opt
->min
) {
299 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,
300 (sizeof(off_t
) == sizeof(int) ?
301 "The %s option must be >= %d: %s\n" :
302 "The %s option must be >= %lld: %s\n"),
303 name
, (off_t
) opt
->min
, param
);
304 return M_OPT_OUT_OF_RANGE
;
307 if (opt
->flags
& M_OPT_MAX
)
308 if (tmp_off
> opt
->max
) {
309 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,
310 (sizeof(off_t
) == sizeof(int) ?
311 "The %s option must be <= %d: %s\n" :
312 "The %s option must be <= %lld: %s\n"),
313 name
, (off_t
) opt
->max
, param
);
314 return M_OPT_OUT_OF_RANGE
;
322 static char* print_position(m_option_t
* opt
, void* val
) {
323 return dup_printf(sizeof(off_t
) == sizeof(int) ? "%d" : "%lld",VAL(val
));
326 m_option_type_t m_option_type_position
= {
343 #define VAL(x) (*(char**)(x))
345 static int parse_str(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
349 return M_OPT_MISSING_PARAM
;
351 if ((opt
->flags
& M_OPT_MIN
) && (strlen(param
) < opt
->min
)) {
352 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Parameter must be >= %d chars: %s\n",
353 (int) opt
->min
, param
);
354 return M_OPT_OUT_OF_RANGE
;
357 if ((opt
->flags
& M_OPT_MAX
) && (strlen(param
) > opt
->max
)) {
358 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Parameter must be <= %d chars: %s\n",
359 (int) opt
->max
, param
);
360 return M_OPT_OUT_OF_RANGE
;
366 VAL(dst
) = strdup(param
);
373 static char* print_str(m_option_t
* opt
, void* val
) {
374 return (val
&& VAL(val
) && strlen(VAL(val
)) > 0) ? strdup(VAL(val
)) : NULL
;
377 static void copy_str(m_option_t
* opt
,void* dst
, void* src
) {
380 if(VAL(dst
)) free(VAL(dst
)); //FIXME!!!
382 VAL(dst
) = VAL(src
) ? strdup(VAL(src
)) : NULL
;
386 static void free_str(void* src
) {
389 free(VAL(src
)); //FIXME!!!
395 m_option_type_t m_option_type_string
= {
408 //////////// String list
410 #define LIST_SEPARATOR ','
412 #define VAL(x) (*(char***)(x))
420 static void free_str_list(void* dst
) {
424 if(!dst
|| !VAL(dst
)) return;
429 for(i
= 0 ; d
[i
] != NULL
; i
++)
436 static int str_list_add(char** add
, int n
,void* dst
,int pre
) {
437 char** lst
= VAL(dst
);
440 if(!dst
) return M_OPT_PARSER_ERR
;
443 for(ln
= 0 ; lst
&& lst
[ln
] ; ln
++)
446 lst
= realloc(lst
,(n
+ln
+1)*sizeof(char*));
449 memmove(&lst
[n
],lst
,(ln
+1)*sizeof(char*));
450 memcpy(lst
,add
,n
*sizeof(char*));
452 memcpy(&lst
[ln
],add
,(n
+1)*sizeof(char*));
461 static int str_list_del(char** del
, int n
,void* dst
) {
466 if(!dst
) return M_OPT_PARSER_ERR
;
469 for(ln
= 0 ; lst
&& lst
[ln
] ; ln
++)
473 for(i
= 0 ; del
[i
] != NULL
; i
++) {
474 idx
= strtol(del
[i
], &ep
, 0);
476 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid index: %s\n",del
[i
]);
481 if(idx
< 0 || idx
>= ln
) {
482 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Index %ld is out of range.\n",idx
);
498 d
= calloc(s
+1,sizeof(char*));
499 for(i
= 0, n
= 0 ; i
< ln
; i
++) {
500 if(!lst
[i
]) continue;
513 static int parse_str_list(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
514 int n
= 0,len
= strlen(opt
->name
);
515 char *ptr
= param
, *last_ptr
, **res
;
518 if(opt
->name
[len
-1] == '*' && ((int)strlen(name
) > len
- 1)) {
519 char* n
= &name
[len
-1];
520 if(strcasecmp(n
,"-add") == 0)
522 else if(strcasecmp(n
,"-pre") == 0)
524 else if(strcasecmp(n
,"-del") == 0)
526 else if(strcasecmp(n
,"-clr") == 0)
529 return M_OPT_UNKNOWN
;
539 // All other ops need a param
540 if (param
== NULL
|| strlen(param
) == 0)
541 return M_OPT_MISSING_PARAM
;
544 while(ptr
[0] != '\0') {
546 ptr
= strchr(ptr
,LIST_SEPARATOR
);
555 return M_OPT_INVALID
;
556 if( ((opt
->flags
& M_OPT_MIN
) && (n
< opt
->min
)) ||
557 ((opt
->flags
& M_OPT_MAX
) && (n
> opt
->max
)) )
558 return M_OPT_OUT_OF_RANGE
;
562 res
= malloc((n
+2)*sizeof(char*));
568 ptr
= strchr(ptr
,LIST_SEPARATOR
);
570 res
[n
] = strdup(last_ptr
);
574 len
= ptr
- last_ptr
;
575 res
[n
] = (char*)malloc(len
+ 1);
576 if(len
) strncpy(res
[n
],last_ptr
,len
);
585 return str_list_add(res
,n
,dst
,0);
587 return str_list_add(res
,n
,dst
,1);
589 return str_list_del(res
,n
,dst
);
599 static void copy_str_list(m_option_t
* opt
,void* dst
, void* src
) {
603 if(!(dst
&& src
)) return;
614 for(n
= 0 ; s
[n
] != NULL
; n
++)
616 d
= (char**)malloc((n
+1)*sizeof(char*));
618 d
[n
] = s
[n
] ? strdup(s
[n
]) : NULL
;
623 static char* print_str_list(m_option_t
* opt
, void* src
) {
625 char *ret
= NULL
,*last
= NULL
;
628 if(!(src
&& VAL(src
))) return NULL
;
631 for(i
= 0 ; lst
[i
] ; i
++) {
633 ret
= dup_printf("%s,%s",last
,lst
[i
]);
636 ret
= strdup(lst
[i
]);
639 if(last
&& last
!= ret
) free(last
);
643 m_option_type_t m_option_type_string_list
= {
645 "A list of strings separated by ','\n"
646 "Option with a name ending in an * permits using the following suffix: \n"
647 "\t-add: Add the given parameters at the end of the list.\n"
648 "\t-pre: Add the given parameters at the begining of the list.\n"
649 "\t-del: Remove the entry at the given indices.\n"
650 "\t-clr: Clear the list.\n"
651 "e.g: -vf-add flip,mirror -vf-del 2,5\n",
653 M_OPT_TYPE_DYNAMIC
| M_OPT_TYPE_ALLOW_WILDCARD
,
663 /////////////////// Func based options
665 // A chained list to save the various calls for func_param and func_full
666 typedef struct m_func_save m_func_save_t
;
674 #define VAL(x) (*(m_func_save_t**)(x))
676 static void free_func_pf(void* src
) {
686 if(s
->param
) free(s
->param
);
693 // Parser for func_param and func_full
694 static int parse_func_pf(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
700 s
= (m_func_save_t
*)calloc(1,sizeof(m_func_save_t
));
701 s
->name
= strdup(name
);
702 s
->param
= param
? strdup(param
) : NULL
;
706 for( ; p
->next
!= NULL
; p
= p
->next
)
715 static void copy_func_pf(m_option_t
* opt
,void* dst
, void* src
) {
716 m_func_save_t
*d
= NULL
, *s
,* last
= NULL
;
718 if(!(dst
&& src
)) return;
725 d
= (m_func_save_t
*)malloc(sizeof(m_func_save_t
));
726 d
->name
= strdup(s
->name
);
727 d
->param
= s
->param
? strdup(s
->param
) : NULL
;
739 /////////////////// Func_param
741 static void set_func_param(m_option_t
* opt
, void* dst
, void* src
) {
750 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,opt
->name
);
751 for( ; s
!= NULL
; s
= s
->next
)
752 ((m_opt_func_param_t
) opt
->p
)(opt
,s
->param
);
755 m_option_type_t m_option_type_func_param
= {
758 sizeof(m_func_save_t
*),
762 NULL
, // Nothing to do on save
768 /////////////////// Func_full
770 static void set_func_full(m_option_t
* opt
, void* dst
, void* src
) {
775 for(s
= VAL(src
) ; s
; s
= s
->next
) {
777 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,s
->name
);
778 ((m_opt_func_full_t
) opt
->p
)(opt
,s
->name
,s
->param
);
782 m_option_type_t m_option_type_func_full
= {
785 sizeof(m_func_save_t
*),
786 M_OPT_TYPE_ALLOW_WILDCARD
|M_OPT_TYPE_INDIRECT
,
789 NULL
, // Nothing to do on save
798 #define VAL(x) (*(int*)(x))
800 static int parse_func(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
806 static void set_func(m_option_t
* opt
,void* dst
, void* src
) {
808 if(opt
->priv
) ((m_opt_default_func_t
)opt
->priv
)(opt
,opt
->name
);
809 for(i
= 0 ; i
< VAL(src
) ; i
++)
810 ((m_opt_func_t
) opt
->p
)(opt
);
813 m_option_type_t m_option_type_func
= {
820 NULL
, // Nothing to do on save
826 /////////////////// Print
828 static int parse_print(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
829 if(opt
->type
->flags
&M_OPT_TYPE_INDIRECT
)
830 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "%s", *(char **) opt
->p
);
832 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "%s", (char *) opt
->p
);
834 if(opt
->priv
== NULL
)
839 m_option_type_t m_option_type_print
= {
852 m_option_type_t m_option_type_print_indirect
= {
866 /////////////////////// Subconfig
868 #define VAL(x) (*(char***)(x))
870 static int parse_subconf(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
879 if (param
== NULL
|| strlen(param
) == 0)
880 return M_OPT_MISSING_PARAM
;
882 subparam
= malloc(strlen(param
)+1);
883 subopt
= malloc(strlen(param
)+1);
884 p
= strdup(param
); // In case that param is a static string (cf man strtok)
888 token
= strtok(p
, (char *)&(":"));
893 subopt
[0] = subparam
[0] = 0;
895 sscanf_ret
= sscanf(token
, "%[^=]=%[^:]", subopt
, subparam
);
897 mp_msg(MSGT_CFGPARSER
, MSGL_DBG3
, "token: '%s', subopt='%s', subparam='%s' (ret: %d)\n", token
, subopt
, subparam
, sscanf_ret
);
903 for(i
= 0 ; subopts
[i
].name
; i
++) {
904 if(!strcmp(subopts
[i
].name
,subopt
)) break;
906 if(!subopts
[i
].name
) {
907 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Unknown suboption %s\n",name
,subopt
);
908 return M_OPT_UNKNOWN
;
910 r
= m_option_parse(&subopts
[i
],subopt
,
911 subparam
[0] == 0 ? NULL
: subparam
,NULL
,src
);
914 lst
= (char**)realloc(lst
,2 * (nr
+2) * sizeof(char*));
915 lst
[2*nr
] = strdup(subopt
);
916 lst
[2*nr
+1] = subparam
[0] == 0 ? NULL
: strdup(subparam
);
917 memset(&lst
[2*(nr
+1)],0,2*sizeof(char*));
922 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Invalid subconfig argument! ('%s')\n", token
);
923 return M_OPT_INVALID
;
925 token
= strtok(NULL
, (char *)&(":"));
937 m_option_type_t m_option_type_subconfig
= {
939 "The syntax is -option opt1=foo:flag:opt2=blah",
941 M_OPT_TYPE_HAS_CHILD
,
950 #include "libmpcodecs/img_format.h"
952 /* FIXME: snyc with img_format.h */
956 } mp_imgfmt_list
[] = {
957 {"444p", IMGFMT_444P
},
958 {"422p", IMGFMT_422P
},
959 {"411p", IMGFMT_411P
},
960 {"yuy2", IMGFMT_YUY2
},
961 {"uyvy", IMGFMT_UYVY
},
962 {"yvu9", IMGFMT_YVU9
},
963 {"if09", IMGFMT_IF09
},
964 {"yv12", IMGFMT_YV12
},
965 {"i420", IMGFMT_I420
},
966 {"iyuv", IMGFMT_IYUV
},
967 {"clpl", IMGFMT_CLPL
},
968 {"hm12", IMGFMT_HM12
},
969 {"y800", IMGFMT_Y800
},
971 {"nv12", IMGFMT_NV12
},
972 {"nv21", IMGFMT_NV21
},
973 {"bgr24", IMGFMT_BGR24
},
974 {"bgr32", IMGFMT_BGR32
},
975 {"bgr16", IMGFMT_BGR16
},
976 {"bgr15", IMGFMT_BGR15
},
977 {"bgr8", IMGFMT_BGR8
},
978 {"bgr4", IMGFMT_BGR4
},
979 {"bg4b", IMGFMT_BG4B
},
980 {"bgr1", IMGFMT_BGR1
},
981 {"rgb24", IMGFMT_RGB24
},
982 {"rgb32", IMGFMT_RGB32
},
983 {"rgb16", IMGFMT_RGB16
},
984 {"rgb15", IMGFMT_RGB15
},
985 {"rgb8", IMGFMT_RGB8
},
986 {"rgb4", IMGFMT_RGB4
},
987 {"rg4b", IMGFMT_RG4B
},
988 {"rgb1", IMGFMT_RGB1
},
989 {"rgba", IMGFMT_RGBA
},
990 {"argb", IMGFMT_ARGB
},
991 {"bgra", IMGFMT_BGRA
},
992 {"abgr", IMGFMT_ABGR
},
996 static int parse_imgfmt(m_option_t
* opt
,char *name
, char *param
, void* dst
, int src
) {
1000 if (param
== NULL
|| strlen(param
) == 0)
1001 return M_OPT_MISSING_PARAM
;
1003 if(!strcmp(param
,"help")) {
1004 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Available formats:");
1005 for(i
= 0 ; mp_imgfmt_list
[i
].name
; i
++)
1006 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, " %s",mp_imgfmt_list
[i
].name
);
1007 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "\n");
1011 if (sscanf(param
, "0x%x", &fmt
) != 1)
1013 for(i
= 0 ; mp_imgfmt_list
[i
].name
; i
++) {
1014 if(!strcasecmp(param
,mp_imgfmt_list
[i
].name
)) {
1015 fmt
=mp_imgfmt_list
[i
].fmt
;
1019 if(!mp_imgfmt_list
[i
].name
) {
1020 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: unknown format name: '%s'\n",name
,param
);
1021 return M_OPT_INVALID
;
1026 *((uint32_t*)dst
) = fmt
;
1031 m_option_type_t m_option_type_imgfmt
= {
1033 "Please report any missing colorspaces.",
1044 //// Objects (i.e. filters, etc) settings
1046 #include "m_struct.h"
1049 #define VAL(x) (*(m_obj_settings_t**)(x))
1051 static int find_obj_desc(char* name
,m_obj_list_t
* l
,m_struct_t
** ret
) {
1055 for(i
= 0 ; l
->list
[i
] ; i
++) {
1056 n
= M_ST_MB(char*,l
->list
[i
],l
->name_off
);
1057 if(!strcmp(n
,name
)) {
1058 *ret
= M_ST_MB(m_struct_t
*,l
->list
[i
],l
->desc_off
);
1065 static int get_obj_param(char* opt_name
,char* obj_name
, m_struct_t
* desc
,
1066 char* str
,int* nold
,int oldmax
,char** dst
) {
1071 eq
= strchr(str
,'=');
1077 if(p
[0] == '\0') p
= NULL
;
1079 opt
= m_option_list_find(desc
->fields
,str
);
1081 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s doesn't have a %s parameter.\n",opt_name
,obj_name
,str
);
1082 return M_OPT_UNKNOWN
;
1084 r
= m_option_parse(opt
,str
,p
,NULL
,M_CONFIG_FILE
);
1086 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name
,obj_name
,str
,p
);
1091 dst
[0] = strdup(str
);
1092 dst
[1] = p
? strdup(p
) : NULL
;
1096 if((*nold
) >= oldmax
) {
1097 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
1098 opt_name
,obj_name
,oldmax
,oldmax
);
1099 return M_OPT_OUT_OF_RANGE
;
1101 opt
= &desc
->fields
[(*nold
)];
1102 r
= m_option_parse(opt
,opt
->name
,str
,NULL
,M_CONFIG_FILE
);
1104 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name
,obj_name
,opt
->name
,str
);
1108 dst
[0] = strdup(opt
->name
);
1109 dst
[1] = strdup(str
);
1116 static int get_obj_params(char* opt_name
, char* name
,char* params
,
1117 m_struct_t
* desc
,char separator
, char*** _ret
) {
1118 int n
= 0,nold
= 0, nopts
,r
;
1119 char* ptr
,*last_ptr
= params
,*eq
;
1122 if(!strcmp(params
,"help")) { // Help
1123 char min
[50],max
[50];
1125 printf("%s doesn't have any options.\n\n",name
);
1128 printf("\n Name Type Min Max\n\n");
1129 for(n
= 0 ; desc
->fields
[n
].name
; n
++) {
1130 m_option_t
* opt
= &desc
->fields
[n
];
1131 if(opt
->type
->flags
& M_OPT_TYPE_HAS_CHILD
) continue;
1132 if(opt
->flags
& M_OPT_MIN
)
1133 sprintf(min
,"%-8.0f",opt
->min
);
1136 if(opt
->flags
& M_OPT_MAX
)
1137 sprintf(max
,"%-8.0f",opt
->max
);
1140 printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
1150 for(nopts
= 0 ; desc
->fields
[nopts
].name
; nopts
++)
1153 // TODO : Check that each opt can be parsed
1155 while(last_ptr
&& last_ptr
[0] != '\0') {
1156 ptr
= strchr(last_ptr
,separator
);
1158 r
= get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,NULL
);
1162 if(ptr
== last_ptr
) { // Empty field, count it and go on
1168 r
= get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,NULL
);
1175 if(!_ret
) // Just test
1178 ret
= malloc((n
+2)*2*sizeof(char*));
1182 while(last_ptr
&& last_ptr
[0] != '\0') {
1183 ptr
= strchr(last_ptr
,separator
);
1185 get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,&ret
[n
*2]);
1189 if(ptr
== last_ptr
) { // Empty field, count it and go on
1195 get_obj_param(opt_name
,name
,desc
,last_ptr
,&nold
,nopts
,&ret
[n
*2]);
1199 ret
[n
*2] = ret
[n
*2+1] = NULL
;
1205 static int parse_obj_params(m_option_t
* opt
,char *name
,
1206 char *param
, void* dst
, int src
) {
1209 m_obj_params_t
* p
= opt
->priv
;
1210 m_struct_t
* desc
= p
->desc
;
1211 char* cpy
= strdup(param
);
1213 // We need the object desc
1215 return M_OPT_INVALID
;
1217 r
= get_obj_params(name
,desc
->name
,cpy
,desc
,p
->separator
,&opts
);
1224 for(r
= 0 ; opts
[r
] ; r
+= 2)
1225 m_struct_set(desc
,dst
,opts
[r
],opts
[r
+1]);
1231 m_option_type_t m_option_type_obj_params
= {
1244 /// Some predefined types as a definition would be quite lengthy
1247 static m_span_t m_span_params_dflts
= { -1, -1 };
1248 static m_option_t m_span_params_fields
[] = {
1249 {"start", M_ST_OFF(m_span_t
,start
), CONF_TYPE_INT
, M_OPT_MIN
, 1 ,0, NULL
},
1250 {"end", M_ST_OFF(m_span_t
,end
), CONF_TYPE_INT
, M_OPT_MIN
, 1 ,0, NULL
},
1251 { NULL
, NULL
, 0, 0, 0, 0, NULL
}
1253 static struct m_struct_st m_span_opts
= {
1256 &m_span_params_dflts
,
1257 m_span_params_fields
1259 m_obj_params_t m_span_params_def
= {
1264 static int parse_obj_settings(char* opt
,char* str
,m_obj_list_t
* list
,
1265 m_obj_settings_t
**_ret
, int ret_n
) {
1267 char *param
,**plist
= NULL
;
1269 m_obj_settings_t
*ret
= _ret
? *_ret
: NULL
;
1272 // Now check that the object exists
1273 param
= strchr(str
,'=');
1277 if(strlen(param
) <= 0)
1282 if(!find_obj_desc(str
,list
,&desc
)) {
1283 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: %s doesn't exist.\n",opt
,str
);
1284 return M_OPT_INVALID
;
1289 plist
= calloc(4,sizeof(char*));
1290 plist
[0] = strdup("_oldargs_");
1291 plist
[1] = strdup(param
);
1293 r
= get_obj_params(opt
,str
,param
,desc
,':',_ret
? &plist
: NULL
);
1301 ret
= realloc(ret
,(ret_n
+2)*sizeof(m_obj_settings_t
));
1302 memset(&ret
[ret_n
],0,2*sizeof(m_obj_settings_t
));
1303 ret
[ret_n
].name
= strdup(str
);
1304 ret
[ret_n
].attribs
= plist
;
1310 static void free_obj_settings_list(void* dst
);
1312 static int obj_settings_list_del(char *opt_name
,char *param
,void* dst
, int src
) {
1313 char** str_list
= NULL
;
1314 int r
,i
,idx_max
= 0;
1315 char* rem_id
= "_removed_marker_";
1316 m_option_t list_opt
= {opt_name
, NULL
, CONF_TYPE_STRING_LIST
,
1318 m_obj_settings_t
* obj_list
= dst
? VAL(dst
) : NULL
;
1320 if(dst
&& !obj_list
) {
1321 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: the list is empty.\n",opt_name
);
1323 } else if(obj_list
) {
1324 for(idx_max
= 0 ; obj_list
[idx_max
].name
!= NULL
; idx_max
++)
1328 r
= m_option_parse(&list_opt
,opt_name
,param
,&str_list
,src
);
1329 if(r
< 0 || !str_list
)
1332 for(r
= 0 ; str_list
[r
] ; r
++) {
1335 id
= strtol(str_list
[r
],&endptr
,0);
1336 if(endptr
== str_list
[r
]) {
1337 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
);
1338 m_option_free(&list_opt
,&str_list
);
1339 return M_OPT_INVALID
;
1341 if(!obj_list
) continue;
1342 if(id
>= idx_max
|| id
< -idx_max
) {
1343 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: Index %d is out of range.\n",opt_name
,id
);
1348 free(obj_list
[id
].name
);
1349 free_str_list(&(obj_list
[id
].attribs
));
1350 obj_list
[id
].name
= rem_id
;
1354 m_option_free(&list_opt
,&str_list
);
1358 for(i
= 0 ; obj_list
[i
].name
; i
++) {
1359 while(obj_list
[i
].name
== rem_id
) {
1360 memmove(&obj_list
[i
],&obj_list
[i
+1],sizeof(m_obj_settings_t
)*(idx_max
- i
));
1364 obj_list
= realloc(obj_list
,sizeof(m_obj_settings_t
)*(idx_max
+1));
1365 VAL(dst
) = obj_list
;
1370 static int parse_obj_settings_list(m_option_t
* opt
,char *name
,
1371 char *param
, void* dst
, int src
) {
1372 int n
= 0,r
,len
= strlen(opt
->name
);
1374 char *ptr
, *last_ptr
;
1375 m_obj_settings_t
*res
= NULL
,*queue
= NULL
,*head
= NULL
;
1378 // We need the objects list
1380 return M_OPT_INVALID
;
1382 if(opt
->name
[len
-1] == '*' && ((int)strlen(name
) > len
- 1)) {
1383 char* n
= &name
[len
-1];
1384 if(strcasecmp(n
,"-add") == 0)
1386 else if(strcasecmp(n
,"-pre") == 0)
1388 else if(strcasecmp(n
,"-del") == 0)
1390 else if(strcasecmp(n
,"-clr") == 0)
1394 strncpy(prefix
,opt
->name
,len
-1);
1395 prefix
[len
-1] = '\0';
1396 mp_msg(MSGT_VFILTER
,MSGL_ERR
, "Option %s: unknown postfix %s\n"
1397 "Supported postfixes are:\n"
1399 " Append the given list to the current list\n\n"
1401 " Prepend the given list to the current list\n\n"
1403 " Remove the given elements. Take the list element index (starting from 0).\n"
1404 " Negative index can be used (i.e. -1 is the last element)\n\n"
1406 " Clear the current list.\n",name
,n
,prefix
,prefix
,prefix
,prefix
);
1408 return M_OPT_UNKNOWN
;
1412 // Clear the list ??
1415 free_obj_settings_list(dst
);
1419 if (param
== NULL
|| strlen(param
) == 0)
1420 return M_OPT_MISSING_PARAM
;
1424 if(dst
) head
= VAL(dst
);
1427 if(dst
) queue
= VAL(dst
);
1430 return obj_settings_list_del(name
,param
,dst
,src
);
1433 free_obj_settings_list(dst
);
1436 mp_msg(MSGT_VFILTER
,MSGL_ERR
, "Option %s: FIXME\n",name
);
1437 return M_OPT_UNKNOWN
;
1440 if(!strcmp(param
,"help")) {
1441 m_obj_list_t
* ol
= opt
->priv
;
1442 for(n
= 0 ; ol
->list
[n
] ; n
++)
1443 mp_msg(MSGT_VFILTER
,MSGL_INFO
," %-15s: %s\n",
1444 M_ST_MB(char*,ol
->list
[n
],ol
->name_off
),
1445 M_ST_MB(char*,ol
->list
[n
],ol
->info_off
));
1448 ptr
= str
= strdup(param
);
1450 while(ptr
[0] != '\0') {
1452 ptr
= strchr(ptr
,LIST_SEPARATOR
);
1454 r
= parse_obj_settings(name
,last_ptr
,opt
->priv
,dst
? &res
: NULL
,n
);
1463 r
= parse_obj_settings(name
,last_ptr
,opt
->priv
,dst
? &res
: NULL
,n
);
1473 return M_OPT_INVALID
;
1475 if( ((opt
->flags
& M_OPT_MIN
) && (n
< opt
->min
)) ||
1476 ((opt
->flags
& M_OPT_MAX
) && (n
> opt
->max
)) )
1477 return M_OPT_OUT_OF_RANGE
;
1482 for(qsize
= 0 ; queue
[qsize
].name
; qsize
++)
1484 res
= realloc(res
,(qsize
+n
+1)*sizeof(m_obj_settings_t
));
1485 memcpy(&res
[n
],queue
,(qsize
+1)*sizeof(m_obj_settings_t
));
1491 for(hsize
= 0 ; head
[hsize
].name
; hsize
++)
1493 head
= realloc(head
,(hsize
+n
+1)*sizeof(m_obj_settings_t
));
1494 memcpy(&head
[hsize
],res
,(n
+1)*sizeof(m_obj_settings_t
));
1503 static void free_obj_settings_list(void* dst
) {
1505 m_obj_settings_t
*d
;
1507 if(!dst
|| !VAL(dst
)) return;
1511 for(n
= 0 ; d
[n
].name
; n
++) {
1513 free_str_list(&(d
[n
].attribs
));
1520 static void copy_obj_settings_list(m_option_t
* opt
,void* dst
, void* src
) {
1521 m_obj_settings_t
*d
,*s
;
1530 free_obj_settings_list(dst
);
1535 for(n
= 0 ; s
[n
].name
; n
++)
1537 d
= malloc((n
+1)*sizeof(m_obj_settings_t
));
1538 for(n
= 0 ; s
[n
].name
; n
++) {
1539 d
[n
].name
= strdup(s
[n
].name
);
1540 d
[n
].attribs
= NULL
;
1541 copy_str_list(NULL
,&(d
[n
].attribs
),&(s
[n
].attribs
));
1544 d
[n
].attribs
= NULL
;
1548 m_option_type_t m_option_type_obj_settings_list
= {
1549 "Object settings list",
1551 sizeof(m_obj_settings_t
*),
1552 M_OPT_TYPE_DYNAMIC
|M_OPT_TYPE_ALLOW_WILDCARD
,
1553 parse_obj_settings_list
,
1555 copy_obj_settings_list
,
1556 copy_obj_settings_list
,
1557 copy_obj_settings_list
,
1558 free_obj_settings_list
,
1563 static int parse_obj_presets(m_option_t
* opt
,char *name
,
1564 char *param
, void* dst
, int src
) {
1565 m_obj_presets_t
* obj_p
= (m_obj_presets_t
*)opt
->priv
;
1566 m_struct_t
*in_desc
,*out_desc
;
1568 unsigned char* pre
= obj_p
->presets
;
1569 char* pre_name
= NULL
;
1572 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Presets need a pointer to a m_obj_presets_t in the priv field.\n",name
);
1573 return M_OPT_PARSER_ERR
;
1577 return M_OPT_MISSING_PARAM
;
1579 in_desc
= obj_p
->in_desc
;
1580 out_desc
= obj_p
->out_desc
? obj_p
->out_desc
: obj_p
->in_desc
;
1583 if(!strcmp(param
,"help")) {
1584 mp_msg(MSGT_CFGPARSER
, MSGL_INFO
, "Available presets for %s->%s:",out_desc
->name
,name
);
1585 for(pre
= obj_p
->presets
;(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) ;
1587 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, " %s",pre_name
);
1588 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "\n");
1592 for(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
) ; pre_name
;
1593 pre
+= s
, pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) {
1594 if(!strcmp(pre_name
,param
)) break;
1597 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: There is no preset named %s\n"
1598 "Available presets are:",name
,param
);
1599 for(pre
= obj_p
->presets
;(pre_name
= M_ST_MB(char*,pre
,obj_p
->name_off
)) ;
1601 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, " %s",pre_name
);
1602 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "\n");
1603 return M_OPT_INVALID
;
1608 for(i
= 0 ; in_desc
->fields
[i
].name
; i
++) {
1609 m_option_t
* out_opt
= m_option_list_find(out_desc
->fields
,
1610 in_desc
->fields
[i
].name
);
1612 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
);
1613 return M_OPT_PARSER_ERR
;
1615 m_option_copy(out_opt
,M_ST_MB_P(dst
,out_opt
->p
),M_ST_MB_P(pre
,in_desc
->fields
[i
].p
));
1621 m_option_type_t m_option_type_obj_presets
= {
1634 static int parse_custom_url(m_option_t
* opt
,char *name
,
1635 char *url
, void* dst
, int src
) {
1636 int pos1
, pos2
, r
, v6addr
= 0;
1637 char *ptr1
=NULL
, *ptr2
=NULL
, *ptr3
=NULL
, *ptr4
=NULL
;
1638 m_struct_t
* desc
= opt
->priv
;
1641 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Custom URL needs a pointer to a m_struct_t in the priv field.\n",name
);
1642 return M_OPT_PARSER_ERR
;
1645 // extract the protocol
1646 ptr1
= strstr(url
, "://");
1649 if(m_option_list_find(desc
->fields
,"filename")) {
1650 m_struct_set(desc
,dst
,"filename",url
);
1653 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
,"Option %s: URL doesn't have a valid protocol!\n",name
);
1654 return M_OPT_INVALID
;
1657 if(dst
&& m_option_list_find(desc
->fields
,"protocol")) {
1659 r
= m_struct_set(desc
,dst
,"protocol",url
);
1662 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting protocol.\n",name
);
1671 // check if a username:password is given
1672 ptr2
= strstr(ptr1
, "@");
1673 ptr3
= strstr(ptr1
, "/");
1674 if( ptr3
!=NULL
&& ptr3
<ptr2
) {
1675 // it isn't really a username but rather a part of the path
1680 // We got something, at least a username...
1681 int len
= ptr2
-ptr1
;
1682 if(!m_option_list_find(desc
->fields
,"username")) {
1683 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a username part.\n",name
);
1686 ptr3
= strstr(ptr1
, ":");
1687 if( ptr3
!=NULL
&& ptr3
<ptr2
) {
1688 // We also have a password
1689 int len2
= ptr2
-ptr3
-1;
1690 if(!m_option_list_find(desc
->fields
,"password")) {
1691 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a password part.\n",name
);
1693 } else { // Username and password
1696 r
= m_struct_set(desc
,dst
,"username",ptr1
);
1699 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting username.\n",name
);
1703 r
= m_struct_set(desc
,dst
,"password",ptr3
+1);
1706 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting password.\n",name
);
1711 } else { // User name only
1713 r
= m_struct_set(desc
,dst
,"username",ptr1
);
1716 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting username.\n",name
);
1725 // before looking for a port number check if we have an IPv6 type numeric address
1726 // in an IPv6 URL the numeric address should be inside square braces.
1727 ptr2
= strstr(ptr1
, "[");
1728 ptr3
= strstr(ptr1
, "]");
1729 // If the [] is after the first it isn't the hostname
1730 ptr4
= strstr(ptr1
, "/");
1731 if( ptr2
!=NULL
&& ptr3
!=NULL
&& (ptr2
< ptr3
) && (!ptr4
|| ptr4
> ptr3
)) {
1732 // we have an IPv6 numeric address
1741 // look if the port is given
1742 ptr2
= strstr(ptr2
, ":");
1743 // If the : is after the first / it isn't the port
1744 ptr3
= strstr(ptr1
, "/");
1745 if(ptr3
&& ptr3
- ptr2
< 0) ptr2
= NULL
;
1748 // Look if a path is given
1751 // So we have an URL like http://www.hostname.com
1754 // We have an URL like http://www.hostname.com/file.txt
1758 // We have an URL beginning like http://www.hostname.com:1212
1759 // Get the port number
1760 if(!m_option_list_find(desc
->fields
,"port")) {
1761 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a port part.\n",name
);
1765 int p
= atoi(ptr2
+1);
1767 snprintf(tmp
,99,"%d",p
);
1768 r
= m_struct_set(desc
,dst
,"port",tmp
);
1770 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting port.\n",name
);
1777 if( v6addr
) pos2
--;
1780 if(!m_option_list_find(desc
->fields
,"hostname")) {
1781 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a hostname part.\n",name
);
1784 char tmp
[pos2
-pos1
+1];
1785 strncpy(tmp
,ptr1
, pos2
-pos1
);
1786 tmp
[pos2
-pos1
] = '\0';
1787 r
= m_struct_set(desc
,dst
,"hostname",tmp
);
1789 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting hostname.\n",name
);
1794 // Look if a path is given
1795 ptr2
= strstr(ptr1
, "/");
1797 // A path/filename is given
1798 // check if it's not a trailing '/'
1799 if( strlen(ptr2
)>1 ) {
1800 // copy the path/filename in the URL container
1801 if(!m_option_list_find(desc
->fields
,"filename")) {
1802 mp_msg(MSGT_CFGPARSER
, MSGL_WARN
, "Option %s: This URL doesn't have a hostname part.\n",name
);
1806 int l
= strlen(ptr2
+1) + 1;
1807 char* fname
= ptr2
+1;
1810 url_unescape_string(fname
,ptr2
+1);
1812 r
= m_struct_set(desc
,dst
,"filename",fname
);
1816 mp_msg(MSGT_CFGPARSER
, MSGL_ERR
, "Option %s: Error while setting filename.\n",name
);
1826 /// TODO : Write the other needed funcs for 'normal' options
1827 m_option_type_t m_option_type_custom_url
= {