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