m_option.c

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