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