?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
10l: comparison of char* ptrs with string literals
[mplayer.git] / m_option.c
blobca60174f693fbff4d9b427ba38fe1965bca1de89
1
2 /// \file
3 /// \ingroup Options
4
5 #include "config.h"
6
7 #include <stdlib.h>
8 #include <string.h>
9 #include <math.h>
10 #include <stdio.h>
11 #include <stdarg.h>
12 #include <inttypes.h>
13 #include <unistd.h>
14
15 #include "m_option.h"
16 //#include "m_config.h"
17 #include "mp_msg.h"
18 #include "stream/url.h"
19
20 // Don't free for 'production' atm
21 #ifndef MP_DEBUG
22 //#define NO_FREE
23 #endif
24
25 m_option_t* m_option_list_find(m_option_t* list,const char* name) {
26 int i;
27
28 for(i = 0 ; list[i].name ; i++) {
29 int l = strlen(list[i].name) - 1;
30 if((list[i].type->flags & M_OPT_TYPE_ALLOW_WILDCARD) &&
31 (l > 0) && (list[i].name[l] == '*')) {
32 if(strncasecmp(list[i].name,name,l) == 0)
33 return &list[i];
34 } else if(strcasecmp(list[i].name,name) == 0)
35 return &list[i];
36 }
37 return NULL;
38 }
39
40 // Default function that just does a memcpy
41
42 static void copy_opt(m_option_t* opt,void* dst,void* src) {
43 if(dst && src)
44 memcpy(dst,src,opt->type->size);
45 }
46
47 // Helper for the print funcs (from man printf)
48 static char* dup_printf(const char *fmt, ...) {
49 /* Guess we need no more than 50 bytes. */
50 int n, size = 50;
51 char *p;
52 va_list ap;
53 if ((p = malloc (size)) == NULL)
54 return NULL;
55 while (1) {
56 /* Try to print in the allocated space. */
57 va_start(ap, fmt);
58 n = vsnprintf (p, size, fmt, ap);
59 va_end(ap);
60 /* If that worked, return the string. */
61 if (n > -1 && n < size)
62 return p;
63 /* Else try again with more space. */
64 if (n > -1) /* glibc 2.1 */
65 size = n+1; /* precisely what is needed */
66 else /* glibc 2.0 */
67 size *= 2; /* twice the old size */
68 if ((p = realloc (p, size)) == NULL)
69 return NULL;
70 }
71 }
72
73
74 // Flag
75
76 #define VAL(x) (*(int*)(x))
77
78 static int parse_flag(m_option_t* opt,char *name, char *param, void* dst, int src) {
79 if (src == M_CONFIG_FILE) {
80 if(!param) return M_OPT_MISSING_PARAM;
81 if (!strcasecmp(param, "yes") || /* any other language? */
82 !strcasecmp(param, "on") ||
83 !strcasecmp(param, "ja") ||
84 !strcasecmp(param, "si") ||
85 !strcasecmp(param, "igen") ||
86 !strcasecmp(param, "y") ||
87 !strcasecmp(param, "j") ||
88 !strcasecmp(param, "i") ||
89 !strcasecmp(param, "tak") ||
90 !strcasecmp(param, "ja") ||
91 !strcasecmp(param, "true") ||
92 !strcmp(param, "1")) {
93 if(dst) VAL(dst) = opt->max;
94 } else if (!strcasecmp(param, "no") ||
95 !strcasecmp(param, "off") ||
96 !strcasecmp(param, "nein") ||
97 !strcasecmp(param, "nicht") ||
98 !strcasecmp(param, "nem") ||
99 !strcasecmp(param, "n") ||
100 !strcasecmp(param, "nie") ||
101 !strcasecmp(param, "nej") ||
102 !strcasecmp(param, "false") ||
103 !strcmp(param, "0")) {
104 if(dst) VAL(dst) = opt->min;
105 } else {
106 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid parameter for %s flag: %s\n",name, param);
107 return M_OPT_INVALID;
108 }
109 return 1;
110 } else {
111 if(dst) VAL(dst) = opt->max;
112 return 0;
113 }
114 }
115
116 static char* print_flag(m_option_t* opt, void* val) {
117 if(VAL(val) == opt->min)
118 return strdup("no");
119 else
120 return strdup("yes");
121 }
122
123 m_option_type_t m_option_type_flag = {
124 "Flag",
125 "need yes or no in config files",
126 sizeof(int),
127 0,
128 parse_flag,
129 print_flag,
130 copy_opt,
131 copy_opt,
132 NULL,
133 NULL
134 };
135
136 // Integer
137
138 static int parse_int(m_option_t* opt,char *name, char *param, void* dst, int src) {
139 long tmp_int;
140 char *endptr;
141 src = 0;
142
143 if (param == NULL)
144 return M_OPT_MISSING_PARAM;
145
146 tmp_int = strtol(param, &endptr, 10);
147 if (*endptr)
148 tmp_int = strtol(param, &endptr, 0);
149 if (*endptr) {
150 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be an integer: %s\n",name, param);
151 return M_OPT_INVALID;
152 }
153
154 if ((opt->flags & M_OPT_MIN) && (tmp_int < opt->min)) {
155 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be >= %d: %s\n", name, (int) opt->min, param);
156 return M_OPT_OUT_OF_RANGE;
157 }
158
159 if ((opt->flags & M_OPT_MAX) && (tmp_int > opt->max)) {
160 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be <= %d: %s\n",name, (int) opt->max, param);
161 return M_OPT_OUT_OF_RANGE;
162 }
163
164 if(dst) VAL(dst) = tmp_int;
165
166 return 1;
167 }
168
169 static char* print_int(m_option_t* opt, void* val) {
170 opt = NULL;
171 return dup_printf("%d",VAL(val));
172 }
173
174 m_option_type_t m_option_type_int = {
175 "Integer",
176 "",
177 sizeof(int),
178 0,
179 parse_int,
180 print_int,
181 copy_opt,
182 copy_opt,
183 NULL,
184 NULL
185 };
186
187 // Float
188
189 #undef VAL
190 #define VAL(x) (*(double*)(x))
191
192 static int parse_double(m_option_t* opt,char *name, char *param, void* dst, int src) {
193 double tmp_float;
194 char* endptr;
195 src = 0;
196
197 if (param == NULL)
198 return M_OPT_MISSING_PARAM;
199
200 tmp_float = strtod(param, &endptr);
201
202 switch(*endptr) {
203 case ':':
204 case '/':
205 tmp_float /= strtod(endptr+1, &endptr);
206 break;
207 case '.':
208 case ',':
209 /* we also handle floats specified with
210 * non-locale decimal point ::atmos
211 */
212 if(tmp_float<0)
213 tmp_float -= 1.0/pow(10,strlen(endptr+1)) * strtod(endptr+1, &endptr);
214 else
215 tmp_float += 1.0/pow(10,strlen(endptr+1)) * strtod(endptr+1, &endptr);
216 break;
217 }
218
219 if (*endptr) {
220 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be a floating point "
221 "number or a ratio (numerator[:/]denominator): %s\n",name, param);
222 return M_OPT_INVALID;
223 }
224
225 if (opt->flags & M_OPT_MIN)
226 if (tmp_float < opt->min) {
227 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be >= %f: %s\n", name, opt->min, param);
228 return M_OPT_OUT_OF_RANGE;
229 }
230
231 if (opt->flags & M_OPT_MAX)
232 if (tmp_float > opt->max) {
233 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be <= %f: %s\n", name, opt->max, param);
234 return M_OPT_OUT_OF_RANGE;
235 }
236
237 if(dst) VAL(dst) = tmp_float;
238 return 1;
239 }
240
241 static char* print_double(m_option_t* opt, void* val) {
242 opt = NULL;
243 return dup_printf("%f",VAL(val));
244 }
245
246 m_option_type_t m_option_type_double = {
247 "Double",
248 "double precission floating point number or ratio (numerator[:/]denominator)",
249 sizeof(double),
250 0,
251 parse_double,
252 print_double,
253 copy_opt,
254 copy_opt,
255 NULL,
256 NULL
257 };
258
259 #undef VAL
260 #define VAL(x) (*(float*)(x))
261
262 static int parse_float(m_option_t* opt,char *name, char *param, void* dst, int src) {
263 double tmp;
264 int r= parse_double(opt, name, param, &tmp, src);
265 if(r==1 && dst) VAL(dst) = tmp;
266 return r;
267 }
268
269 static char* print_float(m_option_t* opt, void* val) {
270 opt = NULL;
271 return dup_printf("%f",VAL(val));
272 }
273
274 m_option_type_t m_option_type_float = {
275 "Float",
276 "floating point number or ratio (numerator[:/]denominator)",
277 sizeof(float),
278 0,
279 parse_float,
280 print_float,
281 copy_opt,
282 copy_opt,
283 NULL,
284 NULL
285 };
286
287 ///////////// Position
288 #undef VAL
289 #define VAL(x) (*(off_t*)(x))
290
291 static int parse_position(m_option_t* opt,char *name, char *param, void* dst, int src) {
292 off_t tmp_off;
293 char dummy;
294
295 if (param == NULL)
296 return M_OPT_MISSING_PARAM;
297 if (sscanf(param, sizeof(off_t) == sizeof(int) ?
298 "%d%c" : "%"PRId64"%c", &tmp_off, &dummy) != 1) {
299 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "The %s option must be an integer: %s\n",opt->name,param);
300 return M_OPT_INVALID;
301 }
302
303 if (opt->flags & M_OPT_MIN)
304 if (tmp_off < opt->min) {
305 mp_msg(MSGT_CFGPARSER, MSGL_ERR,
306 "The %s option must be >= %"PRId64": %s\n",
307 name, (int64_t) opt->min, param);
308 return M_OPT_OUT_OF_RANGE;
309 }
310
311 if (opt->flags & M_OPT_MAX)
312 if (tmp_off > opt->max) {
313 mp_msg(MSGT_CFGPARSER, MSGL_ERR,
314 "The %s option must be <= %"PRId64": %s\n",
315 name, (int64_t) opt->max, param);
316 return M_OPT_OUT_OF_RANGE;
317 }
318
319 if(dst)
320 VAL(dst) = tmp_off;
321 return 1;
322 }
323
324 static char* print_position(m_option_t* opt, void* val) {
325 return dup_printf("%"PRId64,(int64_t)VAL(val));
326 }
327
328 m_option_type_t m_option_type_position = {
329 "Position",
330 "Integer (off_t)",
331 sizeof(off_t),
332 0,
333 parse_position,
334 print_position,
335 copy_opt,
336 copy_opt,
337 NULL,
338 NULL
339 };
340
341
342 ///////////// String
343
344 #undef VAL
345 #define VAL(x) (*(char**)(x))
346
347 static int parse_str(m_option_t* opt,char *name, char *param, void* dst, int src) {
348
349
350 if (param == NULL)
351 return M_OPT_MISSING_PARAM;
352
353 if ((opt->flags & M_OPT_MIN) && (strlen(param) < opt->min)) {
354 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Parameter must be >= %d chars: %s\n",
355 (int) opt->min, param);
356 return M_OPT_OUT_OF_RANGE;
357 }
358
359 if ((opt->flags & M_OPT_MAX) && (strlen(param) > opt->max)) {
360 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Parameter must be <= %d chars: %s\n",
361 (int) opt->max, param);
362 return M_OPT_OUT_OF_RANGE;
363 }
364
365 if(dst) {
366 if(VAL(dst))
367 free(VAL(dst));
368 VAL(dst) = strdup(param);
369 }
370
371 return 1;
372
373 }
374
375 static char* print_str(m_option_t* opt, void* val) {
376 return (val && VAL(val) && strlen(VAL(val)) > 0) ? strdup(VAL(val)) : NULL;
377 }
378
379 static void copy_str(m_option_t* opt,void* dst, void* src) {
380 if(dst && src) {
381 #ifndef NO_FREE
382 if(VAL(dst)) free(VAL(dst)); //FIXME!!!
383 #endif
384 VAL(dst) = VAL(src) ? strdup(VAL(src)) : NULL;
385 }
386 }
387
388 static void free_str(void* src) {
389 if(src && VAL(src)){
390 #ifndef NO_FREE
391 free(VAL(src)); //FIXME!!!
392 #endif
393 VAL(src) = NULL;
394 }
395 }
396
397 m_option_type_t m_option_type_string = {
398 "String",
399 "",
400 sizeof(char*),
401 M_OPT_TYPE_DYNAMIC,
402 parse_str,
403 print_str,
404 copy_str,
405 copy_str,
406 copy_str,
407 free_str
408 };
409
410 //////////// String list
411
412 #define LIST_SEPARATOR ','
413 #undef VAL
414 #define VAL(x) (*(char***)(x))
415
416 #define OP_NONE 0
417 #define OP_ADD 1
418 #define OP_PRE 2
419 #define OP_DEL 3
420 #define OP_CLR 4
421
422 static void free_str_list(void* dst) {
423 char** d;
424 int i;
425
426 if(!dst || !VAL(dst)) return;
427 d = VAL(dst);
428
429 // FIXME!!!
430 #ifndef NO_FREE
431 for(i = 0 ; d[i] != NULL ; i++)
432 free(d[i]);
433 free(d);
434 #endif
435 VAL(dst) = NULL;
436 }
437
438 static int str_list_add(char** add, int n,void* dst,int pre) {
439 char** lst = VAL(dst);
440 int ln;
441
442 if(!dst) return M_OPT_PARSER_ERR;
443 lst = VAL(dst);
444
445 for(ln = 0 ; lst && lst[ln] ; ln++)
446 /**/;
447
448 lst = realloc(lst,(n+ln+1)*sizeof(char*));
449
450 if(pre) {
451 memmove(&lst[n],lst,(ln+1)*sizeof(char*));
452 memcpy(lst,add,n*sizeof(char*));
453 } else
454 memcpy(&lst[ln],add,(n+1)*sizeof(char*));
455
456 free(add);
457
458 VAL(dst) = lst;
459
460 return 1;
461 }
462
463 static int str_list_del(char** del, int n,void* dst) {
464 char **lst,*ep,**d;
465 int i,ln,s;
466 long idx;
467
468 if(!dst) return M_OPT_PARSER_ERR;
469 lst = VAL(dst);
470
471 for(ln = 0 ; lst && lst[ln] ; ln++)
472 /**/;
473 s = ln;
474
475 for(i = 0 ; del[i] != NULL ; i++) {
476 idx = strtol(del[i], &ep, 0);
477 if(*ep) {
478 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid index: %s\n",del[i]);
479 free(del[i]);
480 continue;
481 }
482 free(del[i]);
483 if(idx < 0 || idx >= ln) {
484 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Index %ld is out of range.\n",idx);
485 continue;
486 } else if(!lst[idx])
487 continue;
488 free(lst[idx]);
489 lst[idx] = NULL;
490 s--;
491 }
492 free(del);
493
494 if(s == 0) {
495 if(lst) free(lst);
496 VAL(dst) = NULL;
497 return 1;
498 }
499
500 d = calloc(s+1,sizeof(char*));
501 for(i = 0, n = 0 ; i < ln ; i++) {
502 if(!lst[i]) continue;
503 d[n] = lst[i];
504 n++;
505 }
506 d[s] = NULL;
507
508 if(lst) free(lst);
509 VAL(dst) = d;
510
511 return 1;
512 }
513
514 static char *get_nextsep(char *ptr, char sep, int modify) {
515 char *last_ptr = ptr;
516 for(;;){
517 ptr = strchr(ptr, sep);
518 if(ptr && ptr>last_ptr && ptr[-1]=='\\'){
519 if (modify) memmove(ptr-1, ptr, strlen(ptr)+1);
520 else ptr++;
521 }else
522 break;
523 }
524 return ptr;
525 }
526
527 static int parse_str_list(m_option_t* opt,char *name, char *param, void* dst, int src) {
528 int n = 0,len = strlen(opt->name);
529 char *str;
530 char *ptr = param, *last_ptr, **res;
531 int op = OP_NONE;
532
533 if(opt->name[len-1] == '*' && ((int)strlen(name) > len - 1)) {
534 char* n = &name[len-1];
535 if(strcasecmp(n,"-add") == 0)
536 op = OP_ADD;
537 else if(strcasecmp(n,"-pre") == 0)
538 op = OP_PRE;
539 else if(strcasecmp(n,"-del") == 0)
540 op = OP_DEL;
541 else if(strcasecmp(n,"-clr") == 0)
542 op = OP_CLR;
543 else
544 return M_OPT_UNKNOWN;
545 }
546
547 // Clear the list ??
548 if(op == OP_CLR) {
549 if(dst)
550 free_str_list(dst);
551 return 0;
552 }
553
554 // All other ops need a param
555 if (param == NULL || strlen(param) == 0)
556 return M_OPT_MISSING_PARAM;
557
558
559 while(ptr[0] != '\0') {
560 ptr = get_nextsep(ptr, LIST_SEPARATOR, 0);
561 if(!ptr) {
562 n++;
563 break;
564 }
565 ptr++;
566 n++;
567 }
568 if(n == 0)
569 return M_OPT_INVALID;
570 if( ((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
571 ((opt->flags & M_OPT_MAX) && (n > opt->max)) )
572 return M_OPT_OUT_OF_RANGE;
573
574 if(!dst) return 1;
575
576 res = malloc((n+2)*sizeof(char*));
577 ptr = str = strdup(param);
578 n = 0;
579
580 while(1) {
581 last_ptr = ptr;
582 ptr = get_nextsep(ptr, LIST_SEPARATOR, 1);
583 if(!ptr) {
584 res[n] = strdup(last_ptr);
585 n++;
586 break;
587 }
588 len = ptr - last_ptr;
589 res[n] = malloc(len + 1);
590 if(len) strncpy(res[n],last_ptr,len);
591 res[n][len] = '\0';
592 ptr++;
593 n++;
594 }
595 res[n] = NULL;
596 free(str);
597
598 switch(op) {
599 case OP_ADD:
600 return str_list_add(res,n,dst,0);
601 case OP_PRE:
602 return str_list_add(res,n,dst,1);
603 case OP_DEL:
604 return str_list_del(res,n,dst);
605 }
606
607 if(VAL(dst))
608 free_str_list(dst);
609 VAL(dst) = res;
610
611 return 1;
612 }
613
614 static void copy_str_list(m_option_t* opt,void* dst, void* src) {
615 int n;
616 char **d,**s;
617
618 if(!(dst && src)) return;
619 s = VAL(src);
620
621 if(VAL(dst))
622 free_str_list(dst);
623
624 if(!s) {
625 VAL(dst) = NULL;
626 return;
627 }
628
629 for(n = 0 ; s[n] != NULL ; n++)
630 /* NOTHING */;
631 d = malloc((n+1)*sizeof(char*));
632 for( ; n >= 0 ; n--)
633 d[n] = s[n] ? strdup(s[n]) : NULL;
634
635 VAL(dst) = d;
636 }
637
638 static char* print_str_list(m_option_t* opt, void* src) {
639 char **lst = NULL;
640 char *ret = NULL,*last = NULL;
641 int i;
642
643 if(!(src && VAL(src))) return NULL;
644 lst = VAL(src);
645
646 for(i = 0 ; lst[i] ; i++) {
647 if(last) {
648 ret = dup_printf("%s,%s",last,lst[i]);
649 free(last);
650 } else
651 ret = strdup(lst[i]);
652 last = ret;
653 }
654 if(last && last != ret) free(last);
655 return ret;
656 }
657
658 m_option_type_t m_option_type_string_list = {
659 "String list",
660 "A list of strings separated by ','\n"
661 "Option with a name ending in an * permits using the following suffix: \n"
662 "\t-add: Add the given parameters at the end of the list.\n"
663 "\t-pre: Add the given parameters at the begining of the list.\n"
664 "\t-del: Remove the entry at the given indices.\n"
665 "\t-clr: Clear the list.\n"
666 "e.g: -vf-add flip,mirror -vf-del 2,5\n",
667 sizeof(char**),
668 M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
669 parse_str_list,
670 print_str_list,
671 copy_str_list,
672 copy_str_list,
673 copy_str_list,
674 free_str_list
675 };
676
677
678 /////////////////// Func based options
679
680 // A chained list to save the various calls for func_param and func_full
681 typedef struct m_func_save m_func_save_t;
682 struct m_func_save {
683 m_func_save_t* next;
684 char* name;
685 char* param;
686 };
687
688 #undef VAL
689 #define VAL(x) (*(m_func_save_t**)(x))
690
691 static void free_func_pf(void* src) {
692 m_func_save_t *s,*n;
693
694 if(!src) return;
695
696 s = VAL(src);
697
698 while(s) {
699 n = s->next;
700 free(s->name);
701 if(s->param) free(s->param);
702 free(s);
703 s = n;
704 }
705 VAL(src) = NULL;
706 }
707
708 // Parser for func_param and func_full
709 static int parse_func_pf(m_option_t* opt,char *name, char *param, void* dst, int src) {
710 m_func_save_t *s,*p;
711
712 if(!dst)
713 return 1;
714
715 s = calloc(1,sizeof(m_func_save_t));
716 s->name = strdup(name);
717 s->param = param ? strdup(param) : NULL;
718
719 p = VAL(dst);
720 if(p) {
721 for( ; p->next != NULL ; p = p->next)
722 /**/;
723 p->next = s;
724 } else
725 VAL(dst) = s;
726
727 return 1;
728 }
729
730 static void copy_func_pf(m_option_t* opt,void* dst, void* src) {
731 m_func_save_t *d = NULL, *s,* last = NULL;
732
733 if(!(dst && src)) return;
734 s = VAL(src);
735
736 if(VAL(dst))
737 free_func_pf(dst);
738
739 while(s) {
740 d = calloc(1,sizeof(m_func_save_t));
741 d->name = strdup(s->name);
742 d->param = s->param ? strdup(s->param) : NULL;
743 if(last)
744 last->next = d;
745 else
746 VAL(dst) = d;
747 last = d;
748 s = s->next;
749 }
750
751
752 }
753
754 /////////////////// Func_param
755
756 static void set_func_param(m_option_t* opt, void* dst, void* src) {
757 m_func_save_t* s;
758
759 if(!src) return;
760 s = VAL(src);
761
762 if(!s) return;
763
764 // Revert if needed
765 if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,opt->name);
766 for( ; s != NULL ; s = s->next)
767 ((m_opt_func_param_t) opt->p)(opt,s->param);
768 }
769
770 m_option_type_t m_option_type_func_param = {
771 "Func param",
772 "",
773 sizeof(m_func_save_t*),
774 M_OPT_TYPE_INDIRECT,
775 parse_func_pf,
776 NULL,
777 NULL, // Nothing to do on save
778 set_func_param,
779 copy_func_pf,
780 free_func_pf
781 };
782
783 /////////////////// Func_full
784
785 static void set_func_full(m_option_t* opt, void* dst, void* src) {
786 m_func_save_t* s;
787
788 if(!src) return;
789
790 for(s = VAL(src) ; s ; s = s->next) {
791 // Revert if needed
792 if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,s->name);
793 ((m_opt_func_full_t) opt->p)(opt,s->name,s->param);
794 }
795 }
796
797 m_option_type_t m_option_type_func_full = {
798 "Func full",
799 "",
800 sizeof(m_func_save_t*),
801 M_OPT_TYPE_ALLOW_WILDCARD|M_OPT_TYPE_INDIRECT,
802 parse_func_pf,
803 NULL,
804 NULL, // Nothing to do on save
805 set_func_full,
806 copy_func_pf,
807 free_func_pf
808 };
809
810 /////////////// Func
811
812 #undef VAL
813 #define VAL(x) (*(int*)(x))
814
815 static int parse_func(m_option_t* opt,char *name, char *param, void* dst, int src) {
816 if(dst)
817 VAL(dst) += 1;
818 return 0;
819 }
820
821 static void set_func(m_option_t* opt,void* dst, void* src) {
822 int i;
823 if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,opt->name);
824 for(i = 0 ; i < VAL(src) ; i++)
825 ((m_opt_func_t) opt->p)(opt);
826 }
827
828 m_option_type_t m_option_type_func = {
829 "Func",
830 "",
831 sizeof(int),
832 M_OPT_TYPE_INDIRECT,
833 parse_func,
834 NULL,
835 NULL, // Nothing to do on save
836 set_func,
837 NULL,
838 NULL
839 };
840
841 /////////////////// Print
842
843 static int parse_print(m_option_t* opt,char *name, char *param, void* dst, int src) {
844 if(opt->type == CONF_TYPE_PRINT_INDIRECT)
845 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", *(char **) opt->p);
846 else if(opt->type == CONF_TYPE_PRINT_FUNC)
847 return ((m_opt_func_full_t) opt->p)(opt,name,param);
848 else
849 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", (char *) opt->p);
850
851 if(opt->priv == NULL)
852 return M_OPT_EXIT;
853 return 1;
854 }
855
856 m_option_type_t m_option_type_print = {
857 "Print",
858 "",
859 0,
860 0,
861 parse_print,
862 NULL,
863 NULL,
864 NULL,
865 NULL,
866 NULL
867 };
868
869 m_option_type_t m_option_type_print_indirect = {
870 "Print",
871 "",
872 0,
873 0,
874 parse_print,
875 NULL,
876 NULL,
877 NULL,
878 NULL,
879 NULL
880 };
881
882 m_option_type_t m_option_type_print_func = {
883 "Print",
884 "",
885 0,
886 M_OPT_TYPE_ALLOW_WILDCARD,
887 parse_print,
888 NULL,
889 NULL,
890 NULL,
891 NULL,
892 NULL
893 };
894
895
896 /////////////////////// Subconfig
897 #undef VAL
898 #define VAL(x) (*(char***)(x))
899
900 static int parse_subconf(m_option_t* opt,char *name, char *param, void* dst, int src) {
901 char *subparam;
902 char *subopt;
903 int nr = 0,i,r;
904 m_option_t *subopts;
905 char *p;
906 char** lst = NULL;
907
908 if (param == NULL || strlen(param) == 0)
909 return M_OPT_MISSING_PARAM;
910
911 subparam = malloc(strlen(param)+1);
912 subopt = malloc(strlen(param)+1);
913 p = param;
914
915 subopts = opt->p;
916
917 while(p[0])
918 {
919 int sscanf_ret = 1;
920 int optlen = strcspn(p, ":=");
921 /* clear out */
922 subopt[0] = subparam[0] = 0;
923 strlcpy(subopt, p, optlen + 1);
924 p = &p[optlen];
925 if (p[0] == '=') {
926 sscanf_ret = 2;
927 p = &p[1];
928 if (p[0] == '"') {
929 p = &p[1];
930 optlen = strcspn(p, "\"");
931 strlcpy(subparam, p, optlen + 1);
932 p = &p[optlen];
933 if (p[0] != '"') {
934 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Terminating '\"' missing for '%s'\n", subopt);
935 return M_OPT_INVALID;
936 }
937 p = &p[1];
938 } else if (p[0] == '%') {
939 p = &p[1];
940 optlen = (int)strtol(p, &p, 0);
941 if (!p || p[0] != '%' || (optlen > strlen(p) - 1)) {
942 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid length %i for '%s'\n", optlen, subopt);
943 return M_OPT_INVALID;
944 }
945 p = &p[1];
946 strlcpy(subparam, p, optlen + 1);
947 p = &p[optlen];
948 } else {
949 optlen = strcspn(p, ":");
950 strlcpy(subparam, p, optlen + 1);
951 p = &p[optlen];
952 }
953 }
954 if (p[0] == ':')
955 p = &p[1];
956 else if (p[0]) {
957 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Incorrect termination for '%s'\n", subopt);
958 return M_OPT_INVALID;
959 }
960
961 switch(sscanf_ret)
962 {
963 case 1:
964 subparam[0] = 0;
965 case 2:
966 for(i = 0 ; subopts[i].name ; i++) {
967 if(!strcmp(subopts[i].name,subopt)) break;
968 }
969 if(!subopts[i].name) {
970 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Unknown suboption %s\n",name,subopt);
971 return M_OPT_UNKNOWN;
972 }
973 r = m_option_parse(&subopts[i],subopt,
974 subparam[0] == 0 ? NULL : subparam,NULL,src);
975 if(r < 0) return r;
976 if(dst) {
977 lst = (char**)realloc(lst,2 * (nr+2) * sizeof(char*));
978 lst[2*nr] = strdup(subopt);
979 lst[2*nr+1] = subparam[0] == 0 ? NULL : strdup(subparam);
980 memset(&lst[2*(nr+1)],0,2*sizeof(char*));
981 nr++;
982 }
983 break;
984 }
985 }
986
987 free(subparam);
988 free(subopt);
989 if(dst)
990 VAL(dst) = lst;
991
992 return 1;
993 }
994
995 m_option_type_t m_option_type_subconfig = {
996 "Subconfig",
997 "The syntax is -option opt1=foo:flag:opt2=blah",
998 sizeof(int),
999 M_OPT_TYPE_HAS_CHILD,
1000 parse_subconf,
1001 NULL,
1002 NULL,
1003 NULL,
1004 NULL,
1005 NULL
1006 };
1007
1008 #include "libmpcodecs/img_format.h"
1009
1010 /* FIXME: snyc with img_format.h */
1011 static struct {
1012 const char* name;
1013 unsigned int fmt;
1014 } mp_imgfmt_list[] = {
1015 {"444p", IMGFMT_444P},
1016 {"422p", IMGFMT_422P},
1017 {"411p", IMGFMT_411P},
1018 {"yuy2", IMGFMT_YUY2},
1019 {"uyvy", IMGFMT_UYVY},
1020 {"yvu9", IMGFMT_YVU9},
1021 {"if09", IMGFMT_IF09},
1022 {"yv12", IMGFMT_YV12},
1023 {"i420", IMGFMT_I420},
1024 {"iyuv", IMGFMT_IYUV},
1025 {"clpl", IMGFMT_CLPL},
1026 {"hm12", IMGFMT_HM12},
1027 {"y800", IMGFMT_Y800},
1028 {"y8", IMGFMT_Y8},
1029 {"nv12", IMGFMT_NV12},
1030 {"nv21", IMGFMT_NV21},
1031 {"bgr24", IMGFMT_BGR24},
1032 {"bgr32", IMGFMT_BGR32},
1033 {"bgr16", IMGFMT_BGR16},
1034 {"bgr15", IMGFMT_BGR15},
1035 {"bgr8", IMGFMT_BGR8},
1036 {"bgr4", IMGFMT_BGR4},
1037 {"bg4b", IMGFMT_BG4B},
1038 {"bgr1", IMGFMT_BGR1},
1039 {"rgb24", IMGFMT_RGB24},
1040 {"rgb32", IMGFMT_RGB32},
1041 {"rgb16", IMGFMT_RGB16},
1042 {"rgb15", IMGFMT_RGB15},
1043 {"rgb8", IMGFMT_RGB8},
1044 {"rgb4", IMGFMT_RGB4},
1045 {"rg4b", IMGFMT_RG4B},
1046 {"rgb1", IMGFMT_RGB1},
1047 {"rgba", IMGFMT_RGBA},
1048 {"argb", IMGFMT_ARGB},
1049 {"bgra", IMGFMT_BGRA},
1050 {"abgr", IMGFMT_ABGR},
1051 { NULL, 0 }
1052 };
1053
1054 static int parse_imgfmt(m_option_t* opt,char *name, char *param, void* dst, int src) {
1055 uint32_t fmt = 0;
1056 int i;
1057
1058 if (param == NULL || strlen(param) == 0)
1059 return M_OPT_MISSING_PARAM;
1060
1061 if(!strcmp(param,"help")) {
1062 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1063 for(i = 0 ; mp_imgfmt_list[i].name ; i++)
1064 mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_imgfmt_list[i].name);
1065 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1066 return M_OPT_EXIT - 1;
1067 }
1068
1069 if (sscanf(param, "0x%x", &fmt) != 1)
1070 {
1071 for(i = 0 ; mp_imgfmt_list[i].name ; i++) {
1072 if(!strcasecmp(param,mp_imgfmt_list[i].name)) {
1073 fmt=mp_imgfmt_list[i].fmt;
1074 break;
1075 }
1076 }
1077 if(!mp_imgfmt_list[i].name) {
1078 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1079 return M_OPT_INVALID;
1080 }
1081 }
1082
1083 if(dst)
1084 *((uint32_t*)dst) = fmt;
1085
1086 return 1;
1087 }
1088
1089 m_option_type_t m_option_type_imgfmt = {
1090 "Image format",
1091 "Please report any missing colorspaces.",
1092 sizeof(uint32_t),
1093 0,
1094 parse_imgfmt,
1095 NULL,
1096 copy_opt,
1097 copy_opt,
1098 NULL,
1099 NULL
1100 };
1101
1102 #include "libaf/af_format.h"
1103
1104 /* FIXME: snyc with af_format.h */
1105 static struct {
1106 const char* name;
1107 unsigned int fmt;
1108 } mp_afmt_list[] = {
1109 // SPECIAL
1110 {"mulaw", AF_FORMAT_MU_LAW},
1111 {"alaw", AF_FORMAT_A_LAW},
1112 {"mpeg2", AF_FORMAT_MPEG2},
1113 {"ac3", AF_FORMAT_AC3},
1114 {"imaadpcm", AF_FORMAT_IMA_ADPCM},
1115 // ORIDNARY
1116 {"u8", AF_FORMAT_U8},
1117 {"s8", AF_FORMAT_S8},
1118 {"u16le", AF_FORMAT_U16_LE},
1119 {"u16be", AF_FORMAT_U16_BE},
1120 {"u16ne", AF_FORMAT_U16_NE},
1121 {"s16le", AF_FORMAT_S16_LE},
1122 {"s16be", AF_FORMAT_S16_BE},
1123 {"s16ne", AF_FORMAT_S16_NE},
1124 {"u24le", AF_FORMAT_U24_LE},
1125 {"u24be", AF_FORMAT_U24_BE},
1126 {"u24ne", AF_FORMAT_U24_NE},
1127 {"s24le", AF_FORMAT_S24_LE},
1128 {"s24be", AF_FORMAT_S24_BE},
1129 {"s24ne", AF_FORMAT_S24_NE},
1130 {"u32le", AF_FORMAT_U32_LE},
1131 {"u32be", AF_FORMAT_U32_BE},
1132 {"u32ne", AF_FORMAT_U32_NE},
1133 {"s32le", AF_FORMAT_S32_LE},
1134 {"s32be", AF_FORMAT_S32_BE},
1135 {"s32ne", AF_FORMAT_S32_NE},
1136 {"floatle", AF_FORMAT_FLOAT_LE},
1137 {"floatbe", AF_FORMAT_FLOAT_BE},
1138 {"floatne", AF_FORMAT_FLOAT_NE},
1139 { NULL, 0 }
1140 };
1141
1142 static int parse_afmt(m_option_t* opt,char *name, char *param, void* dst, int src) {
1143 uint32_t fmt = 0;
1144 int i;
1145
1146 if (param == NULL || strlen(param) == 0)
1147 return M_OPT_MISSING_PARAM;
1148
1149 if(!strcmp(param,"help")) {
1150 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1151 for(i = 0 ; mp_afmt_list[i].name ; i++)
1152 mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_afmt_list[i].name);
1153 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1154 return M_OPT_EXIT - 1;
1155 }
1156
1157 if (sscanf(param, "0x%x", &fmt) != 1)
1158 {
1159 for(i = 0 ; mp_afmt_list[i].name ; i++) {
1160 if(!strcasecmp(param,mp_afmt_list[i].name)) {
1161 fmt=mp_afmt_list[i].fmt;
1162 break;
1163 }
1164 }
1165 if(!mp_afmt_list[i].name) {
1166 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1167 return M_OPT_INVALID;
1168 }
1169 }
1170
1171 if(dst)
1172 *((uint32_t*)dst) = fmt;
1173
1174 return 1;
1175 }
1176
1177 m_option_type_t m_option_type_afmt = {
1178 "Audio format",
1179 "Please report any missing formats.",
1180 sizeof(uint32_t),
1181 0,
1182 parse_afmt,
1183 NULL,
1184 copy_opt,
1185 copy_opt,
1186 NULL,
1187 NULL
1188 };
1189
1190
1191 // Time or size (-endpos)
1192
1193 static int parse_time_size(m_option_t* opt,char *name, char *param, void* dst, int src) {
1194 m_time_size_t ts;
1195 char unit[4];
1196 int a,b;
1197 float d;
1198 double end_at;
1199
1200 if (param == NULL || strlen(param) == 0)
1201 return M_OPT_MISSING_PARAM;
1202
1203 ts.pos=0;
1204 /* End at size parsing */
1205 if(sscanf(param, "%lf%3s", &end_at, unit) == 2) {
1206 ts.type = END_AT_SIZE;
1207 if(!strcasecmp(unit, "b"))
1208 ;
1209 else if(!strcasecmp(unit, "kb"))
1210 end_at *= 1024;
1211 else if(!strcasecmp(unit, "mb"))
1212 end_at *= 1024*1024;
1213 else if(!strcasecmp(unit, "gb"))
1214 end_at *= 1024*1024*1024;
1215 else
1216 ts.type = END_AT_NONE;
1217
1218 if (ts.type == END_AT_SIZE) {
1219 ts.pos = end_at;
1220 goto out;
1221 }
1222 }
1223
1224 /* End at time parsing. This has to be last because of
1225 * sscanf("%f", ...) below */
1226 if (sscanf(param, "%d:%d:%f", &a, &b, &d) == 3)
1227 end_at = 3600*a + 60*b + d;
1228 else if (sscanf(param, "%d:%f", &a, &d) == 2)
1229 end_at = 60*a + d;
1230 else if (sscanf(param, "%f", &d) == 1)
1231 end_at = d;
1232 else {
1233 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: invalid time or size: '%s'\n",
1234 name,param);
1235 return M_OPT_INVALID;
1236 }
1237
1238 ts.type = END_AT_TIME;
1239 ts.pos = end_at;
1240 out:
1241 if(dst)
1242 *(m_time_size_t *)dst = ts;
1243 return 1;
1244 }
1245
1246 m_option_type_t m_option_type_time_size = {
1247 "Time or size",
1248 "",
1249 sizeof(m_time_size_t),
1250 0,
1251 parse_time_size,
1252 NULL,
1253 copy_opt,
1254 copy_opt,
1255 NULL,
1256 NULL
1257 };
1258
1259
1260 //// Objects (i.e. filters, etc) settings
1261
1262 #include "m_struct.h"
1263
1264 #undef VAL
1265 #define VAL(x) (*(m_obj_settings_t**)(x))
1266
1267 static int find_obj_desc(char* name,m_obj_list_t* l,m_struct_t** ret) {
1268 int i;
1269 char* n;
1270
1271 for(i = 0 ; l->list[i] ; i++) {
1272 n = M_ST_MB(char*,l->list[i],l->name_off);
1273 if(!strcmp(n,name)) {
1274 *ret = M_ST_MB(m_struct_t*,l->list[i],l->desc_off);
1275 return 1;
1276 }
1277 }
1278 return 0;
1279 }
1280
1281 static int get_obj_param(const char* opt_name,const char* obj_name, m_struct_t* desc,
1282 char* str,int* nold,int oldmax,char** dst) {
1283 char* eq;
1284 m_option_t* opt;
1285 int r;
1286
1287 eq = strchr(str,'=');
1288 if(eq && eq == str)
1289 eq = NULL;
1290
1291 if(eq) {
1292 char* p = eq + 1;
1293 if(p[0] == '\0') p = NULL;
1294 eq[0] = '\0';
1295 opt = m_option_list_find(desc->fields,str);
1296 if(!opt) {
1297 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't have a %s parameter.\n",opt_name,obj_name,str);
1298 return M_OPT_UNKNOWN;
1299 }
1300 r = m_option_parse(opt,str,p,NULL,M_CONFIG_FILE);
1301 if(r < 0) {
1302 if(r > M_OPT_EXIT)
1303 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,str,p);
1304 eq[0] = '=';
1305 return r;
1306 }
1307 if(dst) {
1308 dst[0] = strdup(str);
1309 dst[1] = p ? strdup(p) : NULL;
1310 }
1311 eq[0] = '=';
1312 } else {
1313 if((*nold) >= oldmax) {
1314 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
1315 opt_name,obj_name,oldmax,oldmax);
1316 return M_OPT_OUT_OF_RANGE;
1317 }
1318 opt = &desc->fields[(*nold)];
1319 r = m_option_parse(opt,opt->name,str,NULL,M_CONFIG_FILE);
1320 if(r < 0) {
1321 if(r > M_OPT_EXIT)
1322 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,opt->name,str);
1323 return r;
1324 }
1325 if(dst) {
1326 dst[0] = strdup(opt->name);
1327 dst[1] = strdup(str);
1328 }
1329 (*nold)++;
1330 }
1331 return 1;
1332 }
1333
1334 static int get_obj_params(const char* opt_name, const char* name,char* params,
1335 m_struct_t* desc,char separator, char*** _ret) {
1336 int n = 0,nold = 0, nopts,r;
1337 char* ptr,*last_ptr = params;
1338 char** ret;
1339
1340 if(!strcmp(params,"help")) { // Help
1341 char min[50],max[50];
1342 if(!desc->fields) {
1343 printf("%s doesn't have any options.\n\n",name);
1344 return M_OPT_EXIT - 1;
1345 }
1346 printf("\n Name Type Min Max\n\n");
1347 for(n = 0 ; desc->fields[n].name ; n++) {
1348 m_option_t* opt = &desc->fields[n];
1349 if(opt->type->flags & M_OPT_TYPE_HAS_CHILD) continue;
1350 if(opt->flags & M_OPT_MIN)
1351 sprintf(min,"%-8.0f",opt->min);
1352 else
1353 strcpy(min,"No");
1354 if(opt->flags & M_OPT_MAX)
1355 sprintf(max,"%-8.0f",opt->max);
1356 else
1357 strcpy(max,"No");
1358 printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
1359 opt->name,
1360 opt->type->name,
1361 min,
1362 max);
1363 }
1364 printf("\n");
1365 return M_OPT_EXIT - 1;
1366 }
1367
1368 for(nopts = 0 ; desc->fields[nopts].name ; nopts++)
1369 /* NOP */;
1370
1371 // TODO : Check that each opt can be parsed
1372 r = 1;
1373 while(last_ptr && last_ptr[0] != '\0') {
1374 ptr = strchr(last_ptr,separator);
1375 if(!ptr) {
1376 r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1377 n++;
1378 break;
1379 }
1380 if(ptr == last_ptr) { // Empty field, count it and go on
1381 nold++;
1382 last_ptr = ptr+1;
1383 continue;
1384 }
1385 ptr[0] = '\0';
1386 r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1387 ptr[0] = separator;
1388 if(r < 0) break;
1389 n++;
1390 last_ptr = ptr+1;
1391 }
1392 if(r < 0) return r;
1393 if (!last_ptr[0]) // count an empty field at the end, too
1394 nold++;
1395 if (nold > nopts) {
1396 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Too many options for %s\n", name);
1397 return M_OPT_OUT_OF_RANGE;
1398 }
1399 if(!_ret) // Just test
1400 return 1;
1401 if (n == 0) // No options or only empty options
1402 return 1;
1403
1404 ret = malloc((n+2)*2*sizeof(char*));
1405 n = nold = 0;
1406 last_ptr = params;
1407
1408 while(last_ptr && last_ptr[0] != '\0') {
1409 ptr = strchr(last_ptr,separator);
1410 if(!ptr) {
1411 get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1412 n++;
1413 break;
1414 }
1415 if(ptr == last_ptr) { // Empty field, count it and go on
1416 last_ptr = ptr+1;
1417 nold++;
1418 continue;
1419 }
1420 ptr[0] = '\0';
1421 get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1422 n++;
1423 last_ptr = ptr+1;
1424 }
1425 ret[n*2] = ret[n*2+1] = NULL;
1426 *_ret = ret;
1427
1428 return 1;
1429 }
1430
1431 static int parse_obj_params(m_option_t* opt,char *name,
1432 char *param, void* dst, int src) {
1433 char** opts;
1434 int r;
1435 m_obj_params_t* p = opt->priv;
1436 m_struct_t* desc;
1437 char* cpy = strdup(param);
1438
1439 // We need the object desc
1440 if(!p)
1441 return M_OPT_INVALID;
1442
1443 desc = p->desc;
1444 r = get_obj_params(name,desc->name,cpy,desc,p->separator,dst ? &opts : NULL);
1445 free(cpy);
1446 if(r < 0)
1447 return r;
1448 if(!dst)
1449 return 1;
1450 if (!opts) // no arguments given
1451 return 1;
1452
1453 for(r = 0 ; opts[r] ; r += 2)
1454 m_struct_set(desc,dst,opts[r],opts[r+1]);
1455
1456 return 1;
1457 }
1458
1459
1460 m_option_type_t m_option_type_obj_params = {
1461 "Object params",
1462 "",
1463 0,
1464 0,
1465 parse_obj_params,
1466 NULL,
1467 NULL,
1468 NULL,
1469 NULL,
1470 NULL
1471 };
1472
1473 /// Some predefined types as a definition would be quite lengthy
1474
1475 /// Span arguments
1476 static m_span_t m_span_params_dflts = { -1, -1 };
1477 static m_option_t m_span_params_fields[] = {
1478 {"start", M_ST_OFF(m_span_t,start), CONF_TYPE_INT, M_OPT_MIN, 1 ,0, NULL},
1479 {"end", M_ST_OFF(m_span_t,end), CONF_TYPE_INT, M_OPT_MIN , 1 ,0, NULL},
1480 { NULL, NULL, 0, 0, 0, 0, NULL }
1481 };
1482 static struct m_struct_st m_span_opts = {
1483 "m_span",
1484 sizeof(m_span_t),
1485 &m_span_params_dflts,
1486 m_span_params_fields
1487 };
1488 m_obj_params_t m_span_params_def = {
1489 &m_span_opts,
1490 '-'
1491 };
1492
1493 static int parse_obj_settings(char* opt,char* str,m_obj_list_t* list,
1494 m_obj_settings_t **_ret, int ret_n) {
1495 int r;
1496 char *param,**plist = NULL;
1497 m_struct_t* desc;
1498 m_obj_settings_t *ret = _ret ? *_ret : NULL;
1499
1500
1501 // Now check that the object exists
1502 param = strchr(str,'=');
1503 if(param) {
1504 param[0] = '\0';
1505 param++;
1506 if(strlen(param) <= 0)
1507 param = NULL;
1508 }
1509
1510
1511 if(!find_obj_desc(str,list,&desc)) {
1512 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't exist.\n",opt,str);
1513 return M_OPT_INVALID;
1514 }
1515
1516 if(param) {
1517 if(!desc && _ret) {
1518 if(!strcmp(param,"help")) {
1519 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Option %s: %s have no option description.\n",opt,str);
1520 return M_OPT_EXIT - 1;
1521 }
1522 plist = calloc(4,sizeof(char*));
1523 plist[0] = strdup("_oldargs_");
1524 plist[1] = strdup(param);
1525 } else if(desc) {
1526 r = get_obj_params(opt,str,param,desc,':',_ret ? &plist : NULL);
1527 if(r < 0)
1528 return r;
1529 }
1530 }
1531 if(!_ret)
1532 return 1;
1533
1534 ret = realloc(ret,(ret_n+2)*sizeof(m_obj_settings_t));
1535 memset(&ret[ret_n],0,2*sizeof(m_obj_settings_t));
1536 ret[ret_n].name = strdup(str);
1537 ret[ret_n].attribs = plist;
1538
1539 *_ret = ret;
1540 return 1;
1541 }
1542
1543 static void free_obj_settings_list(void* dst);
1544
1545 static int obj_settings_list_del(char *opt_name,char *param,void* dst, int src) {
1546 char** str_list = NULL;
1547 int r,i,idx_max = 0;
1548 char* rem_id = "_removed_marker_";
1549 m_option_t list_opt = {opt_name , NULL, CONF_TYPE_STRING_LIST,
1550 0, 0, 0, NULL };
1551 m_obj_settings_t* obj_list = dst ? VAL(dst) : NULL;
1552
1553 if(dst && !obj_list) {
1554 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: the list is empty.\n",opt_name);
1555 return 1;
1556 } else if(obj_list) {
1557 for(idx_max = 0 ; obj_list[idx_max].name != NULL ; idx_max++)
1558 /* NOP */;
1559 }
1560
1561 r = m_option_parse(&list_opt,opt_name,param,&str_list,src);
1562 if(r < 0 || !str_list)
1563 return r;
1564
1565 for(r = 0 ; str_list[r] ; r++) {
1566 int id;
1567 char* endptr;
1568 id = strtol(str_list[r],&endptr,0);
1569 if(endptr == str_list[r]) {
1570 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);
1571 m_option_free(&list_opt,&str_list);
1572 return M_OPT_INVALID;
1573 }
1574 if(!obj_list) continue;
1575 if(id >= idx_max || id < -idx_max) {
1576 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: Index %d is out of range.\n",opt_name,id);
1577 continue;
1578 }
1579 if(id < 0)
1580 id = idx_max + id;
1581 free(obj_list[id].name);
1582 free_str_list(&(obj_list[id].attribs));
1583 obj_list[id].name = rem_id;
1584 }
1585
1586 if(!dst) {
1587 m_option_free(&list_opt,&str_list);
1588 return 1;
1589 }
1590
1591 for(i = 0 ; obj_list[i].name ; i++) {
1592 while(obj_list[i].name == rem_id) {
1593 memmove(&obj_list[i],&obj_list[i+1],sizeof(m_obj_settings_t)*(idx_max - i));
1594 idx_max--;
1595 }
1596 }
1597 obj_list = realloc(obj_list,sizeof(m_obj_settings_t)*(idx_max+1));
1598 VAL(dst) = obj_list;
1599
1600 return 1;
1601 }
1602
1603 static int parse_obj_settings_list(m_option_t* opt,char *name,
1604 char *param, void* dst, int src) {
1605 int n = 0,r,len = strlen(opt->name);
1606 char *str;
1607 char *ptr, *last_ptr;
1608 m_obj_settings_t *res = NULL,*queue = NULL,*head = NULL;
1609 int op = OP_NONE;
1610
1611 // We need the objects list
1612 if(!opt->priv)
1613 return M_OPT_INVALID;
1614
1615 if(opt->name[len-1] == '*' && ((int)strlen(name) > len - 1)) {
1616 char* n = &name[len-1];
1617 if(strcasecmp(n,"-add") == 0)
1618 op = OP_ADD;
1619 else if(strcasecmp(n,"-pre") == 0)
1620 op = OP_PRE;
1621 else if(strcasecmp(n,"-del") == 0)
1622 op = OP_DEL;
1623 else if(strcasecmp(n,"-clr") == 0)
1624 op = OP_CLR;
1625 else {
1626 char prefix[len];
1627 strncpy(prefix,opt->name,len-1);
1628 prefix[len-1] = '\0';
1629 mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: unknown postfix %s\n"
1630 "Supported postfixes are:\n"
1631 " %s-add\n"
1632 " Append the given list to the current list\n\n"
1633 " %s-pre\n"
1634 " Prepend the given list to the current list\n\n"
1635 " %s-del x,y,...\n"
1636 " Remove the given elements. Take the list element index (starting from 0).\n"
1637 " Negative index can be used (i.e. -1 is the last element)\n\n"
1638 " %s-clr\n"
1639 " Clear the current list.\n",name,n,prefix,prefix,prefix,prefix);
1640
1641 return M_OPT_UNKNOWN;
1642 }
1643 }
1644
1645 // Clear the list ??
1646 if(op == OP_CLR) {
1647 if(dst)
1648 free_obj_settings_list(dst);
1649 return 0;
1650 }
1651
1652 if (param == NULL || strlen(param) == 0)
1653 return M_OPT_MISSING_PARAM;
1654
1655 switch(op) {
1656 case OP_ADD:
1657 if(dst) head = VAL(dst);
1658 break;
1659 case OP_PRE:
1660 if(dst) queue = VAL(dst);
1661 break;
1662 case OP_DEL:
1663 return obj_settings_list_del(name,param,dst,src);
1664 case OP_NONE:
1665 if(dst && VAL(dst))
1666 free_obj_settings_list(dst);
1667 break;
1668 default:
1669 mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: FIXME\n",name);
1670 return M_OPT_UNKNOWN;
1671 }
1672
1673 if(!strcmp(param,"help")) {
1674 m_obj_list_t* ol = opt->priv;
1675 mp_msg(MSGT_VFILTER,MSGL_INFO,"Available video filters:\n");
1676 mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_FILTERS\n");
1677 for(n = 0 ; ol->list[n] ; n++)
1678 mp_msg(MSGT_VFILTER,MSGL_INFO," %-15s: %s\n",
1679 M_ST_MB(char*,ol->list[n],ol->name_off),
1680 M_ST_MB(char*,ol->list[n],ol->info_off));
1681 mp_msg(MSGT_VFILTER,MSGL_INFO,"\n");
1682 return M_OPT_EXIT - 1;
1683 }
1684 ptr = str = strdup(param);
1685
1686 while(ptr[0] != '\0') {
1687 last_ptr = ptr;
1688 ptr = get_nextsep(ptr, LIST_SEPARATOR, 1);
1689
1690 if(!ptr) {
1691 r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1692 if(r < 0) {
1693 free(str);
1694 return r;
1695 }
1696 n++;
1697 break;
1698 }
1699 ptr[0] = '\0';
1700 r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1701 if(r < 0) {
1702 free(str);
1703 return r;
1704 }
1705 ptr++;
1706 n++;
1707 }
1708 free(str);
1709 if(n == 0)
1710 return M_OPT_INVALID;
1711
1712 if( ((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
1713 ((opt->flags & M_OPT_MAX) && (n > opt->max)) )
1714 return M_OPT_OUT_OF_RANGE;
1715
1716 if(dst) {
1717 if(queue) {
1718 int qsize;
1719 for(qsize = 0 ; queue[qsize].name ; qsize++)
1720 /* NOP */;
1721 res = realloc(res,(qsize+n+1)*sizeof(m_obj_settings_t));
1722 memcpy(&res[n],queue,(qsize+1)*sizeof(m_obj_settings_t));
1723 n += qsize;
1724 free(queue);
1725 }
1726 if(head) {
1727 int hsize;
1728 for(hsize = 0 ; head[hsize].name ; hsize++)
1729 /* NOP */;
1730 head = realloc(head,(hsize+n+1)*sizeof(m_obj_settings_t));
1731 memcpy(&head[hsize],res,(n+1)*sizeof(m_obj_settings_t));
1732 free(res);
1733 res = head;
1734 }
1735 VAL(dst) = res;
1736 }
1737 return 1;
1738 }
1739
1740 static void free_obj_settings_list(void* dst) {
1741 int n;
1742 m_obj_settings_t *d;
1743
1744 if(!dst || !VAL(dst)) return;
1745
1746 d = VAL(dst);
1747 #ifndef NO_FREE
1748 for(n = 0 ; d[n].name ; n++) {
1749 free(d[n].name);
1750 free_str_list(&(d[n].attribs));
1751 }
1752 free(d);
1753 #endif
1754 VAL(dst) = NULL;
1755 }
1756
1757 static void copy_obj_settings_list(m_option_t* opt,void* dst, void* src) {
1758 m_obj_settings_t *d,*s;
1759 int n;
1760
1761 if(!(dst && src))
1762 return;
1763
1764 s = VAL(src);
1765
1766 if(VAL(dst))
1767 free_obj_settings_list(dst);
1768 if(!s) return;
1769
1770
1771
1772 for(n = 0 ; s[n].name ; n++)
1773 /* NOP */;
1774 d = malloc((n+1)*sizeof(m_obj_settings_t));
1775 for(n = 0 ; s[n].name ; n++) {
1776 d[n].name = strdup(s[n].name);
1777 d[n].attribs = NULL;
1778 copy_str_list(NULL,&(d[n].attribs),&(s[n].attribs));
1779 }
1780 d[n].name = NULL;
1781 d[n].attribs = NULL;
1782 VAL(dst) = d;
1783 }
1784
1785 m_option_type_t m_option_type_obj_settings_list = {
1786 "Object settings list",
1787 "",
1788 sizeof(m_obj_settings_t*),
1789 M_OPT_TYPE_DYNAMIC|M_OPT_TYPE_ALLOW_WILDCARD,
1790 parse_obj_settings_list,
1791 NULL,
1792 copy_obj_settings_list,
1793 copy_obj_settings_list,
1794 copy_obj_settings_list,
1795 free_obj_settings_list,
1796 };
1797
1798
1799
1800 static int parse_obj_presets(m_option_t* opt,char *name,
1801 char *param, void* dst, int src) {
1802 m_obj_presets_t* obj_p = (m_obj_presets_t*)opt->priv;
1803 m_struct_t *in_desc,*out_desc;
1804 int s,i;
1805 unsigned char* pre;
1806 char* pre_name = NULL;
1807
1808 if(!obj_p) {
1809 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Presets need a pointer to a m_obj_presets_t in the priv field.\n",name);
1810 return M_OPT_PARSER_ERR;
1811 }
1812
1813 if(!param)
1814 return M_OPT_MISSING_PARAM;
1815
1816 pre = obj_p->presets;
1817 in_desc = obj_p->in_desc;
1818 out_desc = obj_p->out_desc ? obj_p->out_desc : obj_p->in_desc;
1819 s = in_desc->size;
1820
1821 if(!strcmp(param,"help")) {
1822 mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available presets for %s->%s:",out_desc->name,name);
1823 for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1824 pre += s)
1825 mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1826 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1827 return M_OPT_EXIT - 1;
1828 }
1829
1830 for(pre_name = M_ST_MB(char*,pre,obj_p->name_off) ; pre_name ;
1831 pre += s, pre_name = M_ST_MB(char*,pre,obj_p->name_off)) {
1832 if(!strcmp(pre_name,param)) break;
1833 }
1834 if(!pre_name) {
1835 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: There is no preset named %s\n"
1836 "Available presets are:",name,param);
1837 for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1838 pre += s)
1839 mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1840 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1841 return M_OPT_INVALID;
1842 }
1843
1844 if(!dst) return 1;
1845
1846 for(i = 0 ; in_desc->fields[i].name ; i++) {
1847 m_option_t* out_opt = m_option_list_find(out_desc->fields,
1848 in_desc->fields[i].name);
1849 if(!out_opt) {
1850 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);
1851 return M_OPT_PARSER_ERR;
1852 }
1853 m_option_copy(out_opt,M_ST_MB_P(dst,out_opt->p),M_ST_MB_P(pre,in_desc->fields[i].p));
1854 }
1855 return 1;
1856 }
1857
1858
1859 m_option_type_t m_option_type_obj_presets = {
1860 "Object presets",
1861 "",
1862 0,
1863 0,
1864 parse_obj_presets,
1865 NULL,
1866 NULL,
1867 NULL,
1868 NULL,
1869 NULL
1870 };
1871
1872 static int parse_custom_url(m_option_t* opt,char *name,
1873 char *url, void* dst, int src) {
1874 int pos1, pos2, r, v6addr = 0;
1875 char *ptr1=NULL, *ptr2=NULL, *ptr3=NULL, *ptr4=NULL;
1876 m_struct_t* desc = opt->priv;
1877
1878 if(!desc) {
1879 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Custom URL needs a pointer to a m_struct_t in the priv field.\n",name);
1880 return M_OPT_PARSER_ERR;
1881 }
1882
1883 // extract the protocol
1884 ptr1 = strstr(url, "://");
1885 if( ptr1==NULL ) {
1886 // Filename only
1887 if(m_option_list_find(desc->fields,"filename")) {
1888 m_struct_set(desc,dst,"filename",url);
1889 return 1;
1890 }
1891 mp_msg(MSGT_CFGPARSER, MSGL_ERR,"Option %s: URL doesn't have a valid protocol!\n",name);
1892 return M_OPT_INVALID;
1893 }
1894 if(m_option_list_find(desc->fields,"string")) {
1895 if(strlen(ptr1)>3) {
1896 m_struct_set(desc,dst,"string",ptr1+3);
1897 return 1;
1898 }
1899 }
1900 pos1 = ptr1-url;
1901 if(dst && m_option_list_find(desc->fields,"protocol")) {
1902 ptr1[0] = '\0';
1903 r = m_struct_set(desc,dst,"protocol",url);
1904 ptr1[0] = ':';
1905 if(r < 0) {
1906 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting protocol.\n",name);
1907 return r;
1908 }
1909 }
1910
1911 // jump the "://"
1912 ptr1 += 3;
1913 pos1 += 3;
1914
1915 // check if a username:password is given
1916 ptr2 = strstr(ptr1, "@");
1917 ptr3 = strstr(ptr1, "/");
1918 if( ptr3!=NULL && ptr3<ptr2 ) {
1919 // it isn't really a username but rather a part of the path
1920 ptr2 = NULL;
1921 }
1922 if( ptr2!=NULL ) {
1923
1924 // We got something, at least a username...
1925 if(!m_option_list_find(desc->fields,"username")) {
1926 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a username part.\n",name);
1927 // skip
1928 } else {
1929 ptr3 = strstr(ptr1, ":");
1930 if( ptr3!=NULL && ptr3<ptr2 ) {
1931 // We also have a password
1932 if(!m_option_list_find(desc->fields,"password")) {
1933 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a password part.\n",name);
1934 // skip
1935 } else { // Username and password
1936 if(dst) {
1937 ptr3[0] = '\0';
1938 r = m_struct_set(desc,dst,"username",ptr1);
1939 ptr3[0] = ':';
1940 if(r < 0) {
1941 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
1942 return r;
1943 }
1944 ptr2[0] = '\0';
1945 r = m_struct_set(desc,dst,"password",ptr3+1);
1946 ptr2[0] = '@';
1947 if(r < 0) {
1948 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting password.\n",name);
1949 return r;
1950 }
1951 }
1952 }
1953 } else { // User name only
1954 ptr2[0] = '\0';
1955 r = m_struct_set(desc,dst,"username",ptr1);
1956 ptr2[0] = '@';
1957 if(r < 0) {
1958 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
1959 return r;
1960 }
1961 }
1962 }
1963 ptr1 = ptr2+1;
1964 pos1 = ptr1-url;
1965 }
1966
1967 // before looking for a port number check if we have an IPv6 type numeric address
1968 // in an IPv6 URL the numeric address should be inside square braces.
1969 ptr2 = strstr(ptr1, "[");
1970 ptr3 = strstr(ptr1, "]");
1971 // If the [] is after the first it isn't the hostname
1972 ptr4 = strstr(ptr1, "/");
1973 if( ptr2!=NULL && ptr3!=NULL && (ptr2 < ptr3) && (!ptr4 || ptr4 > ptr3)) {
1974 // we have an IPv6 numeric address
1975 ptr1++;
1976 pos1++;
1977 ptr2 = ptr3;
1978 v6addr = 1;
1979 } else {
1980 ptr2 = ptr1;
1981 }
1982
1983 // look if the port is given
1984 ptr2 = strstr(ptr2, ":");
1985 // If the : is after the first / it isn't the port
1986 ptr3 = strstr(ptr1, "/");
1987 if(ptr3 && ptr3 - ptr2 < 0) ptr2 = NULL;
1988 if( ptr2==NULL ) {
1989 // No port is given
1990 // Look if a path is given
1991 if( ptr3==NULL ) {
1992 // No path/filename
1993 // So we have an URL like http://www.hostname.com
1994 pos2 = strlen(url);
1995 } else {
1996 // We have an URL like http://www.hostname.com/file.txt
1997 pos2 = ptr3-url;
1998 }
1999 } else {
2000 // We have an URL beginning like http://www.hostname.com:1212
2001 // Get the port number
2002 if(!m_option_list_find(desc->fields,"port")) {
2003 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a port part.\n",name);
2004 // skip
2005 } else {
2006 if(dst) {
2007 int p = atoi(ptr2+1);
2008 char tmp[100];
2009 snprintf(tmp,99,"%d",p);
2010 r = m_struct_set(desc,dst,"port",tmp);
2011 if(r < 0) {
2012 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting port.\n",name);
2013 return r;
2014 }
2015 }
2016 }
2017 pos2 = ptr2-url;
2018 }
2019 if( v6addr ) pos2--;
2020 // Get the hostname
2021 if(pos2-pos1 > 0) {
2022 if(!m_option_list_find(desc->fields,"hostname")) {
2023 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
2024 // skip
2025 } else {
2026 char tmp[pos2-pos1+1];
2027 strncpy(tmp,ptr1, pos2-pos1);
2028 tmp[pos2-pos1] = '\0';
2029 r = m_struct_set(desc,dst,"hostname",tmp);
2030 if(r < 0) {
2031 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting hostname.\n",name);
2032 return r;
2033 }
2034 }
2035 }
2036 // Look if a path is given
2037 ptr2 = strstr(ptr1, "/");
2038 if( ptr2!=NULL ) {
2039 // A path/filename is given
2040 // check if it's not a trailing '/'
2041 if( strlen(ptr2)>1 ) {
2042 // copy the path/filename in the URL container
2043 if(!m_option_list_find(desc->fields,"filename")) {
2044 mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
2045 // skip
2046 } else {
2047 if(dst) {
2048 int l = strlen(ptr2+1) + 1;
2049 char* fname = ptr2+1;
2050 if(l > 1) {
2051 fname = malloc(l);
2052 url_unescape_string(fname,ptr2+1);
2053 }
2054 r = m_struct_set(desc,dst,"filename",fname);
2055 if(fname != ptr2+1)
2056 free(fname);
2057 if(r < 0) {
2058 mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting filename.\n",name);
2059 return r;
2060 }
2061 }
2062 }
2063 }
2064 }
2065 return 1;
2066 }
2067
2068 /// TODO : Write the other needed funcs for 'normal' options
2069 m_option_type_t m_option_type_custom_url = {
2070 "Custom URL",
2071 "",
2072 0,
2073 0,
2074 parse_custom_url,
2075 NULL,
2076 NULL,
2077 NULL,
2078 NULL,
2079 NULL
2080 };
MPlayer development branch