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