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