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