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