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