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 "libmpdemux/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,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
 515 static int parse_str_list(m_option_t* opt,char *name, char *param, void* dst, int src) {
 516   int n = 0,len = strlen(opt->name);
 517   char *ptr = param, *last_ptr, **res;
 518   int op = OP_NONE;
 519
 520   if(opt->name[len-1] == '*' && ((int)strlen(name) > len - 1)) {
 521     char* n = &name[len-1];
 522     if(strcasecmp(n,"-add") == 0)
 523       op = OP_ADD;
 524     else if(strcasecmp(n,"-pre") == 0)
 525       op = OP_PRE;
 526     else if(strcasecmp(n,"-del") == 0)
 527       op = OP_DEL;
 528     else if(strcasecmp(n,"-clr") == 0)
 529       op = OP_CLR;
 530     else
 531       return M_OPT_UNKNOWN;
 532   }
 533
 534   // Clear the list ??
 535   if(op == OP_CLR) {
 536     if(dst)
 537       free_str_list(dst);
 538     return 0;
 539   }
 540
 541   // All other ops need a param
 542   if (param == NULL || strlen(param) == 0)
 543       return M_OPT_MISSING_PARAM;
 544
 545
 546   while(ptr[0] != '\0') {
 547     last_ptr = ptr;
 548     ptr = strchr(ptr,LIST_SEPARATOR);
 549     if(!ptr) {
 550       n++;
 551       break;
 552     }
 553     ptr++;
 554     n++;
 555   }
 556   if(n == 0)
 557     return M_OPT_INVALID;
 558   if( ((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
 559       ((opt->flags & M_OPT_MAX) && (n > opt->max)) )
 560     return M_OPT_OUT_OF_RANGE;
 561
 562   if(!dst) return 1;
 563
 564   res = malloc((n+2)*sizeof(char*));
 565   ptr = param;
 566   n = 0;
 567
 568   while(1) {
 569     last_ptr = ptr;
 570     ptr = strchr(ptr,LIST_SEPARATOR);
 571     if(!ptr) {
 572       res[n] = strdup(last_ptr);
 573       n++;
 574       break;
 575     }
 576     len = ptr - last_ptr;
 577     res[n] = (char*)malloc(len + 1);
 578     if(len) strncpy(res[n],last_ptr,len);
 579     res[n][len] = '\0';
 580     ptr++;
 581     n++;
 582   }
 583   res[n] = NULL;
 584
 585   switch(op) {
 586   case OP_ADD:
 587     return str_list_add(res,n,dst,0);
 588   case OP_PRE:
 589     return str_list_add(res,n,dst,1);
 590   case OP_DEL:
 591     return str_list_del(res,n,dst);
 592   }
 593
 594   if(VAL(dst))
 595     free_str_list(dst);
 596   VAL(dst) = res;
 597
 598   return 1;
 599 }
 600
 601 static void copy_str_list(m_option_t* opt,void* dst, void* src) {
 602   int n;
 603   char **d,**s;
 604
 605   if(!(dst && src)) return;
 606   s = VAL(src);
 607
 608   if(VAL(dst))
 609     free_str_list(dst);
 610
 611   if(!s) {
 612     VAL(dst) = NULL;
 613     return;
 614   }
 615
 616   for(n = 0 ; s[n] != NULL ; n++)
 617     /* NOTHING */;
 618   d = (char**)malloc((n+1)*sizeof(char*));
 619   for( ; n >= 0 ; n--)
 620     d[n] = s[n] ? strdup(s[n]) : NULL;
 621
 622   VAL(dst) = d;
 623 }
 624
 625 static char* print_str_list(m_option_t* opt, void* src) {
 626   char **lst = NULL;
 627   char *ret = NULL,*last = NULL;
 628   int i;
 629
 630   if(!(src && VAL(src))) return NULL;
 631   lst = VAL(src);
 632
 633   for(i = 0 ; lst[i] ; i++) {
 634     if(last) {
 635       ret = dup_printf("%s,%s",last,lst[i]);
 636       free(last);
 637     } else
 638       ret = strdup(lst[i]);
 639     last = ret;
 640   }
 641   if(last && last != ret) free(last);
 642   return ret;
 643 }
 644
 645 m_option_type_t m_option_type_string_list = {
 646   "String list",
 647   "A list of strings separated by ','\n"
 648   "Option with a name ending in an * permits using the following suffix: \n"
 649   "\t-add: Add the given parameters at the end of the list.\n"
 650   "\t-pre: Add the given parameters at the begining of the list.\n"
 651   "\t-del: Remove the entry at the given indices.\n"
 652   "\t-clr: Clear the list.\n"
 653   "e.g: -vf-add flip,mirror -vf-del 2,5\n",
 654   sizeof(char**),
 655   M_OPT_TYPE_DYNAMIC | M_OPT_TYPE_ALLOW_WILDCARD,
 656   parse_str_list,
 657   print_str_list,
 658   copy_str_list,
 659   copy_str_list,
 660   copy_str_list,
 661   free_str_list
 662 };
 663
 664
 665 ///////////////////  Func based options
 666
 667 // A chained list to save the various calls for func_param and func_full
 668 typedef struct m_func_save m_func_save_t;
 669 struct m_func_save {
 670   m_func_save_t* next;
 671   char* name;
 672   char* param;
 673 };
 674
 675 #undef VAL
 676 #define VAL(x) (*(m_func_save_t**)(x))
 677
 678 static void free_func_pf(void* src) {
 679   m_func_save_t *s,*n;
 680
 681   if(!src) return;
 682
 683   s = VAL(src);
 684
 685   while(s) {
 686     n = s->next;
 687     free(s->name);
 688     if(s->param) free(s->param);
 689     free(s);
 690     s = n;
 691   }
 692   VAL(src) = NULL;
 693 }
 694
 695 // Parser for func_param and func_full
 696 static int parse_func_pf(m_option_t* opt,char *name, char *param, void* dst, int src) {
 697   m_func_save_t *s,*p;
 698
 699   if(!dst)
 700     return 1;
 701
 702   s = (m_func_save_t*)calloc(1,sizeof(m_func_save_t));
 703   s->name = strdup(name);
 704   s->param = param ? strdup(param) : NULL;
 705
 706   p = VAL(dst);
 707   if(p) {
 708     for( ; p->next != NULL ; p = p->next)
 709       /**/;
 710     p->next = s;
 711   } else
 712     VAL(dst) = s;
 713
 714   return 1;
 715 }
 716
 717 static void copy_func_pf(m_option_t* opt,void* dst, void* src) {
 718   m_func_save_t *d = NULL, *s,* last = NULL;
 719
 720   if(!(dst && src)) return;
 721   s = VAL(src);
 722
 723   if(VAL(dst))
 724     free_func_pf(dst);
 725
 726   while(s) {
 727     d = (m_func_save_t*)calloc(1,sizeof(m_func_save_t));
 728     d->name = strdup(s->name);
 729     d->param = s->param ? strdup(s->param) : NULL;
 730     if(last)
 731       last->next = d;
 732     else
 733       VAL(dst) = d;
 734     last = d;
 735     s = s->next;
 736   }
 737
 738
 739 }
 740
 741 /////////////////// Func_param
 742
 743 static void set_func_param(m_option_t* opt, void* dst, void* src) {
 744   m_func_save_t* s;
 745
 746   if(!src) return;
 747   s = VAL(src);
 748
 749   if(!s) return;
 750
 751   // Revert if needed
 752   if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,opt->name);
 753   for( ; s != NULL ; s = s->next)
 754     ((m_opt_func_param_t) opt->p)(opt,s->param);
 755 }
 756
 757 m_option_type_t m_option_type_func_param = {
 758   "Func param",
 759   "",
 760   sizeof(m_func_save_t*),
 761   M_OPT_TYPE_INDIRECT,
 762   parse_func_pf,
 763   NULL,
 764   NULL, // Nothing to do on save
 765   set_func_param,
 766   copy_func_pf,
 767   free_func_pf
 768 };
 769
 770 /////////////////// Func_full
 771
 772 static void set_func_full(m_option_t* opt, void* dst, void* src) {
 773   m_func_save_t* s;
 774
 775   if(!src) return;
 776
 777   for(s = VAL(src) ; s ; s = s->next) {
 778     // Revert if needed
 779     if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,s->name);
 780     ((m_opt_func_full_t) opt->p)(opt,s->name,s->param);
 781   }
 782 }
 783
 784 m_option_type_t m_option_type_func_full = {
 785   "Func full",
 786   "",
 787   sizeof(m_func_save_t*),
 788   M_OPT_TYPE_ALLOW_WILDCARD|M_OPT_TYPE_INDIRECT,
 789   parse_func_pf,
 790   NULL,
 791   NULL, // Nothing to do on save
 792   set_func_full,
 793   copy_func_pf,
 794   free_func_pf
 795 };
 796
 797 /////////////// Func
 798
 799 #undef VAL
 800 #define VAL(x) (*(int*)(x))
 801
 802 static int parse_func(m_option_t* opt,char *name, char *param, void* dst, int src) {
 803   if(dst)
 804     VAL(dst) += 1;
 805   return 0;
 806 }
 807
 808 static void set_func(m_option_t* opt,void* dst, void* src) {
 809   int i;
 810   if(opt->priv) ((m_opt_default_func_t)opt->priv)(opt,opt->name);
 811   for(i = 0 ; i < VAL(src) ; i++)
 812     ((m_opt_func_t) opt->p)(opt);
 813 }
 814
 815 m_option_type_t m_option_type_func = {
 816   "Func",
 817   "",
 818   sizeof(int),
 819   M_OPT_TYPE_INDIRECT,
 820   parse_func,
 821   NULL,
 822   NULL, // Nothing to do on save
 823   set_func,
 824   NULL,
 825   NULL
 826 };
 827
 828 /////////////////// Print
 829
 830 static int parse_print(m_option_t* opt,char *name, char *param, void* dst, int src) {
 831   if(opt->type == CONF_TYPE_PRINT_INDIRECT)
 832     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", *(char **) opt->p);
 833   else if(opt->type == CONF_TYPE_PRINT_FUNC)
 834     return ((m_opt_func_full_t) opt->p)(opt,name,param);
 835   else
 836     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "%s", (char *) opt->p);
 837
 838   if(opt->priv == NULL)
 839     return M_OPT_EXIT;
 840   return 1;
 841 }
 842
 843 m_option_type_t m_option_type_print = {
 844   "Print",
 845   "",
 846   0,
 847   0,
 848   parse_print,
 849   NULL,
 850   NULL,
 851   NULL,
 852   NULL,
 853   NULL
 854 };
 855
 856 m_option_type_t m_option_type_print_indirect = {
 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_func = {
 870   "Print",
 871   "",
 872   0,
 873   M_OPT_TYPE_ALLOW_WILDCARD,
 874   parse_print,
 875   NULL,
 876   NULL,
 877   NULL,
 878   NULL,
 879   NULL
 880 };
 881
 882
 883 /////////////////////// Subconfig
 884 #undef VAL
 885 #define VAL(x) (*(char***)(x))
 886
 887 static int parse_subconf(m_option_t* opt,char *name, char *param, void* dst, int src) {
 888   char *subparam;
 889   char *subopt;
 890   int nr = 0,i,r;
 891   m_option_t *subopts;
 892   char *p;
 893   char** lst = NULL;
 894
 895   if (param == NULL || strlen(param) == 0)
 896     return M_OPT_MISSING_PARAM;
 897
 898   subparam = malloc(strlen(param)+1);
 899   subopt = malloc(strlen(param)+1);
 900   p = param;
 901
 902   subopts = opt->p;
 903
 904   while(p[0])
 905     {
 906       int sscanf_ret = 1;
 907       int optlen = strcspn(p, ":=");
 908       /* clear out */
 909       subopt[0] = subparam[0] = 0;
 910       strlcpy(subopt, p, optlen + 1);
 911       p = &p[optlen];
 912       if (p[0] == '=') {
 913         sscanf_ret = 2;
 914         p = &p[1];
 915         if (p[0] == '"') {
 916           p = &p[1];
 917           optlen = strcspn(p, "\"");
 918           strlcpy(subparam, p, optlen + 1);
 919           p = &p[optlen];
 920           if (p[0] != '"') {
 921             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Terminating '\"' missing for '%s'\n", subopt);
 922             return M_OPT_INVALID;
 923           }
 924           p = &p[1];
 925         } else if (p[0] == '%') {
 926           p = &p[1];
 927           optlen = (int)strtol(p, &p, 0);
 928           if (!p || p[0] != '%' || (optlen > strlen(p) - 1)) {
 929             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Invalid length %i for '%s'\n", optlen, subopt);
 930             return M_OPT_INVALID;
 931           }
 932           p = &p[1];
 933           strlcpy(subparam, p, optlen + 1);
 934           p = &p[optlen];
 935         } else {
 936           optlen = strcspn(p, ":");
 937           strlcpy(subparam, p, optlen + 1);
 938           p = &p[optlen];
 939         }
 940       }
 941       if (p[0] == ':')
 942         p = &p[1];
 943       else if (p[0]) {
 944         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Incorrect termination for '%s'\n", subopt);
 945         return M_OPT_INVALID;
 946       }
 947
 948       switch(sscanf_ret)
 949         {
 950         case 1:
 951           subparam[0] = 0;
 952         case 2:
 953           for(i = 0 ; subopts[i].name ; i++) {
 954             if(!strcmp(subopts[i].name,subopt)) break;
 955           }
 956           if(!subopts[i].name) {
 957             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Unknown suboption %s\n",name,subopt);
 958             return M_OPT_UNKNOWN;
 959           }
 960           r = m_option_parse(&subopts[i],subopt,
 961                              subparam[0] == 0 ? NULL : subparam,NULL,src);
 962           if(r < 0) return r;
 963           if(dst) {
 964             lst = (char**)realloc(lst,2 * (nr+2) * sizeof(char*));
 965             lst[2*nr] = strdup(subopt);
 966             lst[2*nr+1] = subparam[0] == 0 ? NULL : strdup(subparam);
 967             memset(&lst[2*(nr+1)],0,2*sizeof(char*));
 968             nr++;
 969           }
 970           break;
 971         }
 972     }
 973
 974   free(subparam);
 975   free(subopt);
 976   if(dst)
 977     VAL(dst) = lst;
 978
 979   return 1;
 980 }
 981
 982 m_option_type_t m_option_type_subconfig = {
 983   "Subconfig",
 984   "The syntax is -option opt1=foo:flag:opt2=blah",
 985   sizeof(int),
 986   M_OPT_TYPE_HAS_CHILD,
 987   parse_subconf,
 988   NULL,
 989   NULL,
 990   NULL,
 991   NULL,
 992   NULL
 993 };
 994
 995 #include "libmpcodecs/img_format.h"
 996
 997 /* FIXME: snyc with img_format.h */
 998 static struct {
 999   char* name;
1000   unsigned int fmt;
1001 } mp_imgfmt_list[] = {
1002   {"444p", IMGFMT_444P},
1003   {"422p", IMGFMT_422P},
1004   {"411p", IMGFMT_411P},
1005   {"yuy2", IMGFMT_YUY2},
1006   {"uyvy", IMGFMT_UYVY},
1007   {"yvu9", IMGFMT_YVU9},
1008   {"if09", IMGFMT_IF09},
1009   {"yv12", IMGFMT_YV12},
1010   {"i420", IMGFMT_I420},
1011   {"iyuv", IMGFMT_IYUV},
1012   {"clpl", IMGFMT_CLPL},
1013   {"hm12", IMGFMT_HM12},
1014   {"y800", IMGFMT_Y800},
1015   {"y8", IMGFMT_Y8},
1016   {"nv12", IMGFMT_NV12},
1017   {"nv21", IMGFMT_NV21},
1018   {"bgr24", IMGFMT_BGR24},
1019   {"bgr32", IMGFMT_BGR32},
1020   {"bgr16", IMGFMT_BGR16},
1021   {"bgr15", IMGFMT_BGR15},
1022   {"bgr8", IMGFMT_BGR8},
1023   {"bgr4", IMGFMT_BGR4},
1024   {"bg4b", IMGFMT_BG4B},
1025   {"bgr1", IMGFMT_BGR1},
1026   {"rgb24", IMGFMT_RGB24},
1027   {"rgb32", IMGFMT_RGB32},
1028   {"rgb16", IMGFMT_RGB16},
1029   {"rgb15", IMGFMT_RGB15},
1030   {"rgb8", IMGFMT_RGB8},
1031   {"rgb4", IMGFMT_RGB4},
1032   {"rg4b", IMGFMT_RG4B},
1033   {"rgb1", IMGFMT_RGB1},
1034   {"rgba", IMGFMT_RGBA},
1035   {"argb", IMGFMT_ARGB},
1036   {"bgra", IMGFMT_BGRA},
1037   {"abgr", IMGFMT_ABGR},
1038   { NULL, 0 }
1039 };
1040
1041 static int parse_imgfmt(m_option_t* opt,char *name, char *param, void* dst, int src) {
1042   uint32_t fmt = 0;
1043   int i;
1044
1045   if (param == NULL || strlen(param) == 0)
1046     return M_OPT_MISSING_PARAM;
1047
1048   if(!strcmp(param,"help")) {
1049     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1050     for(i = 0 ; mp_imgfmt_list[i].name ; i++)
1051       mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_imgfmt_list[i].name);
1052     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1053     return M_OPT_EXIT - 1;
1054   }
1055
1056   if (sscanf(param, "0x%x", &fmt) != 1)
1057   {
1058   for(i = 0 ; mp_imgfmt_list[i].name ; i++) {
1059     if(!strcasecmp(param,mp_imgfmt_list[i].name)) {
1060       fmt=mp_imgfmt_list[i].fmt;
1061       break;
1062     }
1063   }
1064   if(!mp_imgfmt_list[i].name) {
1065     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1066     return M_OPT_INVALID;
1067   }
1068   }
1069
1070   if(dst)
1071     *((uint32_t*)dst) = fmt;
1072
1073   return 1;
1074 }
1075
1076 m_option_type_t m_option_type_imgfmt = {
1077   "Image format",
1078   "Please report any missing colorspaces.",
1079   sizeof(uint32_t),
1080   0,
1081   parse_imgfmt,
1082   NULL,
1083   copy_opt,
1084   copy_opt,
1085   NULL,
1086   NULL
1087 };
1088
1089 #include "libaf/af_format.h"
1090
1091 /* FIXME: snyc with af_format.h */
1092 static struct {
1093   char* name;
1094   unsigned int fmt;
1095 } mp_afmt_list[] = {
1096   // SPECIAL
1097   {"mulaw", AF_FORMAT_MU_LAW},
1098   {"alaw", AF_FORMAT_A_LAW},
1099   {"mpeg2", AF_FORMAT_MPEG2},
1100   {"ac3", AF_FORMAT_AC3},
1101   {"imaadpcm", AF_FORMAT_IMA_ADPCM},
1102   // ORIDNARY
1103   {"u8", AF_FORMAT_U8},
1104   {"s8", AF_FORMAT_S8},
1105   {"u16le", AF_FORMAT_U16_LE},
1106   {"u16be", AF_FORMAT_U16_BE},
1107   {"u16ne", AF_FORMAT_U16_NE},
1108   {"s16le", AF_FORMAT_S16_LE},
1109   {"s16be", AF_FORMAT_S16_BE},
1110   {"s16ne", AF_FORMAT_S16_NE},
1111   {"u24le", AF_FORMAT_U24_LE},
1112   {"u24be", AF_FORMAT_U24_BE},
1113   {"u24ne", AF_FORMAT_U24_NE},
1114   {"s24le", AF_FORMAT_S24_LE},
1115   {"s24be", AF_FORMAT_S24_BE},
1116   {"s24ne", AF_FORMAT_S24_NE},
1117   {"u32le", AF_FORMAT_U32_LE},
1118   {"u32be", AF_FORMAT_U32_BE},
1119   {"u32ne", AF_FORMAT_U32_NE},
1120   {"s32le", AF_FORMAT_S32_LE},
1121   {"s32be", AF_FORMAT_S32_BE},
1122   {"s32ne", AF_FORMAT_S32_NE},
1123   {"floatle", AF_FORMAT_FLOAT_LE},
1124   {"floatbe", AF_FORMAT_FLOAT_BE},
1125   {"floatne", AF_FORMAT_FLOAT_NE},
1126   { NULL, 0 }
1127 };
1128
1129 static int parse_afmt(m_option_t* opt,char *name, char *param, void* dst, int src) {
1130   uint32_t fmt = 0;
1131   int i;
1132
1133   if (param == NULL || strlen(param) == 0)
1134     return M_OPT_MISSING_PARAM;
1135
1136   if(!strcmp(param,"help")) {
1137     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available formats:");
1138     for(i = 0 ; mp_afmt_list[i].name ; i++)
1139       mp_msg(MSGT_CFGPARSER, MSGL_INFO, " %s",mp_afmt_list[i].name);
1140     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "\n");
1141     return M_OPT_EXIT - 1;
1142   }
1143
1144   if (sscanf(param, "0x%x", &fmt) != 1)
1145   {
1146   for(i = 0 ; mp_afmt_list[i].name ; i++) {
1147     if(!strcasecmp(param,mp_afmt_list[i].name)) {
1148       fmt=mp_afmt_list[i].fmt;
1149       break;
1150     }
1151   }
1152   if(!mp_afmt_list[i].name) {
1153     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: unknown format name: '%s'\n",name,param);
1154     return M_OPT_INVALID;
1155   }
1156   }
1157
1158   if(dst)
1159     *((uint32_t*)dst) = fmt;
1160
1161   return 1;
1162 }
1163
1164 m_option_type_t m_option_type_afmt = {
1165   "Audio format",
1166   "Please report any missing formats.",
1167   sizeof(uint32_t),
1168   0,
1169   parse_afmt,
1170   NULL,
1171   copy_opt,
1172   copy_opt,
1173   NULL,
1174   NULL
1175 };
1176
1177
1178 //// Objects (i.e. filters, etc) settings
1179
1180 #include "m_struct.h"
1181
1182 #undef VAL
1183 #define VAL(x) (*(m_obj_settings_t**)(x))
1184
1185 static int find_obj_desc(char* name,m_obj_list_t* l,m_struct_t** ret) {
1186   int i;
1187   char* n;
1188
1189   for(i = 0 ; l->list[i] ; i++) {
1190     n = M_ST_MB(char*,l->list[i],l->name_off);
1191     if(!strcmp(n,name)) {
1192       *ret = M_ST_MB(m_struct_t*,l->list[i],l->desc_off);
1193       return 1;
1194     }
1195   }
1196   return 0;
1197 }
1198
1199 static int get_obj_param(char* opt_name,char* obj_name, m_struct_t* desc,
1200                          char* str,int* nold,int oldmax,char** dst) {
1201   char* eq,param;
1202   m_option_t* opt;
1203   int r;
1204
1205   eq = strchr(str,'=');
1206   if(eq && eq == str)
1207     eq = NULL;
1208
1209   if(eq) {
1210     char* p = eq + 1;
1211     if(p[0] == '\0') p = NULL;
1212     eq[0] = '\0';
1213     opt = m_option_list_find(desc->fields,str);
1214     if(!opt) {
1215       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't have a %s parameter.\n",opt_name,obj_name,str);
1216       return M_OPT_UNKNOWN;
1217     }
1218     r = m_option_parse(opt,str,p,NULL,M_CONFIG_FILE);
1219     if(r < 0) {
1220       if(r > M_OPT_EXIT)
1221         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,str,p);
1222       eq[0] = '=';
1223       return r;
1224     }
1225     if(dst) {
1226       dst[0] = strdup(str);
1227       dst[1] = p ? strdup(p) : NULL;
1228     }
1229     eq[0] = '=';
1230   } else {
1231     if((*nold) >= oldmax) {
1232       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s has only %d params, so you can't give more than %d unnamed params.\n",
1233              opt_name,obj_name,oldmax,oldmax);
1234       return M_OPT_OUT_OF_RANGE;
1235     }
1236     opt = &desc->fields[(*nold)];
1237     r = m_option_parse(opt,opt->name,str,NULL,M_CONFIG_FILE);
1238     if(r < 0) {
1239       if(r > M_OPT_EXIT)
1240         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while parsing %s parameter %s (%s)\n",opt_name,obj_name,opt->name,str);
1241       return r;
1242     }
1243     if(dst) {
1244       dst[0] = strdup(opt->name);
1245       dst[1] = strdup(str);
1246     }
1247     (*nold)++;
1248   }
1249   return 1;
1250 }
1251
1252 static int get_obj_params(char* opt_name, char* name,char* params,
1253                           m_struct_t* desc,char separator, char*** _ret) {
1254   int n = 0,nold = 0, nopts,r;
1255   char* ptr,*last_ptr = params,*eq;
1256   char** ret;
1257
1258   if(!strcmp(params,"help")) { // Help
1259     char min[50],max[50];
1260     if(!desc->fields) {
1261       printf("%s doesn't have any options.\n\n",name);
1262       return M_OPT_EXIT - 1;
1263     }
1264     printf("\n Name                 Type            Min        Max\n\n");
1265     for(n = 0 ; desc->fields[n].name ; n++) {
1266       m_option_t* opt = &desc->fields[n];
1267       if(opt->type->flags & M_OPT_TYPE_HAS_CHILD) continue;
1268       if(opt->flags & M_OPT_MIN)
1269         sprintf(min,"%-8.0f",opt->min);
1270       else
1271         strcpy(min,"No");
1272       if(opt->flags & M_OPT_MAX)
1273         sprintf(max,"%-8.0f",opt->max);
1274       else
1275         strcpy(max,"No");
1276       printf(" %-20.20s %-15.15s %-10.10s %-10.10s\n",
1277              opt->name,
1278              opt->type->name,
1279              min,
1280              max);
1281     }
1282     printf("\n");
1283     return M_OPT_EXIT - 1;
1284   }
1285
1286   for(nopts = 0 ; desc->fields[nopts].name ; nopts++)
1287     /* NOP */;
1288
1289   // TODO : Check that each opt can be parsed
1290   r = 1;
1291   while(last_ptr && last_ptr[0] != '\0') {
1292     ptr = strchr(last_ptr,separator);
1293     if(!ptr) {
1294       r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1295       n++;
1296       break;
1297     }
1298     if(ptr == last_ptr) { // Empty field, count it and go on
1299       nold++;
1300       last_ptr = ptr+1;
1301       continue;
1302     }
1303     ptr[0] = '\0';
1304     r = get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,NULL);
1305     ptr[0] = separator;
1306     if(r < 0) break;
1307     n++;
1308     last_ptr = ptr+1;
1309   }
1310   if(r < 0) return r;
1311   if (!last_ptr[0]) // count an empty field at the end, too
1312     nold++;
1313   if (nold > nopts) {
1314     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Too many options for %s\n", name);
1315     return M_OPT_OUT_OF_RANGE;
1316   }
1317   if(!_ret) // Just test
1318     return 1;
1319   if (n == 0) // No options or only empty options
1320     return 1;
1321
1322   ret = malloc((n+2)*2*sizeof(char*));
1323   n = nold = 0;
1324   last_ptr = params;
1325
1326   while(last_ptr && last_ptr[0] != '\0') {
1327     ptr = strchr(last_ptr,separator);
1328     if(!ptr) {
1329       get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1330       n++;
1331       break;
1332     }
1333     if(ptr == last_ptr) { // Empty field, count it and go on
1334       last_ptr = ptr+1;
1335       nold++;
1336       continue;
1337     }
1338     ptr[0] = '\0';
1339     get_obj_param(opt_name,name,desc,last_ptr,&nold,nopts,&ret[n*2]);
1340     n++;
1341     last_ptr = ptr+1;
1342   }
1343   ret[n*2] = ret[n*2+1] = NULL;
1344   *_ret = ret;
1345
1346   return 1;
1347 }
1348
1349 static int parse_obj_params(m_option_t* opt,char *name,
1350                             char *param, void* dst, int src) {
1351   char** opts;
1352   int r;
1353   m_obj_params_t* p = opt->priv;
1354   m_struct_t* desc = p->desc;
1355   char* cpy = strdup(param);
1356
1357   // We need the object desc
1358   if(!p)
1359     return M_OPT_INVALID;
1360
1361   r = get_obj_params(name,desc->name,cpy,desc,p->separator,&opts);
1362   free(cpy);
1363   if(r < 0)
1364     return r;
1365   if(!dst)
1366     return 1;
1367   if (!opts) // no arguments given
1368     return 1;
1369
1370   for(r = 0 ; opts[r] ; r += 2)
1371     m_struct_set(desc,dst,opts[r],opts[r+1]);
1372
1373   return 1;
1374 }
1375
1376
1377 m_option_type_t m_option_type_obj_params = {
1378   "Object params",
1379   "",
1380   0,
1381   0,
1382   parse_obj_params,
1383   NULL,
1384   NULL,
1385   NULL,
1386   NULL,
1387   NULL
1388 };
1389
1390 /// Some predefined types as a definition would be quite lengthy
1391
1392 /// Span arguments
1393 static m_span_t m_span_params_dflts = { -1, -1 };
1394 static m_option_t m_span_params_fields[] = {
1395   {"start", M_ST_OFF(m_span_t,start), CONF_TYPE_INT, M_OPT_MIN, 1 ,0, NULL},
1396   {"end", M_ST_OFF(m_span_t,end), CONF_TYPE_INT, M_OPT_MIN , 1 ,0, NULL},
1397   { NULL, NULL, 0, 0, 0, 0,  NULL }
1398 };
1399 static struct m_struct_st m_span_opts = {
1400   "m_span",
1401   sizeof(m_span_t),
1402   &m_span_params_dflts,
1403   m_span_params_fields
1404 };
1405 m_obj_params_t m_span_params_def = {
1406   &m_span_opts,
1407   '-'
1408 };
1409
1410 static int parse_obj_settings(char* opt,char* str,m_obj_list_t* list,
1411                               m_obj_settings_t **_ret, int ret_n) {
1412   int r;
1413   char *param,**plist = NULL;
1414   m_struct_t* desc;
1415   m_obj_settings_t *ret = _ret ? *_ret : NULL;
1416
1417
1418   // Now check that the object exists
1419   param = strchr(str,'=');
1420   if(param) {
1421     param[0] = '\0';
1422     param++;
1423     if(strlen(param) <= 0)
1424       param = NULL;
1425   }
1426
1427
1428   if(!find_obj_desc(str,list,&desc)) {
1429     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: %s doesn't exist.\n",opt,str);
1430     return M_OPT_INVALID;
1431   }
1432
1433   if(param) {
1434     if(!desc && _ret) {
1435       if(!strcmp(param,"help")) {
1436         mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Option %s: %s have no option description.\n",opt,str);
1437         return M_OPT_EXIT - 1;
1438       }
1439       plist = calloc(4,sizeof(char*));
1440       plist[0] = strdup("_oldargs_");
1441       plist[1] = strdup(param);
1442     } else if(desc) {
1443       r = get_obj_params(opt,str,param,desc,':',_ret ? &plist : NULL);
1444       if(r < 0)
1445         return r;
1446     }
1447   }
1448   if(!_ret)
1449     return 1;
1450
1451   ret = realloc(ret,(ret_n+2)*sizeof(m_obj_settings_t));
1452   memset(&ret[ret_n],0,2*sizeof(m_obj_settings_t));
1453   ret[ret_n].name = strdup(str);
1454   ret[ret_n].attribs = plist;
1455
1456   *_ret = ret;
1457   return 1;
1458 }
1459
1460 static void free_obj_settings_list(void* dst);
1461
1462 static int obj_settings_list_del(char *opt_name,char *param,void* dst, int src) {
1463   char** str_list = NULL;
1464   int r,i,idx_max = 0;
1465   char* rem_id = "_removed_marker_";
1466   m_option_t list_opt = {opt_name , NULL, CONF_TYPE_STRING_LIST,
1467                            0, 0, 0, NULL };
1468   m_obj_settings_t* obj_list = dst ? VAL(dst) : NULL;
1469
1470   if(dst && !obj_list) {
1471     mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: the list is empty.\n",opt_name);
1472     return 1;
1473   } else if(obj_list) {
1474     for(idx_max = 0 ; obj_list[idx_max].name != NULL ; idx_max++)
1475       /* NOP */;
1476   }
1477
1478   r = m_option_parse(&list_opt,opt_name,param,&str_list,src);
1479   if(r < 0 || !str_list)
1480     return r;
1481
1482   for(r = 0 ; str_list[r] ; r++) {
1483     int id;
1484     char* endptr;
1485     id = strtol(str_list[r],&endptr,0);
1486     if(endptr == str_list[r]) {
1487       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);
1488       m_option_free(&list_opt,&str_list);
1489       return M_OPT_INVALID;
1490     }
1491     if(!obj_list) continue;
1492     if(id >= idx_max || id < -idx_max) {
1493       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: Index %d is out of range.\n",opt_name,id);
1494       continue;
1495     }
1496     if(id < 0)
1497       id = idx_max + id;
1498     free(obj_list[id].name);
1499     free_str_list(&(obj_list[id].attribs));
1500     obj_list[id].name = rem_id;
1501   }
1502
1503   if(!dst) {
1504     m_option_free(&list_opt,&str_list);
1505     return 1;
1506   }
1507
1508   for(i = 0 ; obj_list[i].name ; i++) {
1509     while(obj_list[i].name == rem_id) {
1510       memmove(&obj_list[i],&obj_list[i+1],sizeof(m_obj_settings_t)*(idx_max - i));
1511       idx_max--;
1512     }
1513   }
1514   obj_list = realloc(obj_list,sizeof(m_obj_settings_t)*(idx_max+1));
1515   VAL(dst) = obj_list;
1516
1517   return 1;
1518 }
1519
1520 static int parse_obj_settings_list(m_option_t* opt,char *name,
1521                                    char *param, void* dst, int src) {
1522   int n = 0,r,len = strlen(opt->name);
1523   char *str;
1524   char *ptr, *last_ptr;
1525   m_obj_settings_t *res = NULL,*queue = NULL,*head = NULL;
1526   int op = OP_NONE;
1527
1528   // We need the objects list
1529   if(!opt->priv)
1530     return M_OPT_INVALID;
1531
1532   if(opt->name[len-1] == '*' && ((int)strlen(name) > len - 1)) {
1533     char* n = &name[len-1];
1534     if(strcasecmp(n,"-add") == 0)
1535       op = OP_ADD;
1536     else if(strcasecmp(n,"-pre") == 0)
1537       op = OP_PRE;
1538     else if(strcasecmp(n,"-del") == 0)
1539       op = OP_DEL;
1540     else if(strcasecmp(n,"-clr") == 0)
1541       op = OP_CLR;
1542     else {
1543       char prefix[len];
1544       strncpy(prefix,opt->name,len-1);
1545       prefix[len-1] = '\0';
1546       mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: unknown postfix %s\n"
1547              "Supported postfixes are:\n"
1548              "  %s-add\n"
1549              " Append the given list to the current list\n\n"
1550              "  %s-pre\n"
1551              " Prepend the given list to the current list\n\n"
1552              "  %s-del x,y,...\n"
1553              " Remove the given elements. Take the list element index (starting from 0).\n"
1554              " Negative index can be used (i.e. -1 is the last element)\n\n"
1555              "  %s-clr\n"
1556              " Clear the current list.\n",name,n,prefix,prefix,prefix,prefix);
1557
1558       return M_OPT_UNKNOWN;
1559     }
1560   }
1561
1562   // Clear the list ??
1563   if(op == OP_CLR) {
1564     if(dst)
1565       free_obj_settings_list(dst);
1566     return 0;
1567   }
1568
1569   if (param == NULL || strlen(param) == 0)
1570     return M_OPT_MISSING_PARAM;
1571
1572   switch(op) {
1573   case OP_ADD:
1574     if(dst) head = VAL(dst);
1575     break;
1576   case OP_PRE:
1577     if(dst) queue = VAL(dst);
1578      break;
1579   case OP_DEL:
1580     return obj_settings_list_del(name,param,dst,src);
1581   case OP_NONE:
1582     if(dst && VAL(dst))
1583       free_obj_settings_list(dst);
1584     break;
1585   default:
1586     mp_msg(MSGT_VFILTER,MSGL_ERR, "Option %s: FIXME\n",name);
1587     return M_OPT_UNKNOWN;
1588   }
1589
1590   if(!strcmp(param,"help")) {
1591     m_obj_list_t* ol = opt->priv;
1592     mp_msg(MSGT_VFILTER,MSGL_INFO,"Available video filters:\n");
1593     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_FILTERS\n");
1594     for(n = 0 ; ol->list[n] ; n++)
1595       mp_msg(MSGT_VFILTER,MSGL_INFO,"  %-15s: %s\n",
1596              M_ST_MB(char*,ol->list[n],ol->name_off),
1597              M_ST_MB(char*,ol->list[n],ol->info_off));
1598     mp_msg(MSGT_VFILTER,MSGL_INFO,"\n");
1599     return M_OPT_EXIT - 1;
1600   }
1601   ptr = str = strdup(param);
1602
1603   while(ptr[0] != '\0') {
1604     last_ptr = ptr;
1605     ptr = strchr(ptr,LIST_SEPARATOR);
1606     if(!ptr) {
1607       r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1608       if(r < 0) {
1609         free(str);
1610         return r;
1611       }
1612       n++;
1613       break;
1614     }
1615     ptr[0] = '\0';
1616     r = parse_obj_settings(name,last_ptr,opt->priv,dst ? &res : NULL,n);
1617     if(r < 0) {
1618       free(str);
1619       return r;
1620     }
1621     ptr++;
1622     n++;
1623   }
1624   free(str);
1625   if(n == 0)
1626     return M_OPT_INVALID;
1627
1628   if( ((opt->flags & M_OPT_MIN) && (n < opt->min)) ||
1629       ((opt->flags & M_OPT_MAX) && (n > opt->max)) )
1630     return M_OPT_OUT_OF_RANGE;
1631
1632   if(dst) {
1633     if(queue) {
1634       int qsize;
1635       for(qsize = 0 ; queue[qsize].name ; qsize++)
1636         /* NOP */;
1637       res = realloc(res,(qsize+n+1)*sizeof(m_obj_settings_t));
1638       memcpy(&res[n],queue,(qsize+1)*sizeof(m_obj_settings_t));
1639       n += qsize;
1640       free(queue);
1641     }
1642     if(head) {
1643       int hsize;
1644       for(hsize = 0 ; head[hsize].name ; hsize++)
1645         /* NOP */;
1646       head = realloc(head,(hsize+n+1)*sizeof(m_obj_settings_t));
1647       memcpy(&head[hsize],res,(n+1)*sizeof(m_obj_settings_t));
1648       free(res);
1649       res = head;
1650     }
1651     VAL(dst) = res;
1652   }
1653   return 1;
1654 }
1655
1656 static void free_obj_settings_list(void* dst) {
1657   int n;
1658   m_obj_settings_t *d;
1659
1660   if(!dst || !VAL(dst)) return;
1661
1662   d = VAL(dst);
1663 #ifndef NO_FREE
1664   for(n = 0 ; d[n].name ; n++) {
1665     free(d[n].name);
1666     free_str_list(&(d[n].attribs));
1667   }
1668   free(d);
1669 #endif
1670   VAL(dst) = NULL;
1671 }
1672
1673 static void copy_obj_settings_list(m_option_t* opt,void* dst, void* src) {
1674   m_obj_settings_t *d,*s;
1675   int n;
1676
1677   if(!(dst && src))
1678     return;
1679
1680   s = VAL(src);
1681
1682   if(VAL(dst))
1683     free_obj_settings_list(dst);
1684   if(!s) return;
1685
1686
1687
1688   for(n = 0 ; s[n].name ; n++)
1689     /* NOP */;
1690   d = malloc((n+1)*sizeof(m_obj_settings_t));
1691   for(n = 0 ; s[n].name ; n++) {
1692     d[n].name = strdup(s[n].name);
1693     d[n].attribs = NULL;
1694     copy_str_list(NULL,&(d[n].attribs),&(s[n].attribs));
1695   }
1696   d[n].name = NULL;
1697   d[n].attribs = NULL;
1698   VAL(dst) = d;
1699 }
1700
1701 m_option_type_t m_option_type_obj_settings_list = {
1702   "Object settings list",
1703   "",
1704   sizeof(m_obj_settings_t*),
1705   M_OPT_TYPE_DYNAMIC|M_OPT_TYPE_ALLOW_WILDCARD,
1706   parse_obj_settings_list,
1707   NULL,
1708   copy_obj_settings_list,
1709   copy_obj_settings_list,
1710   copy_obj_settings_list,
1711   free_obj_settings_list,
1712 };
1713
1714
1715
1716 static int parse_obj_presets(m_option_t* opt,char *name,
1717                             char *param, void* dst, int src) {
1718   m_obj_presets_t* obj_p = (m_obj_presets_t*)opt->priv;
1719   m_struct_t *in_desc,*out_desc;
1720   int s,i;
1721   unsigned char* pre = obj_p->presets;
1722   char* pre_name = NULL;
1723
1724   if(!obj_p) {
1725     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Presets need a pointer to a m_obj_presets_t in the priv field.\n",name);
1726     return M_OPT_PARSER_ERR;
1727   }
1728
1729   if(!param)
1730     return M_OPT_MISSING_PARAM;
1731
1732   in_desc = obj_p->in_desc;
1733   out_desc = obj_p->out_desc ? obj_p->out_desc : obj_p->in_desc;
1734   s = in_desc->size;
1735
1736   if(!strcmp(param,"help")) {
1737     mp_msg(MSGT_CFGPARSER, MSGL_INFO, "Available presets for %s->%s:",out_desc->name,name);
1738     for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1739         pre +=  s)
1740       mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1741     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1742     return M_OPT_EXIT - 1;
1743   }
1744
1745   for(pre_name = M_ST_MB(char*,pre,obj_p->name_off) ; pre_name ;
1746       pre +=  s, pre_name = M_ST_MB(char*,pre,obj_p->name_off)) {
1747     if(!strcmp(pre_name,param)) break;
1748   }
1749   if(!pre_name) {
1750     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: There is no preset named %s\n"
1751            "Available presets are:",name,param);
1752     for(pre = obj_p->presets;(pre_name = M_ST_MB(char*,pre,obj_p->name_off)) ;
1753         pre +=  s)
1754       mp_msg(MSGT_CFGPARSER, MSGL_ERR, " %s",pre_name);
1755     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "\n");
1756     return M_OPT_INVALID;
1757   }
1758
1759   if(!dst) return 1;
1760
1761   for(i = 0 ; in_desc->fields[i].name ; i++) {
1762     m_option_t* out_opt = m_option_list_find(out_desc->fields,
1763                                              in_desc->fields[i].name);
1764     if(!out_opt) {
1765       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);
1766       return M_OPT_PARSER_ERR;
1767     }
1768     m_option_copy(out_opt,M_ST_MB_P(dst,out_opt->p),M_ST_MB_P(pre,in_desc->fields[i].p));
1769   }
1770   return 1;
1771 }
1772
1773
1774 m_option_type_t m_option_type_obj_presets = {
1775   "Object presets",
1776   "",
1777   0,
1778   0,
1779   parse_obj_presets,
1780   NULL,
1781   NULL,
1782   NULL,
1783   NULL,
1784   NULL
1785 };
1786
1787 static int parse_custom_url(m_option_t* opt,char *name,
1788                             char *url, void* dst, int src) {
1789   int pos1, pos2, r, v6addr = 0;
1790   char *ptr1=NULL, *ptr2=NULL, *ptr3=NULL, *ptr4=NULL;
1791   m_struct_t* desc = opt->priv;
1792
1793   if(!desc) {
1794     mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Custom URL needs a pointer to a m_struct_t in the priv field.\n",name);
1795     return M_OPT_PARSER_ERR;
1796   }
1797
1798   // extract the protocol
1799   ptr1 = strstr(url, "://");
1800   if( ptr1==NULL ) {
1801     // Filename only
1802     if(m_option_list_find(desc->fields,"filename")) {
1803       m_struct_set(desc,dst,"filename",url);
1804       return 1;
1805     }
1806     mp_msg(MSGT_CFGPARSER, MSGL_ERR,"Option %s: URL doesn't have a valid protocol!\n",name);
1807     return M_OPT_INVALID;
1808   }
1809   if(m_option_list_find(desc->fields,"string")) {
1810     if(strlen(ptr1)>3) {
1811       m_struct_set(desc,dst,"string",ptr1+3);
1812       return 1;
1813     }
1814   }
1815   pos1 = ptr1-url;
1816   if(dst && m_option_list_find(desc->fields,"protocol")) {
1817     ptr1[0] = '\0';
1818     r = m_struct_set(desc,dst,"protocol",url);
1819     ptr1[0] = ':';
1820     if(r < 0) {
1821       mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting protocol.\n",name);
1822       return r;
1823     }
1824   }
1825
1826   // jump the "://"
1827   ptr1 += 3;
1828   pos1 += 3;
1829
1830   // check if a username:password is given
1831   ptr2 = strstr(ptr1, "@");
1832   ptr3 = strstr(ptr1, "/");
1833   if( ptr3!=NULL && ptr3<ptr2 ) {
1834     // it isn't really a username but rather a part of the path
1835     ptr2 = NULL;
1836   }
1837   if( ptr2!=NULL ) {
1838
1839     // We got something, at least a username...
1840     int len = ptr2-ptr1;
1841     if(!m_option_list_find(desc->fields,"username")) {
1842       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a username part.\n",name);
1843       // skip
1844     } else {
1845       ptr3 = strstr(ptr1, ":");
1846       if( ptr3!=NULL && ptr3<ptr2 ) {
1847         // We also have a password
1848         int len2 = ptr2-ptr3-1;
1849         if(!m_option_list_find(desc->fields,"password")) {
1850           mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a password part.\n",name);
1851           // skip
1852         } else { // Username and password
1853           if(dst) {
1854             ptr3[0] = '\0';
1855             r = m_struct_set(desc,dst,"username",ptr1);
1856             ptr3[0] = ':';
1857             if(r < 0) {
1858               mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
1859               return r;
1860             }
1861             ptr2[0] = '\0';
1862             r = m_struct_set(desc,dst,"password",ptr3+1);
1863             ptr2[0] = '@';
1864             if(r < 0) {
1865               mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting password.\n",name);
1866               return r;
1867             }
1868           }
1869         }
1870       } else { // User name only
1871         ptr2[0] = '\0';
1872         r = m_struct_set(desc,dst,"username",ptr1);
1873         ptr2[0] = '@';
1874         if(r < 0) {
1875           mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting username.\n",name);
1876           return r;
1877         }
1878       }
1879     }
1880     ptr1 = ptr2+1;
1881     pos1 = ptr1-url;
1882   }
1883
1884   // before looking for a port number check if we have an IPv6 type numeric address
1885   // in an IPv6 URL the numeric address should be inside square braces.
1886   ptr2 = strstr(ptr1, "[");
1887   ptr3 = strstr(ptr1, "]");
1888   // If the [] is after the first it isn't the hostname
1889   ptr4 = strstr(ptr1, "/");
1890   if( ptr2!=NULL && ptr3!=NULL && (ptr2 < ptr3) && (!ptr4 || ptr4 > ptr3)) {
1891     // we have an IPv6 numeric address
1892     ptr1++;
1893     pos1++;
1894     ptr2 = ptr3;
1895     v6addr = 1;
1896   } else {
1897     ptr2 = ptr1;
1898   }
1899
1900   // look if the port is given
1901   ptr2 = strstr(ptr2, ":");
1902   // If the : is after the first / it isn't the port
1903   ptr3 = strstr(ptr1, "/");
1904   if(ptr3 && ptr3 - ptr2 < 0) ptr2 = NULL;
1905   if( ptr2==NULL ) {
1906     // No port is given
1907     // Look if a path is given
1908     if( ptr3==NULL ) {
1909       // No path/filename
1910       // So we have an URL like http://www.hostname.com
1911       pos2 = strlen(url);
1912     } else {
1913       // We have an URL like http://www.hostname.com/file.txt
1914       pos2 = ptr3-url;
1915     }
1916   } else {
1917     // We have an URL beginning like http://www.hostname.com:1212
1918     // Get the port number
1919     if(!m_option_list_find(desc->fields,"port")) {
1920       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a port part.\n",name);
1921       // skip
1922     } else {
1923       if(dst) {
1924         int p = atoi(ptr2+1);
1925         char tmp[100];
1926         snprintf(tmp,99,"%d",p);
1927         r = m_struct_set(desc,dst,"port",tmp);
1928         if(r < 0) {
1929           mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting port.\n",name);
1930           return r;
1931         }
1932       }
1933     }
1934     pos2 = ptr2-url;
1935   }
1936   if( v6addr ) pos2--;
1937   // Get the hostname
1938   if(pos2-pos1 > 0) {
1939     if(!m_option_list_find(desc->fields,"hostname")) {
1940       mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
1941       // skip
1942     } else {
1943       char tmp[pos2-pos1+1];
1944       strncpy(tmp,ptr1, pos2-pos1);
1945       tmp[pos2-pos1] = '\0';
1946       r = m_struct_set(desc,dst,"hostname",tmp);
1947       if(r < 0) {
1948         mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting hostname.\n",name);
1949         return r;
1950       }
1951     }
1952   }
1953   // Look if a path is given
1954   ptr2 = strstr(ptr1, "/");
1955   if( ptr2!=NULL ) {
1956     // A path/filename is given
1957     // check if it's not a trailing '/'
1958     if( strlen(ptr2)>1 ) {
1959       // copy the path/filename in the URL container
1960       if(!m_option_list_find(desc->fields,"filename")) {
1961         mp_msg(MSGT_CFGPARSER, MSGL_WARN, "Option %s: This URL doesn't have a hostname part.\n",name);
1962         // skip
1963       } else {
1964         if(dst) {
1965           int l = strlen(ptr2+1) + 1;
1966           char* fname = ptr2+1;
1967           if(l > 1) {
1968             fname = malloc(l);
1969             url_unescape_string(fname,ptr2+1);
1970           }
1971           r = m_struct_set(desc,dst,"filename",fname);
1972           if(fname != ptr2+1)
1973             free(fname);
1974           if(r < 0) {
1975             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option %s: Error while setting filename.\n",name);
1976             return r;
1977           }
1978         }
1979       }
1980     }
1981   }
1982   return 1;
1983 }
1984
1985 /// TODO : Write the other needed funcs for 'normal' options
1986 m_option_type_t m_option_type_custom_url = {
1987   "Custom URL",
1988   "",
1989   0,
1990   0,
1991   parse_custom_url,
1992   NULL,
1993   NULL,
1994   NULL,
1995   NULL,
1996   NULL
1997 };