m_option.c

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