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   for( ; s != NULL ; s = s->next)
 785     ((m_opt_func_param_t) opt->p)(opt,s->param);
 786 }
 787
 788 const m_option_type_t m_option_type_func_param = {
 789   "Func param",
 790   "",
 791   sizeof(m_func_save_t*),
 792   M_OPT_TYPE_INDIRECT,
 793   parse_func_pf,
 794   NULL,
 795   NULL, // Nothing to do on save
 796   set_func_param,
 797   copy_func_pf,
 798   free_func_pf
 799 };
 800
 801 /////////////////// Func_full
 802
 803 static void set_func_full(const m_option_t* opt, void* dst, void* src) {
 804   m_func_save_t* s;
 805
 806   if(!src) return;
 807
 808   for(s = VAL(src) ; s ; s = s->next) {
 809     // Revert if needed
 810     if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,s->name);
 811     ((m_opt_func_full_t) opt->p)(opt,s->name,s->param);
 812   }
 813 }
 814
 815 const m_option_type_t m_option_type_func_full = {
 816   "Func full",
 817   "",
 818   sizeof(m_func_save_t*),
 819   M_OPT_TYPE_ALLOW_WILDCARD|M_OPT_TYPE_INDIRECT,
 820   parse_func_pf,
 821   NULL,
 822   NULL, // Nothing to do on save
 823   set_func_full,
 824   copy_func_pf,
 825   free_func_pf
 826 };
 827
 828 /////////////// Func
 829
 830 #undef VAL
 831
 832 static int parse_func(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
 833   return 0;
 834 }
 835
 836 static void set_func(const m_option_t* opt,void* dst, void* src) {
 837     ((m_opt_func_t) opt->p)(opt);
 838 }
 839
 840 const m_option_type_t m_option_type_func = {
 841   "Func",
 842   "",
 843   sizeof(int),
 844   M_OPT_TYPE_INDIRECT,
 845   parse_func,
 846   NULL,
 847   NULL, // Nothing to do on save
 848   set_func,
 849   NULL,
 850   NULL
 851 };
 852
 853 /////////////////// Print
 854
 855 static int parse_print(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
 856   if(opt->type == CONF_TYPE_PRINT_INDIRECT)
 857     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", *(char **) opt->p);
 858   else if(opt->type == CONF_TYPE_PRINT_FUNC)
 859     return ((m_opt_func_full_t) opt->p)(opt,name,param);
 860   else
 861     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", (char *) opt->p);
 862
 863   if(opt->priv == NULL)
 864     return M_OPT_EXIT;
 865   return 1;
 866 }
 867
 868 const m_option_type_t m_option_type_print = {
 869   "Print",
 870   "",
 871   0,
 872   0,
 873   parse_print,
 874   NULL,
 875   NULL,
 876   NULL,
 877   NULL,
 878   NULL
 879 };
 880
 881 const m_option_type_t m_option_type_print_indirect = {
 882   "Print",
 883   "",
 884   0,
 885   0,
 886   parse_print,
 887   NULL,
 888   NULL,
 889   NULL,
 890   NULL,
 891   NULL
 892 };
 893
 894 const m_option_type_t m_option_type_print_func = {
 895   "Print",
 896   "",
 897   0,
 898   M_OPT_TYPE_ALLOW_WILDCARD,
 899   parse_print,
 900   NULL,
 901   NULL,
 902   NULL,
 903   NULL,
 904   NULL
 905 };
 906
 907
 908 /////////////////////// Subconfig
 909 #undef VAL
 910 #define VAL(x) (*(char***)(x))
 911
 912 static int parse_subconf(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
 913   char *subparam;
 914   char *subopt;
 915   int nr = 0,i,r;
 916   const m_option_t *subopts;
 917   const char *p;
 918   char** lst = NULL;
 919
 920   if (param == NULL || strlen(param) == 0)
 921     return M_OPT_MISSING_PARAM;
 922
 923   subparam = malloc(strlen(param)+1);
 924   subopt = malloc(strlen(param)+1);
 925   p = param;
 926
 927   subopts = opt->p;
 928
 929   while(p[0])
 930     {
 931       int sscanf_ret = 1;
 932       int optlen = strcspn(p, ":=");
 933       /* clear out */
 934       subopt[0] = subparam[0] = 0;
 935       av_strlcpy(subopt, p, optlen + 1);
 936       p = &p[optlen];
 937       if (p[0] == '=') {
 938         sscanf_ret = 2;
 939         p = &p[1];
 940         if (p[0] == '"') {
 941           p = &p[1];
 942           optlen = strcspn(p, "\"");
 943           av_strlcpy(subparam, p, optlen + 1);
 944           p = &p[optlen];
 945           if (p[0] != '"') {
 946             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Terminating '\"' missing for '%s'\n", subopt);
 947             return M_OPT_INVALID;
 948           }
 949           p = &p[1];
 950         } else if (p[0] == '%') {
 951           p = &p[1];
 952           optlen = (int)strtol(p, (char**)&p, 0);
 953           if (!p || p[0] != '%' || (optlen > strlen(p) - 1)) {
 954             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid length %i for '%s'\n", optlen, subopt);
 955             return M_OPT_INVALID;
 956           }
 957           p = &p[1];
 958           av_strlcpy(subparam, p, optlen + 1);
 959           p = &p[optlen];
 960         } else {
 961           optlen = strcspn(p, ":");
 962           av_strlcpy(subparam, p, optlen + 1);
 963           p = &p[optlen];
 964         }
 965       }
 966       if (p[0] == ':')
 967         p = &p[1];
 968       else if (p[0]) {
 969         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Incorrect termination for '%s'\n", subopt);
 970         return M_OPT_INVALID;
 971       }
 972
 973       switch(sscanf_ret)
 974         {
 975         case 1:
 976           subparam[0] = 0;
 977         case 2:
 978           for(i = 0 ; subopts[i].name ; i++) {
 979             if(!strcmp(subopts[i].name,subopt)) break;
 980           }
 981           if(!subopts[i].name) {
 982             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Unknown suboption %s\n",name,subopt);
 983             return M_OPT_UNKNOWN;
 984           }
 985           r = m_option_parse(&subopts[i],subopt,
 986                              subparam[0] == 0 ? NULL : subparam,NULL,src);
 987           if(r < 0) return r;
 988           if(dst) {
 989             lst = (char**)realloc(lst,2 * (nr+2) * sizeof(char*));
 990             lst[2*nr] = strdup(subopt);
 991             lst[2*nr+1] = subparam[0] == 0 ? NULL : strdup(subparam);
 992             memset(&lst[2*(nr+1)],0,2*sizeof(char*));
 993             nr++;
 994           }
 995           break;
 996         }
 997     }
 998
 999   free(subparam);
1000   free(subopt);
1001   if(dst)
1002     VAL(dst) = lst;
1003
1004   return 1;
1005 }
1006
1007 const m_option_type_t m_option_type_subconfig = {
1008   "Subconfig",
1009   "The syntax is -option opt1=foo:flag:opt2=blah",
1010   sizeof(int),
1011   M_OPT_TYPE_HAS_CHILD,
1012   parse_subconf,
1013   NULL,
1014   NULL,
1015   NULL,
1016   NULL,
1017   NULL
1018 };
1019
1020 #include "libmpcodecs/img_format.h"
1021
1022 /* FIXME: snyc with img_format.h */
1023 static struct {
1024   const char* name;
1025   unsigned int fmt;
1026 } mp_imgfmt_list[] = {
1027   {"444p", IMGFMT_444P},
1028   {"422p", IMGFMT_422P},
1029   {"411p", IMGFMT_411P},
1030   {"yuy2", IMGFMT_YUY2},
1031   {"uyvy", IMGFMT_UYVY},
1032   {"yvu9", IMGFMT_YVU9},
1033   {"if09", IMGFMT_IF09},
1034   {"yv12", IMGFMT_YV12},
1035   {"i420", IMGFMT_I420},
1036   {"iyuv", IMGFMT_IYUV},
1037   {"clpl", IMGFMT_CLPL},
1038   {"hm12", IMGFMT_HM12},
1039   {"y800", IMGFMT_Y800},
1040   {"y8", IMGFMT_Y8},
1041   {"nv12", IMGFMT_NV12},
1042   {"nv21", IMGFMT_NV21},
1043   {"bgr24", IMGFMT_BGR24},
1044   {"bgr32", IMGFMT_BGR32},
1045   {"bgr16", IMGFMT_BGR16},
1046   {"bgr15", IMGFMT_BGR15},
1047   {"bgr8", IMGFMT_BGR8},
1048   {"bgr4", IMGFMT_BGR4},
1049   {"bg4b", IMGFMT_BG4B},
1050   {"bgr1", IMGFMT_BGR1},
1051   {"rgb24", IMGFMT_RGB24},
1052   {"rgb32", IMGFMT_RGB32},
1053   {"rgb16", IMGFMT_RGB16},
1054   {"rgb15", IMGFMT_RGB15},
1055   {"rgb8", IMGFMT_RGB8},
1056   {"rgb4", IMGFMT_RGB4},
1057   {"rg4b", IMGFMT_RG4B},
1058   {"rgb1", IMGFMT_RGB1},
1059   {"rgba", IMGFMT_RGBA},
1060   {"argb", IMGFMT_ARGB},
1061   {"bgra", IMGFMT_BGRA},
1062   {"abgr", IMGFMT_ABGR},
1063   {"mjpeg", IMGFMT_MJPEG},
1064   {"mjpg", IMGFMT_MJPEG},
1065   { NULL, 0 }
1066 };
1067
1068 static int parse_imgfmt(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
1069   uint32_t fmt = 0;
1070   int i;
1071
1072   if (param == NULL || strlen(param) == 0)
1073     return M_OPT_MISSING_PARAM;
1074
1075   if(!strcmp(param,"help")) {
1076     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1077     for(i = 0 ; mp_imgfmt_list[i].name ; i++)
1078       mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_imgfmt_list[i].name);
1079     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1080     return M_OPT_EXIT - 1;
1081   }
1082
1083   if (sscanf(param, "0x%x", &fmt) != 1)
1084   {
1085   for(i = 0 ; mp_imgfmt_list[i].name ; i++) {
1086     if(!strcasecmp(param,mp_imgfmt_list[i].name)) {
1087       fmt=mp_imgfmt_list[i].fmt;
1088       break;
1089     }
1090   }
1091   if(!mp_imgfmt_list[i].name) {
1092     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1093     return M_OPT_INVALID;
1094   }
1095   }
1096
1097   if(dst)
1098     *((uint32_t*)dst) = fmt;
1099
1100   return 1;
1101 }
1102
1103 const m_option_type_t m_option_type_imgfmt = {
1104   "Image format",
1105   "Please report any missing colorspaces.",
1106   sizeof(uint32_t),
1107   0,
1108   parse_imgfmt,
1109   NULL,
1110   copy_opt,
1111   copy_opt,
1112   NULL,
1113   NULL
1114 };
1115
1116 #include "libaf/af_format.h"
1117
1118 /* FIXME: snyc with af_format.h */
1119 static struct {
1120   const char* name;
1121   unsigned int fmt;
1122 } mp_afmt_list[] = {
1123   // SPECIAL
1124   {"mulaw", AF_FORMAT_MU_LAW},
1125   {"alaw", AF_FORMAT_A_LAW},
1126   {"mpeg2", AF_FORMAT_MPEG2},
1127   {"ac3", AF_FORMAT_AC3},
1128   {"imaadpcm", AF_FORMAT_IMA_ADPCM},
1129   // ORIDNARY
1130   {"u8", AF_FORMAT_U8},
1131   {"s8", AF_FORMAT_S8},
1132   {"u16le", AF_FORMAT_U16_LE},
1133   {"u16be", AF_FORMAT_U16_BE},
1134   {"u16ne", AF_FORMAT_U16_NE},
1135   {"s16le", AF_FORMAT_S16_LE},
1136   {"s16be", AF_FORMAT_S16_BE},
1137   {"s16ne", AF_FORMAT_S16_NE},
1138   {"u24le", AF_FORMAT_U24_LE},
1139   {"u24be", AF_FORMAT_U24_BE},
1140   {"u24ne", AF_FORMAT_U24_NE},
1141   {"s24le", AF_FORMAT_S24_LE},
1142   {"s24be", AF_FORMAT_S24_BE},
1143   {"s24ne", AF_FORMAT_S24_NE},
1144   {"u32le", AF_FORMAT_U32_LE},
1145   {"u32be", AF_FORMAT_U32_BE},
1146   {"u32ne", AF_FORMAT_U32_NE},
1147   {"s32le", AF_FORMAT_S32_LE},
1148   {"s32be", AF_FORMAT_S32_BE},
1149   {"s32ne", AF_FORMAT_S32_NE},
1150   {"floatle", AF_FORMAT_FLOAT_LE},
1151   {"floatbe", AF_FORMAT_FLOAT_BE},
1152   {"floatne", AF_FORMAT_FLOAT_NE},
1153   { NULL, 0 }
1154 };
1155
1156 static int parse_afmt(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
1157   uint32_t fmt = 0;
1158   int i;
1159
1160   if (param == NULL || strlen(param) == 0)
1161     return M_OPT_MISSING_PARAM;
1162
1163   if(!strcmp(param,"help")) {
1164     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1165     for(i = 0 ; mp_afmt_list[i].name ; i++)
1166       mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_afmt_list[i].name);
1167     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1168     return M_OPT_EXIT - 1;
1169   }
1170
1171   if (sscanf(param, "0x%x", &fmt) != 1)
1172   {
1173   for(i = 0 ; mp_afmt_list[i].name ; i++) {
1174     if(!strcasecmp(param,mp_afmt_list[i].name)) {
1175       fmt=mp_afmt_list[i].fmt;
1176       break;
1177     }
1178   }
1179   if(!mp_afmt_list[i].name) {
1180     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1181     return M_OPT_INVALID;
1182   }
1183   }
1184
1185   if(dst)
1186     *((uint32_t*)dst) = fmt;
1187
1188   return 1;
1189 }
1190
1191 const m_option_type_t m_option_type_afmt = {
1192   "Audio format",
1193   "Please report any missing formats.",
1194   sizeof(uint32_t),
1195   0,
1196   parse_afmt,
1197   NULL,
1198   copy_opt,
1199   copy_opt,
1200   NULL,
1201   NULL
1202 };
1203
1204
1205 static double parse_timestring(const char *str)
1206 {
1207   int a, b;
1208   double d;
1209   if (sscanf(str, "%d:%d:%lf", &a, &b, &d) == 3)
1210     return 3600*a + 60*b + d;
1211   else if (sscanf(str, "%d:%lf", &a, &d) == 2)
1212     return 60*a + d;
1213   else if (sscanf(str, "%lf", &d) == 1)
1214     return d;
1215   return -1e100;
1216 }
1217
1218
1219 static int parse_time(const m_option_t* opt,const char *name, char *param, void* dst, int src)
1220 {
1221   double time;
1222
1223   if (param == NULL || strlen(param) == 0)
1224     return M_OPT_MISSING_PARAM;
1225
1226   time = parse_timestring(param);
1227   if (time == -1e100) {
1228     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: invalid time: '%s'\n",
1229            name,param);
1230     return M_OPT_INVALID;
1231   }
1232
1233   if (dst)
1234     *(double *)dst = time;
1235   return 1;
1236 }
1237
1238 const m_option_type_t m_option_type_time = {
1239   "Time",
1240   "",
1241   sizeof(double),
1242   0,
1243   parse_time,
1244   print_double,
1245   copy_opt,
1246   copy_opt,
1247   NULL,
1248   NULL
1249 };
1250
1251
1252 // Time or size (-endpos)
1253
1254 static int parse_time_size(const m_option_t* opt,const char *name, char *param, void* dst, int src) {
1255   m_time_size_t ts;
1256   char unit[4];
1257   double end_at;
1258
1259   if (param == NULL || strlen(param) == 0)
1260     return M_OPT_MISSING_PARAM;
1261
1262   ts.pos=0;
1263   /* End at size parsing */
1264   if(sscanf(param, "%lf%3s", &end_at, unit) == 2) {
1265     ts.type = END_AT_SIZE;
1266     if(!strcasecmp(unit, "b"))
1267       ;
1268     else if(!strcasecmp(unit, "kb"))
1269       end_at *= 1024;
1270     else if(!strcasecmp(unit, "mb"))
1271       end_at *= 1024*1024;
1272     else if(!strcasecmp(unit, "gb"))
1273       end_at *= 1024*1024*1024;
1274     else
1275       ts.type = END_AT_NONE;
1276
1277     if (ts.type == END_AT_SIZE) {
1278       ts.pos  = end_at;
1279       goto out;
1280     }
1281   }
1282
1283   /* End at time parsing. This has to be last because the parsing accepts
1284    * even a number followed by garbage */
1285   if ((end_at = parse_timestring(param)) == -1e100) {
1286     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: invalid time or size: '%s'\n",
1287            name,param);
1288     return M_OPT_INVALID;
1289   }
1290
1291   ts.type = END_AT_TIME;
1292   ts.pos  = end_at;
1293 out:
1294   if(dst)
1295     *(m_time_size_t *)dst = ts;
1296   return 1;
1297 }
1298
1299 const m_option_type_t m_option_type_time_size = {
1300   "Time or size",
1301   "",
1302   sizeof(m_time_size_t),
1303   0,
1304   parse_time_size,
1305   NULL,
1306   copy_opt,
1307   copy_opt,
1308   NULL,
1309   NULL
1310 };
1311
1312
1313 //// Objects (i.e. filters, etc) settings
1314
1315 #include "m_struct.h"
1316
1317 #undef VAL
1318 #define VAL(x) (*(m_obj_settings_t**)(x))
1319
1320 static int find_obj_desc(const char* name,const m_obj_list_t* l,const m_struct_t** ret) {
1321   int i;
1322   char* n;
1323
1324   for(i = 0 ; l->list[i] ; i++) {
1325     n = M_ST_MB(char*,l->list[i],l->name_off);
1326     if(!strcmp(n,name)) {
1327       *ret = M_ST_MB(m_struct_t*,l->list[i],l->desc_off);
1328       return 1;
1329     }
1330   }
1331   return 0;
1332 }
1333
1334 static int get_obj_param(const char* opt_name,const char* obj_name, const m_struct_t* desc,
1335                          char* str,int* nold,int oldmax,char** dst) {
1336   char* eq;
1337   const m_option_t* opt;
1338   int r;
1339
1340   eq = strchr(str,'=');
1341   if(eq && eq == str)
1342     eq = NULL;
1343
1344   if(eq) {
1345     char* p = eq + 1;
1346     if(p[0] == '\0') p = NULL;
1347     eq[0] = '\0';
1348     opt = m_option_list_find(desc->fields,str);
1349     if(!opt) {
1350       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't have a %s parameter.\n",opt_name,obj_name,str);
1351       return M_OPT_UNKNOWN;
1352     }
1353     r = m_option_parse(opt,str,p,NULL,M_CONFIG_FILE);
1354     if(r < 0) {
1355       if(r > M_OPT_EXIT)
1356         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,str,p);
1357       eq[0] = '=';
1358       return r;
1359     }
1360     if(dst) {
1361       dst[0] = strdup(str);
1362       dst[1] = p ? strdup(p) : NULL;
1363     }
1364     eq[0] = '=';
1365   } else {
1366     if((*nold) >= oldmax) {
1367       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
1368              opt_name,obj_name,oldmax,oldmax);
1369       return M_OPT_OUT_OF_RANGE;
1370     }
1371     opt = &desc->fields[(*nold)];
1372     r = m_option_parse(opt,opt->name,str,NULL,M_CONFIG_FILE);
1373     if(r < 0) {
1374       if(r > M_OPT_EXIT)
1375         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,opt->name,str);
1376       return r;
1377     }
1378     if(dst) {
1379       dst[0] = strdup(opt->name);
1380       dst[1] = strdup(str);
1381     }
1382     (*nold)++;
1383   }
1384   return 1;
1385 }
1386
1387 static int get_obj_params(const char* opt_name, const char* name,char* params,
1388                           const m_struct_t* desc,char separator, char*** _ret) {
1389   int n = 0,nold = 0, nopts,r;
1390   char* ptr,*last_ptr = params;
1391   char** ret;
1392
1393   if(!strcmp(params,"help")) { // Help
1394     char min[50],max[50];
1395     if(!desc->fields) {
1396       printf("%s doesn't have any options.\n\n",name);
1397       return M_OPT_EXIT - 1;
1398     }
1399     printf("\n Name                 Type            Min        Max\n\n");
1400     for(n = 0 ; desc->fields[n].name ; n++) {
1401       const m_option_t* opt = &desc->fields[n];
1402       if(opt->type->flags & M_OPT_TYPE_HAS_CHILD) continue;
1403       if(opt->flags & M_OPT_MIN)
1404         sprintf(min,"%-8.0f",opt->min);
1405       else
1406         strcpy(min,"No");
1407       if(opt->flags & M_OPT_MAX)
1408         sprintf(max,"%-8.0f",opt->max);
1409       else
1410         strcpy(max,"No");
1411       printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
1412              opt->name,
1413              opt->type->name,
1414              min,
1415              max);
1416     }
1417     printf("\n");
1418     return M_OPT_EXIT - 1;
1419   }
1420
1421   for(nopts = 0 ; desc->fields[nopts].name ; nopts++)
1422     /* NOP */;
1423
1424   // TODO : Check that each opt can be parsed
1425   r = 1;
1426   while(last_ptr && last_ptr[0] != '\0') {
1427     ptr = strchr(last_ptr,separator);
1428     if(!ptr) {
1429       r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1430       n++;
1431       break;
1432     }
1433     if(ptr == last_ptr) { // Empty field, count it and go on
1434       nold++;
1435       last_ptr = ptr+1;
1436       continue;
1437     }
1438     ptr[0] = '\0';
1439     r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1440     ptr[0] = separator;
1441     if(r < 0) break;
1442     n++;
1443     last_ptr = ptr+1;
1444   }
1445   if(r < 0) return r;
1446   if (!last_ptr[0]) // count an empty field at the end, too
1447     nold++;
1448   if (nold > nopts) {
1449     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Too many options for %s\n", name);
1450     return M_OPT_OUT_OF_RANGE;
1451   }
1452   if(!_ret) // Just test
1453     return 1;
1454   if (n == 0) // No options or only empty options
1455     return 1;
1456
1457   ret = malloc((n+2)*2*sizeof(char*));
1458   n = nold = 0;
1459   last_ptr = params;
1460
1461   while(last_ptr && last_ptr[0] != '\0') {
1462     ptr = strchr(last_ptr,separator);
1463     if(!ptr) {
1464       get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1465       n++;
1466       break;
1467     }
1468     if(ptr == last_ptr) { // Empty field, count it and go on
1469       last_ptr = ptr+1;
1470       nold++;
1471       continue;
1472     }
1473     ptr[0] = '\0';
1474     get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1475     n++;
1476     last_ptr = ptr+1;
1477   }
1478   ret[n*2] = ret[n*2+1] = NULL;
1479   *_ret = ret;
1480
1481   return 1;
1482 }
1483
1484 static int parse_obj_params(const m_option_t* opt,const char *name,
1485                             char *param, void* dst, int src) {
1486   char** opts;
1487   int r;
1488   m_obj_params_t* p = opt->priv;
1489   const m_struct_t* desc;
1490   char* cpy;
1491
1492   // We need the object desc
1493   if(!p)
1494     return M_OPT_INVALID;
1495
1496   desc = p->desc;
1497   cpy = strdup(param);
1498   r = get_obj_params(name,desc->name,cpy,desc,p->separator,dst ? &opts : NULL);
1499   free(cpy);
1500   if(r < 0)
1501     return r;
1502   if(!dst)
1503     return 1;
1504   if (!opts) // no arguments given
1505     return 1;
1506
1507   for(r = 0 ; opts[r] ; r += 2)
1508     m_struct_set(desc,dst,opts[r],opts[r+1]);
1509
1510   return 1;
1511 }
1512
1513
1514 const m_option_type_t m_option_type_obj_params = {
1515   "Object params",
1516   "",
1517   0,
1518   0,
1519   parse_obj_params,
1520   NULL,
1521   NULL,
1522   NULL,
1523   NULL,
1524   NULL
1525 };
1526
1527 /// Some predefined types as a definition would be quite lengthy
1528
1529 /// Span arguments
1530 static const m_span_t m_span_params_dflts = { -1, -1 };
1531 static const m_option_t m_span_params_fields[] = {
1532   {"start", M_ST_OFF(m_span_t,start), CONF_TYPE_INT, M_OPT_MIN, 1 ,0, NULL},
1533   {"end", M_ST_OFF(m_span_t,end), CONF_TYPE_INT, M_OPT_MIN , 1 ,0, NULL},
1534   { NULL, NULL, 0, 0, 0, 0,  NULL }
1535 };
1536 static const struct m_struct_st m_span_opts = {
1537   "m_span",
1538   sizeof(m_span_t),
1539   &m_span_params_dflts,
1540   m_span_params_fields
1541 };
1542 const m_obj_params_t m_span_params_def = {
1543   &m_span_opts,
1544   '-'
1545 };
1546
1547 static int parse_obj_settings(const char* opt,char* str,const m_obj_list_t* list,
1548                               m_obj_settings_t **_ret, int ret_n) {
1549   int r;
1550   char *param,**plist = NULL;
1551   const m_struct_t* desc;
1552   m_obj_settings_t *ret = _ret ? *_ret : NULL;
1553
1554
1555   // Now check that the object exists
1556   param = strchr(str,'=');
1557   if(param) {
1558     param[0] = '\0';
1559     param++;
1560     if(strlen(param) <= 0)
1561       param = NULL;
1562   }
1563
1564
1565   if(!find_obj_desc(str,list,&desc)) {
1566     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't exist.\n",opt,str);
1567     return M_OPT_INVALID;
1568   }
1569
1570   if(param) {
1571     if(!desc && _ret) {
1572       if(!strcmp(param,"help")) {
1573         mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Option %s: %s have no option description.\n",opt,str);
1574         return M_OPT_EXIT - 1;
1575       }
1576       plist = calloc(4,sizeof(char*));
1577       plist[0] = strdup("_oldargs_");
1578       plist[1] = strdup(param);
1579     } else if(desc) {
1580       r = get_obj_params(opt,str,param,desc,':',_ret ? &plist : NULL);
1581       if(r < 0)
1582         return r;
1583     }
1584   }
1585   if(!_ret)
1586     return 1;
1587
1588   ret = realloc(ret,(ret_n+2)*sizeof(m_obj_settings_t));
1589   memset(&ret[ret_n],0,2*sizeof(m_obj_settings_t));
1590   ret[ret_n].name = strdup(str);
1591   ret[ret_n].attribs = plist;
1592
1593   *_ret = ret;
1594   return 1;
1595 }
1596
1597 static void free_obj_settings_list(void* dst);
1598
1599 static int obj_settings_list_del(const char *opt_name,char *param,void* dst, int src) {
1600   char** str_list = NULL;
1601   int r,i,idx_max = 0;
1602   char* rem_id = "_removed_marker_";
1603   const m_option_t list_opt = {opt_name , NULL, CONF_TYPE_STRING_LIST,
1604                            0, 0, 0, NULL };
1605   m_obj_settings_t* obj_list = dst ? VAL(dst) : NULL;
1606
1607   if(dst && !obj_list) {
1608     mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: the list is empty.\n",opt_name);
1609     return 1;
1610   } else if(obj_list) {
1611     for(idx_max = 0 ; obj_list[idx_max].name != NULL ; idx_max++)
1612       /* NOP */;
1613   }
1614
1615   r = m_option_parse(&list_opt,opt_name,param,&str_list,src);
1616   if(r < 0 || !str_list)
1617     return r;
1618
1619   for(r = 0 ; str_list[r] ; r++) {
1620     int id;
1621     char* endptr;
1622     id = strtol(str_list[r],&endptr,0);
1623     if(endptr == str_list[r]) {
1624       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);
1625       m_option_free(&list_opt,&str_list);
1626       return M_OPT_INVALID;
1627     }
1628     if(!obj_list) continue;
1629     if(id >= idx_max || id < -idx_max) {
1630       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: Index %d is out of range.\n",opt_name,id);
1631       continue;
1632     }
1633     if(id < 0)
1634       id = idx_max + id;
1635     free(obj_list[id].name);
1636     free_str_list(&(obj_list[id].attribs));
1637     obj_list[id].name = rem_id;
1638   }
1639
1640   if(!dst) {
1641     m_option_free(&list_opt,&str_list);
1642     return 1;
1643   }
1644
1645   for(i = 0 ; obj_list[i].name ; i++) {
1646     while(obj_list[i].name == rem_id) {
1647       memmove(&obj_list[i],&obj_list[i+1],sizeof(m_obj_settings_t)*(idx_max - i));
1648       idx_max--;
1649     }
1650   }
1651   obj_list = realloc(obj_list,sizeof(m_obj_settings_t)*(idx_max+1));
1652   VAL(dst) = obj_list;
1653
1654   return 1;
1655 }
1656
1657 static int parse_obj_settings_list(const m_option_t* opt,const char *name,
1658                                    char *param, void* dst, int src) {
1659   int n = 0,r,len = strlen(opt->name);
1660   char *str;
1661   char *ptr, *last_ptr;
1662   m_obj_settings_t *res = NULL,*queue = NULL,*head = NULL;
1663   int op = OP_NONE;
1664
1665   // We need the objects list
1666   if(!opt->priv)
1667     return M_OPT_INVALID;
1668
1669   if(opt->name[len-1] == '*' && ((int)strlen(name) > len - 1)) {
1670     const char* n = &name[len-1];
1671     if(strcasecmp(n,"-add") == 0)
1672       op = OP_ADD;
1673     else if(strcasecmp(n,"-pre") == 0)
1674       op = OP_PRE;
1675     else if(strcasecmp(n,"-del") == 0)
1676       op = OP_DEL;
1677     else if(strcasecmp(n,"-clr") == 0)
1678       op = OP_CLR;
1679     else {
1680       char prefix[len];
1681       strncpy(prefix,opt->name,len-1);
1682       prefix[len-1] = '\0';
1683       mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: unknown postfix %s\n"
1684              "Supported postfixes are:\n"
1685              "  %s-add\n"
1686              " Append the given list to the current list\n\n"
1687              "  %s-pre\n"
1688              " Prepend the given list to the current list\n\n"
1689              "  %s-del x,y,...\n"
1690              " Remove the given elements. Take the list element index (starting from 0).\n"
1691              " Negative index can be used (i.e. -1 is the last element)\n\n"
1692              "  %s-clr\n"
1693              " Clear the current list.\n",name,n,prefix,prefix,prefix,prefix);
1694
1695       return M_OPT_UNKNOWN;
1696     }
1697   }
1698
1699   // Clear the list ??
1700   if(op == OP_CLR) {
1701     if(dst)
1702       free_obj_settings_list(dst);
1703     return 0;
1704   }
1705
1706   if (param == NULL || strlen(param) == 0)
1707     return M_OPT_MISSING_PARAM;
1708
1709   switch(op) {
1710   case OP_ADD:
1711     if(dst) head = VAL(dst);
1712     break;
1713   case OP_PRE:
1714     if(dst) queue = VAL(dst);
1715      break;
1716   case OP_DEL:
1717     return obj_settings_list_del(name,param,dst,src);
1718   case OP_NONE:
1719     if(dst && VAL(dst))
1720       free_obj_settings_list(dst);
1721     break;
1722   default:
1723     mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: FIXME\n",name);
1724     return M_OPT_UNKNOWN;
1725   }
1726
1727   if(!strcmp(param,"help")) {
1728     m_obj_list_t* ol = opt->priv;
1729     mp_msg(MSGT_VFILTER,MSGL_INFO,"Available video filters:\n");
1730     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_FILTERS\n");
1731     for(n = 0 ; ol->list[n] ; n++)
1732       mp_msg(MSGT_VFILTER,MSGL_INFO,"  %-15s: %s\n",
1733              M_ST_MB(char*,ol->list[n],ol->name_off),
1734              M_ST_MB(char*,ol->list[n],ol->info_off));
1735     mp_msg(MSGT_VFILTER,MSGL_INFO,"\n");
1736     return M_OPT_EXIT - 1;
1737   }
1738   ptr = str = strdup(param);
1739
1740   while(ptr[0] != '\0') {
1741     last_ptr = ptr;
1742     ptr = get_nextsep(ptr, LIST_SEPARATOR, 1);
1743
1744     if(!ptr) {
1745       r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1746       if(r < 0) {
1747         free(str);
1748         return r;
1749       }
1750       n++;
1751       break;
1752     }
1753     ptr[0] = '\0';
1754     r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1755     if(r < 0) {
1756       free(str);
1757       return r;
1758     }
1759     ptr++;
1760     n++;
1761   }
1762   free(str);
1763   if(n == 0)
1764     return M_OPT_INVALID;
1765
1766   if( ((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
1767       ((opt->flags & M_OPT_MAX) && (n > opt->max)) )
1768     return M_OPT_OUT_OF_RANGE;
1769
1770   if(dst) {
1771     if(queue) {
1772       int qsize;
1773       for(qsize = 0 ; queue[qsize].name ; qsize++)
1774         /* NOP */;
1775       res = realloc(res,(qsize+n+1)*sizeof(m_obj_settings_t));
1776       memcpy(&res[n],queue,(qsize+1)*sizeof(m_obj_settings_t));
1777       n += qsize;
1778       free(queue);
1779     }
1780     if(head) {
1781       int hsize;
1782       for(hsize = 0 ; head[hsize].name ; hsize++)
1783         /* NOP */;
1784       head = realloc(head,(hsize+n+1)*sizeof(m_obj_settings_t));
1785       memcpy(&head[hsize],res,(n+1)*sizeof(m_obj_settings_t));
1786       free(res);
1787       res = head;
1788     }
1789     VAL(dst) = res;
1790   }
1791   return 1;
1792 }
1793
1794 static void free_obj_settings_list(void* dst) {
1795   int n;
1796   m_obj_settings_t *d;
1797
1798   if(!dst || !VAL(dst)) return;
1799
1800   d = VAL(dst);
1801 #ifndef NO_FREE
1802   for(n = 0 ; d[n].name ; n++) {
1803     free(d[n].name);
1804     free_str_list(&(d[n].attribs));
1805   }
1806   free(d);
1807 #endif
1808   VAL(dst) = NULL;
1809 }
1810
1811 static void copy_obj_settings_list(const m_option_t* opt,void* dst, void* src) {
1812   m_obj_settings_t *d,*s;
1813   int n;
1814
1815   if(!(dst && src))
1816     return;
1817
1818   s = VAL(src);
1819
1820   if(VAL(dst))
1821     free_obj_settings_list(dst);
1822   if(!s) return;
1823
1824
1825
1826   for(n = 0 ; s[n].name ; n++)
1827     /* NOP */;
1828   d = malloc((n+1)*sizeof(m_obj_settings_t));
1829   for(n = 0 ; s[n].name ; n++) {
1830     d[n].name = strdup(s[n].name);
1831     d[n].attribs = NULL;
1832     copy_str_list(NULL,&(d[n].attribs),&(s[n].attribs));
1833   }
1834   d[n].name = NULL;
1835   d[n].attribs = NULL;
1836   VAL(dst) = d;
1837 }
1838
1839 const m_option_type_t m_option_type_obj_settings_list = {
1840   "Object settings list",
1841   "",
1842   sizeof(m_obj_settings_t*),
1843   M_OPT_TYPE_DYNAMIC|M_OPT_TYPE_ALLOW_WILDCARD,
1844   parse_obj_settings_list,
1845   NULL,
1846   copy_obj_settings_list,
1847   copy_obj_settings_list,
1848   copy_obj_settings_list,
1849   free_obj_settings_list,
1850 };
1851
1852
1853
1854 static int parse_obj_presets(const m_option_t* opt,const char *name,
1855                             char *param, void* dst, int src) {
1856   m_obj_presets_t* obj_p = (m_obj_presets_t*)opt->priv;
1857   m_struct_t *in_desc,*out_desc;
1858   int s,i;
1859   unsigned char* pre;
1860   char* pre_name = NULL;
1861
1862   if(!obj_p) {
1863     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Presets need a pointer to a m_obj_presets_t in the priv field.\n",name);
1864     return M_OPT_PARSER_ERR;
1865   }
1866
1867   if(!param)
1868     return M_OPT_MISSING_PARAM;
1869
1870   pre = obj_p->presets;
1871   in_desc = obj_p->in_desc;
1872   out_desc = obj_p->out_desc ? obj_p->out_desc : obj_p->in_desc;
1873   s = in_desc->size;
1874
1875   if(!strcmp(param,"help")) {
1876     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available presets for %s->%s:",out_desc->name,name);
1877     for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1878         pre +=  s)
1879       mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1880     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1881     return M_OPT_EXIT - 1;
1882   }
1883
1884   for(pre_name = M_ST_MB(char*,pre,obj_p->name_off) ; pre_name ;
1885       pre +=  s, pre_name = M_ST_MB(char*,pre,obj_p->name_off)) {
1886     if(!strcmp(pre_name,param)) break;
1887   }
1888   if(!pre_name) {
1889     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: There is no preset named %s\n"
1890            "Available presets are:",name,param);
1891     for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1892         pre +=  s)
1893       mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1894     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1895     return M_OPT_INVALID;
1896   }
1897
1898   if(!dst) return 1;
1899
1900   for(i = 0 ; in_desc->fields[i].name ; i++) {
1901     const m_option_t* out_opt = m_option_list_find(out_desc->fields,
1902                                              in_desc->fields[i].name);
1903     if(!out_opt) {
1904       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);
1905       return M_OPT_PARSER_ERR;
1906     }
1907     m_option_copy(out_opt,M_ST_MB_P(dst,out_opt->p),M_ST_MB_P(pre,in_desc->fields[i].p));
1908   }
1909   return 1;
1910 }
1911
1912
1913 const m_option_type_t m_option_type_obj_presets = {
1914   "Object presets",
1915   "",
1916   0,
1917   0,
1918   parse_obj_presets,
1919   NULL,
1920   NULL,
1921   NULL,
1922   NULL,
1923   NULL
1924 };
1925
1926 static int parse_custom_url(const m_option_t* opt,const char *name,
1927                             char *url, void* dst, int src) {
1928   int pos1, pos2, r, v6addr = 0;
1929   char *ptr1=NULL, *ptr2=NULL, *ptr3=NULL, *ptr4=NULL;
1930   m_struct_t* desc = opt->priv;
1931
1932   if(!desc) {
1933     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Custom URL needs a pointer to a m_struct_t in the priv field.\n",name);
1934     return M_OPT_PARSER_ERR;
1935   }
1936
1937   // extract the protocol
1938   ptr1 = strstr(url, "://");
1939   if( ptr1==NULL ) {
1940     // Filename only
1941     if(m_option_list_find(desc->fields,"filename")) {
1942       m_struct_set(desc,dst,"filename",url);
1943       return 1;
1944     }
1945     mp_msg(MSGT_CFGPARSER, MSGL_ERR,"Option %s: URL doesn't have a valid protocol!\n",name);
1946     return M_OPT_INVALID;
1947   }
1948   if(m_option_list_find(desc->fields,"string")) {
1949     if(strlen(ptr1)>3) {
1950       m_struct_set(desc,dst,"string",ptr1+3);
1951       return 1;
1952     }
1953   }
1954   pos1 = ptr1-url;
1955   if(dst && m_option_list_find(desc->fields,"protocol")) {
1956     ptr1[0] = '\0';
1957     r = m_struct_set(desc,dst,"protocol",url);
1958     ptr1[0] = ':';
1959     if(r < 0) {
1960       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting protocol.\n",name);
1961       return r;
1962     }
1963   }
1964
1965   // jump the "://"
1966   ptr1 += 3;
1967   pos1 += 3;
1968
1969   // check if a username:password is given
1970   ptr2 = strstr(ptr1, "@");
1971   ptr3 = strstr(ptr1, "/");
1972   if( ptr3!=NULL && ptr3<ptr2 ) {
1973     // it isn't really a username but rather a part of the path
1974     ptr2 = NULL;
1975   }
1976   if( ptr2!=NULL ) {
1977
1978     // We got something, at least a username...
1979     if(!m_option_list_find(desc->fields,"username")) {
1980       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a username part.\n",name);
1981       // skip
1982     } else {
1983       ptr3 = strstr(ptr1, ":");
1984       if( ptr3!=NULL && ptr3<ptr2 ) {
1985         // We also have a password
1986         if(!m_option_list_find(desc->fields,"password")) {
1987           mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a password part.\n",name);
1988           // skip
1989         } else { // Username and password
1990           if(dst) {
1991             ptr3[0] = '\0';
1992             r = m_struct_set(desc,dst,"username",ptr1);
1993             ptr3[0] = ':';
1994             if(r < 0) {
1995               mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
1996               return r;
1997             }
1998             ptr2[0] = '\0';
1999             r = m_struct_set(desc,dst,"password",ptr3+1);
2000             ptr2[0] = '@';
2001             if(r < 0) {
2002               mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting password.\n",name);
2003               return r;
2004             }
2005           }
2006         }
2007       } else { // User name only
2008         ptr2[0] = '\0';
2009         r = m_struct_set(desc,dst,"username",ptr1);
2010         ptr2[0] = '@';
2011         if(r < 0) {
2012           mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
2013           return r;
2014         }
2015       }
2016     }
2017     ptr1 = ptr2+1;
2018     pos1 = ptr1-url;
2019   }
2020
2021   // before looking for a port number check if we have an IPv6 type numeric address
2022   // in an IPv6 URL the numeric address should be inside square braces.
2023   ptr2 = strstr(ptr1, "[");
2024   ptr3 = strstr(ptr1, "]");
2025   // If the [] is after the first it isn't the hostname
2026   ptr4 = strstr(ptr1, "/");
2027   if( ptr2!=NULL && ptr3!=NULL && (ptr2 < ptr3) && (!ptr4 || ptr4 > ptr3)) {
2028     // we have an IPv6 numeric address
2029     ptr1++;
2030     pos1++;
2031     ptr2 = ptr3;
2032     v6addr = 1;
2033   } else {
2034     ptr2 = ptr1;
2035   }
2036
2037   // look if the port is given
2038   ptr2 = strstr(ptr2, ":");
2039   // If the : is after the first / it isn't the port
2040   ptr3 = strstr(ptr1, "/");
2041   if(ptr3 && ptr3 - ptr2 < 0) ptr2 = NULL;
2042   if( ptr2==NULL ) {
2043     // No port is given
2044     // Look if a path is given
2045     if( ptr3==NULL ) {
2046       // No path/filename
2047       // So we have an URL like http://www.hostname.com
2048       pos2 = strlen(url);
2049     } else {
2050       // We have an URL like http://www.hostname.com/file.txt
2051       pos2 = ptr3-url;
2052     }
2053   } else {
2054     // We have an URL beginning like http://www.hostname.com:1212
2055     // Get the port number
2056     if(!m_option_list_find(desc->fields,"port")) {
2057       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a port part.\n",name);
2058       // skip
2059     } else {
2060       if(dst) {
2061         int p = atoi(ptr2+1);
2062         char tmp[100];
2063         snprintf(tmp,99,"%d",p);
2064         r = m_struct_set(desc,dst,"port",tmp);
2065         if(r < 0) {
2066           mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting port.\n",name);
2067           return r;
2068         }
2069       }
2070     }
2071     pos2 = ptr2-url;
2072   }
2073   if( v6addr ) pos2--;
2074   // Get the hostname
2075   if(pos2-pos1 > 0) {
2076     if(!m_option_list_find(desc->fields,"hostname")) {
2077       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
2078       // skip
2079     } else {
2080       char tmp[pos2-pos1+1];
2081       strncpy(tmp,ptr1, pos2-pos1);
2082       tmp[pos2-pos1] = '\0';
2083       r = m_struct_set(desc,dst,"hostname",tmp);
2084       if(r < 0) {
2085         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting hostname.\n",name);
2086         return r;
2087       }
2088     }
2089   }
2090   // Look if a path is given
2091   ptr2 = strstr(ptr1, "/");
2092   if( ptr2!=NULL ) {
2093     // A path/filename is given
2094     // check if it's not a trailing '/'
2095     if( strlen(ptr2)>1 ) {
2096       // copy the path/filename in the URL container
2097       if(!m_option_list_find(desc->fields,"filename")) {
2098         mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
2099         // skip
2100       } else {
2101         if(dst) {
2102           int l = strlen(ptr2+1) + 1;
2103           char* fname = ptr2+1;
2104           if(l > 1) {
2105             fname = malloc(l);
2106             url_unescape_string(fname,ptr2+1);
2107           }
2108           r = m_struct_set(desc,dst,"filename",fname);
2109           if(fname != ptr2+1)
2110             free(fname);
2111           if(r < 0) {
2112             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting filename.\n",name);
2113             return r;
2114           }
2115         }
2116       }
2117     }
2118   }
2119   return 1;
2120 }
2121
2122 /// TODO : Write the other needed funcs for 'normal' options
2123 const m_option_type_t m_option_type_custom_url = {
2124   "Custom URL",
2125   "",
2126   0,
2127   0,
2128   parse_custom_url,
2129   NULL,
2130   NULL,
2131   NULL,
2132   NULL,
2133   NULL
2134 };