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