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