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