m_option.c

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