codec-cfg.c

   1 /*
   2  * codec.conf parser
   3  * by Szabolcs Berecz <szabi@inf.elte.hu>
   4  * (C) 2001
   5  *
   6  * to compile test application:
   7  *  cc -I. -DTESTING -o codec-cfg-test codec-cfg.c mp_msg.o osdep/getch2.o -ltermcap
   8  * to compile CODECS2HTML:
   9  *   gcc -DCODECS2HTML -o codecs2html codec-cfg.c mp_msg.o
  10  *
  11  * TODO: implement informat in CODECS2HTML too
  12  */
  13
  14 #define DEBUG
  15
  16 //disable asserts
  17 #define NDEBUG
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <fcntl.h>
  22 #include <unistd.h>
  23 #include <errno.h>
  24 #include <ctype.h>
  25 #include <assert.h>
  26 #include <string.h>
  27
  28 #include "config.h"
  29 #include "mp_msg.h"
  30 #ifdef CODECS2HTML
  31 #ifdef __GNUC__
  32 #define mp_msg(t, l, m, args...) fprintf(stderr, m, ##args)
  33 #else
  34 #define mp_msg(t, l, ...) fprintf(stderr, __VA_ARGS__)
  35 #endif
  36 #endif
  37
  38 #include "help_mp.h"
  39
  40 // for mmioFOURCC:
  41 #include "libmpdemux/aviheader.h"
  42
  43 #include "libmpcodecs/img_format.h"
  44 #include "codec-cfg.h"
  45
  46 #ifndef CODECS2HTML
  47 #include "codecs.conf.h"
  48 #endif
  49
  50 #define PRINT_LINENUM mp_msg(MSGT_CODECCFG,MSGL_ERR," at line %d\n", line_num)
  51
  52 #define MAX_NR_TOKEN    16
  53
  54 #define MAX_LINE_LEN    1000
  55
  56 #define RET_EOF         -1
  57 #define RET_EOL         -2
  58
  59 #define TYPE_VIDEO      0
  60 #define TYPE_AUDIO      1
  61
  62 char * codecs_file = NULL;
  63
  64 static int add_to_fourcc(char *s, char *alias, unsigned int *fourcc,
  65                 unsigned int *map)
  66 {
  67         int i, j, freeslots;
  68         unsigned int tmp;
  69
  70         /* find first unused slot */
  71         for (i = 0; i < CODECS_MAX_FOURCC && fourcc[i] != 0xffffffff; i++)
  72                 /* NOTHING */;
  73         freeslots = CODECS_MAX_FOURCC - i;
  74         if (!freeslots)
  75                 goto err_out_too_many;
  76
  77         do {
  78                 tmp = mmioFOURCC(s[0], s[1], s[2], s[3]);
  79                 for (j = 0; j < i; j++)
  80                         if (tmp == fourcc[j])
  81                                 goto err_out_duplicated;
  82                 fourcc[i] = tmp;
  83                 map[i] = alias ? mmioFOURCC(alias[0], alias[1], alias[2], alias[3]) : tmp;
  84                 s += 4;
  85                 i++;
  86         } while ((*(s++) == ',') && --freeslots);
  87
  88         if (!freeslots)
  89                 goto err_out_too_many;
  90         if (*(--s) != '\0')
  91                 goto err_out_parse_error;
  92         return 1;
  93 err_out_duplicated:
  94         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_DuplicateFourcc);
  95         return 0;
  96 err_out_too_many:
  97         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_TooManyFourccs);
  98         return 0;
  99 err_out_parse_error:
 100         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_ParseError);
 101         return 0;
 102 }
 103
 104 static int add_to_format(char *s, char *alias,unsigned int *fourcc, unsigned int *fourccmap)
 105 {
 106         int i, j;
 107         char *endptr;
 108
 109         /* find first unused slot */
 110         for (i = 0; i < CODECS_MAX_FOURCC && fourcc[i] != 0xffffffff; i++)
 111                 /* NOTHING */;
 112         if (i == CODECS_MAX_FOURCC) {
 113                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_TooManyFourccs);
 114                 return 0;
 115         }
 116
 117         fourcc[i]=strtoul(s,&endptr,0);
 118         if (*endptr != '\0') {
 119                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_ParseErrorFIDNotNumber);
 120                 return 0;
 121         }
 122
 123         if(alias){
 124             fourccmap[i]=strtoul(alias,&endptr,0);
 125             if (*endptr != '\0') {
 126                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_ParseErrorFIDAliasNotNumber);
 127                 return 0;
 128             }
 129         } else
 130             fourccmap[i]=fourcc[i];
 131
 132         for (j = 0; j < i; j++)
 133                 if (fourcc[j] == fourcc[i]) {
 134                         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_DuplicateFID);
 135                         return 0;
 136                 }
 137
 138         return 1;
 139 }
 140
 141         static struct {
 142                 const char *name;
 143                 const unsigned int num;
 144         } fmt_table[] = {
 145                 {"YV12",  IMGFMT_YV12},
 146                 {"I420",  IMGFMT_I420},
 147                 {"IYUV",  IMGFMT_IYUV},
 148                 {"NV12",  IMGFMT_NV12},
 149                 {"NV21",  IMGFMT_NV21},
 150                 {"YVU9",  IMGFMT_YVU9},
 151                 {"IF09",  IMGFMT_IF09},
 152                 {"444P",  IMGFMT_444P},
 153                 {"422P",  IMGFMT_422P},
 154                 {"411P",  IMGFMT_411P},
 155                 {"Y800",  IMGFMT_Y800},
 156                 {"Y8",    IMGFMT_Y8},
 157
 158                 {"YUY2",  IMGFMT_YUY2},
 159                 {"UYVY",  IMGFMT_UYVY},
 160                 {"YVYU",  IMGFMT_YVYU},
 161
 162                 {"RGB4",  IMGFMT_RGB|4},
 163                 {"RGB8",  IMGFMT_RGB|8},
 164                 {"RGB15", IMGFMT_RGB|15},
 165                 {"RGB16", IMGFMT_RGB|16},
 166                 {"RGB24", IMGFMT_RGB|24},
 167                 {"RGB32", IMGFMT_RGB|32},
 168                 {"BGR4",  IMGFMT_BGR|4},
 169                 {"BGR8",  IMGFMT_BGR|8},
 170                 {"BGR15", IMGFMT_BGR|15},
 171                 {"BGR16", IMGFMT_BGR|16},
 172                 {"BGR24", IMGFMT_BGR|24},
 173                 {"BGR32", IMGFMT_BGR|32},
 174                 {"RGB1",  IMGFMT_RGB|1},
 175                 {"BGR1",  IMGFMT_BGR|1},
 176
 177                 {"MPES",  IMGFMT_MPEGPES},
 178                 {"ZRMJPEGNI", IMGFMT_ZRMJPEGNI},
 179                 {"ZRMJPEGIT", IMGFMT_ZRMJPEGIT},
 180                 {"ZRMJPEGIB", IMGFMT_ZRMJPEGIB},
 181
 182                 {"IDCT_MPEG2",IMGFMT_XVMC_IDCT_MPEG2},
 183                 {"MOCO_MPEG2",IMGFMT_XVMC_MOCO_MPEG2},
 184
 185                 {NULL,    0}
 186         };
 187
 188
 189 static int add_to_inout(char *sfmt, char *sflags, unsigned int *outfmt,
 190                 unsigned char *outflags)
 191 {
 192
 193         static char *flagstr[] = {
 194                 "flip",
 195                 "noflip",
 196                 "yuvhack",
 197                 "query",
 198                 "static",
 199                 NULL
 200         };
 201
 202         int i, j, freeslots;
 203         unsigned char flags;
 204
 205         for (i = 0; i < CODECS_MAX_OUTFMT && outfmt[i] != 0xffffffff; i++)
 206                 /* NOTHING */;
 207         freeslots = CODECS_MAX_OUTFMT - i;
 208         if (!freeslots)
 209                 goto err_out_too_many;
 210
 211         flags = 0;
 212         if(sflags) {
 213                 do {
 214                         for (j = 0; flagstr[j] != NULL; j++)
 215                                 if (!strncmp(sflags, flagstr[j],
 216                                                         strlen(flagstr[j])))
 217                                         break;
 218                         if (flagstr[j] == NULL)
 219                                 goto err_out_parse_error;
 220                         flags|=(1<<j);
 221                         sflags+=strlen(flagstr[j]);
 222                 } while (*(sflags++) == ',');
 223
 224                 if (*(--sflags) != '\0')
 225                         goto err_out_parse_error;
 226         }
 227
 228         do {
 229                 for (j = 0; fmt_table[j].name != NULL; j++)
 230                         if (!strncmp(sfmt, fmt_table[j].name, strlen(fmt_table[j].name)))
 231                                 break;
 232                 if (fmt_table[j].name == NULL)
 233                         goto err_out_parse_error;
 234                 outfmt[i] = fmt_table[j].num;
 235                 outflags[i] = flags;
 236                 ++i;
 237                 sfmt+=strlen(fmt_table[j].name);
 238         } while ((*(sfmt++) == ',') && --freeslots);
 239
 240         if (!freeslots)
 241                 goto err_out_too_many;
 242
 243         if (*(--sfmt) != '\0')
 244                 goto err_out_parse_error;
 245
 246         return 1;
 247 err_out_too_many:
 248         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_TooManyOut);
 249         return 0;
 250 err_out_parse_error:
 251         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_ParseError);
 252         return 0;
 253 }
 254
 255 #if 0
 256 static short get_driver(char *s,int audioflag)
 257 {
 258         static char *audiodrv[] = {
 259                 "null",
 260                 "mp3lib",
 261                 "pcm",
 262                 "libac3",
 263                 "acm",
 264                 "alaw",
 265                 "msgsm",
 266                 "dshow",
 267                 "dvdpcm",
 268                 "hwac3",
 269                 "libvorbis",
 270                 "ffmpeg",
 271                 "libmad",
 272                 "msadpcm",
 273                 "liba52",
 274                 "g72x",
 275                 "imaadpcm",
 276                 "dk4adpcm",
 277                 "dk3adpcm",
 278                 "roqaudio",
 279                 "faad",
 280                 "realaud",
 281                 "libdv",
 282                 NULL
 283         };
 284         static char *videodrv[] = {
 285                 "null",
 286                 "libmpeg2",
 287                 "vfw",
 288                 "dshow",
 289                 "ffmpeg",
 290                 "vfwex",
 291                 "raw",
 292                 "msrle",
 293                 "xanim",
 294                 "msvidc",
 295                 "fli",
 296                 "cinepak",
 297                 "qtrle",
 298                 "nuv",
 299                 "cyuv",
 300                 "qtsmc",
 301                 "ducktm1",
 302                 "roqvideo",
 303                 "qtrpza",
 304                 "mpng",
 305                 "ijpg",
 306                 "zlib",
 307                 "mpegpes",
 308                 "zrmjpeg",
 309                 "realvid",
 310                 "xvid",
 311                 "libdv",
 312                 NULL
 313         };
 314         char **drv=audioflag?audiodrv:videodrv;
 315         int i;
 316
 317         for(i=0;drv[i];i++) if(!strcmp(s,drv[i])) return i;
 318
 319         return -1;
 320 }
 321 #endif
 322
 323 static int validate_codec(codecs_t *c, int type)
 324 {
 325         unsigned int i;
 326         char *tmp_name = c->name;
 327
 328         for (i = 0; i < strlen(tmp_name) && isalnum(tmp_name[i]); i++)
 329                 /* NOTHING */;
 330
 331         if (i < strlen(tmp_name)) {
 332                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_InvalidCodecName, c->name);
 333                 return 0;
 334         }
 335
 336         if (!c->info)
 337                 c->info = strdup(c->name);
 338
 339 #if 0
 340         if (c->fourcc[0] == 0xffffffff) {
 341                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecLacksFourcc, c->name);
 342                 return 0;
 343         }
 344 #endif
 345
 346         if (!c->drv) {
 347                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecLacksDriver, c->name);
 348                 return 0;
 349         }
 350
 351 #if 0
 352 #warning codec->driver == 4;... <- this should not be put in here...
 353 #warning Where are they defined ????????????
 354         if (!c->dll && (c->driver == 4 ||
 355                                 (c->driver == 2 && type == TYPE_VIDEO))) {
 356                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecNeedsDLL, c->name);
 357                 return 0;
 358         }
 359 #warning Can guid.f1 be 0? How does one know that it was not given?
 360 //      if (!(codec->flags & CODECS_FLAG_AUDIO) && codec->driver == 4)
 361
 362         if (type == TYPE_VIDEO)
 363                 if (c->outfmt[0] == 0xffffffff) {
 364                         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecNeedsOutfmt, c->name);
 365                         return 0;
 366                 }
 367 #endif
 368         return 1;
 369 }
 370
 371 static int add_comment(char *s, char **d)
 372 {
 373         int pos;
 374
 375         if (!*d)
 376                 pos = 0;
 377         else {
 378                 pos = strlen(*d);
 379                 (*d)[pos++] = '\n';
 380         }
 381         if (!(*d = realloc(*d, pos + strlen(s) + 1))) {
 382                 mp_msg(MSGT_CODECCFG,MSGL_FATAL,MSGTR_CantAllocateComment);
 383                 return 0;
 384         }
 385         strcpy(*d + pos, s);
 386         return 1;
 387 }
 388
 389 static short get_cpuflags(char *s)
 390 {
 391         static char *flagstr[] = {
 392                 "mmx",
 393                 "sse",
 394                 "3dnow",
 395                 NULL
 396         };
 397         int i;
 398         short flags = 0;
 399
 400         do {
 401                 for (i = 0; flagstr[i]; i++)
 402                         if (!strncmp(s, flagstr[i], strlen(flagstr[i])))
 403                                 break;
 404                 if (!flagstr[i])
 405                         goto err_out_parse_error;
 406                 flags |= 1<<i;
 407                 s += strlen(flagstr[i]);
 408         } while (*(s++) == ',');
 409
 410         if (*(--s) != '\0')
 411                 goto err_out_parse_error;
 412
 413         return flags;
 414 err_out_parse_error:
 415         return 0;
 416 }
 417
 418 static FILE *fp;
 419 static int line_num = 0;
 420 static char *line;
 421 static char *token[MAX_NR_TOKEN];
 422 static int read_nextline = 1;
 423
 424 static int get_token(int min, int max)
 425 {
 426         static int line_pos;
 427         int i;
 428         char c;
 429
 430         if (max >= MAX_NR_TOKEN) {
 431                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_GetTokenMaxNotLessThanMAX_NR_TOKEN);
 432                 goto out_eof;
 433         }
 434
 435         memset(token, 0x00, sizeof(*token) * max);
 436
 437         if (read_nextline) {
 438                 if (!fgets(line, MAX_LINE_LEN, fp))
 439                         goto out_eof;
 440                 line_pos = 0;
 441                 ++line_num;
 442                 read_nextline = 0;
 443         }
 444         for (i = 0; i < max; i++) {
 445                 while (isspace(line[line_pos]))
 446                         ++line_pos;
 447                 if (line[line_pos] == '\0' || line[line_pos] == '#' ||
 448                                 line[line_pos] == ';') {
 449                         read_nextline = 1;
 450                         if (i >= min)
 451                                 goto out_ok;
 452                         goto out_eol;
 453                 }
 454                 token[i] = line + line_pos;
 455                 c = line[line_pos];
 456                 if (c == '"' || c == '\'') {
 457                         token[i]++;
 458                         while (line[++line_pos] != c && line[line_pos])
 459                                 /* NOTHING */;
 460                 } else {
 461                         for (/* NOTHING */; !isspace(line[line_pos]) &&
 462                                         line[line_pos]; line_pos++)
 463                                 /* NOTHING */;
 464                 }
 465                 if (!line[line_pos]) {
 466                         read_nextline = 1;
 467                         if (i >= min - 1)
 468                                 goto out_ok;
 469                         goto out_eol;
 470                 }
 471                 line[line_pos] = '\0';
 472                 line_pos++;
 473         }
 474 out_ok:
 475         return i;
 476 out_eof:
 477         read_nextline = 1;
 478         return RET_EOF;
 479 out_eol:
 480         return RET_EOL;
 481 }
 482
 483 static codecs_t *video_codecs=NULL;
 484 static codecs_t *audio_codecs=NULL;
 485 static int nr_vcodecs = 0;
 486 static int nr_acodecs = 0;
 487
 488 int parse_codec_cfg(const char *cfgfile)
 489 {
 490         codecs_t *codec = NULL; // current codec
 491         codecs_t **codecsp = NULL;// points to audio_codecs or to video_codecs
 492         char *endptr;   // strtoul()...
 493         int *nr_codecsp;
 494         int codec_type;         /* TYPE_VIDEO/TYPE_AUDIO */
 495         int tmp, i;
 496
 497         // in case we call it a second time
 498         codecs_uninit_free();
 499
 500         nr_vcodecs = 0;
 501         nr_acodecs = 0;
 502
 503         if(cfgfile==NULL) {
 504 #ifdef CODECS2HTML
 505                 return 0;
 506 #else
 507                 video_codecs = builtin_video_codecs;
 508                 audio_codecs = builtin_audio_codecs;
 509                 nr_vcodecs = sizeof(builtin_video_codecs)/sizeof(codecs_t);
 510                 nr_acodecs = sizeof(builtin_audio_codecs)/sizeof(codecs_t);
 511                 return 1;
 512 #endif
 513         }
 514
 515         mp_msg(MSGT_CODECCFG,MSGL_V,MSGTR_ReadingFile, cfgfile);
 516
 517         if ((fp = fopen(cfgfile, "r")) == NULL) {
 518                 mp_msg(MSGT_CODECCFG,MSGL_V,MSGTR_CantOpenFileError, cfgfile, strerror(errno));
 519                 return 0;
 520         }
 521
 522         if ((line = malloc(MAX_LINE_LEN + 1)) == NULL) {
 523                 mp_msg(MSGT_CODECCFG,MSGL_FATAL,MSGTR_CantGetMemoryForLine, strerror(errno));
 524                 return 0;
 525         }
 526         read_nextline = 1;
 527
 528         /*
 529          * this only catches release lines at the start of
 530          * codecs.conf, before audiocodecs and videocodecs.
 531          */
 532         while ((tmp = get_token(1, 1)) == RET_EOL)
 533                 /* NOTHING */;
 534         if (tmp == RET_EOF)
 535                 goto out;
 536         if (!strcmp(token[0], "release")) {
 537                 if (get_token(1, 2) < 0)
 538                         goto err_out_parse_error;
 539                 tmp = atoi(token[0]);
 540                 if (tmp < CODEC_CFG_MIN)
 541                         goto err_out_release_num;
 542                 while ((tmp = get_token(1, 1)) == RET_EOL)
 543                         /* NOTHING */;
 544                 if (tmp == RET_EOF)
 545                         goto out;
 546         } else
 547                 goto err_out_release_num;
 548
 549         /*
 550          * check if the next block starts with 'audiocodec' or
 551          * with 'videocodec'
 552          */
 553         if (!strcmp(token[0], "audiocodec") || !strcmp(token[0], "videocodec"))
 554                 goto loop_enter;
 555         goto err_out_parse_error;
 556
 557         while ((tmp = get_token(1, 1)) != RET_EOF) {
 558                 if (tmp == RET_EOL)
 559                         continue;
 560                 if (!strcmp(token[0], "audiocodec") ||
 561                                 !strcmp(token[0], "videocodec")) {
 562                         if (!validate_codec(codec, codec_type))
 563                                 goto err_out_not_valid;
 564                 loop_enter:
 565                         if (*token[0] == 'v') {
 566                                 codec_type = TYPE_VIDEO;
 567                                 nr_codecsp = &nr_vcodecs;
 568                                 codecsp = &video_codecs;
 569                         } else if (*token[0] == 'a') {
 570                                 codec_type = TYPE_AUDIO;
 571                                 nr_codecsp = &nr_acodecs;
 572                                 codecsp = &audio_codecs;
 573 #ifdef DEBUG
 574                         } else {
 575                                 mp_msg(MSGT_CODECCFG,MSGL_ERR,"picsba\n");
 576                                 goto err_out;
 577 #endif
 578                         }
 579                         if (!(*codecsp = realloc(*codecsp,
 580                                 sizeof(codecs_t) * (*nr_codecsp + 2)))) {
 581                             mp_msg(MSGT_CODECCFG,MSGL_FATAL,MSGTR_CantReallocCodecsp, strerror(errno));
 582                             goto err_out;
 583                         }
 584                         codec=*codecsp + *nr_codecsp;
 585                         ++*nr_codecsp;
 586                         memset(codec,0,sizeof(codecs_t));
 587                         memset(codec->fourcc, 0xff, sizeof(codec->fourcc));
 588                         memset(codec->outfmt, 0xff, sizeof(codec->outfmt));
 589                         memset(codec->infmt, 0xff, sizeof(codec->infmt));
 590
 591                         if (get_token(1, 1) < 0)
 592                                 goto err_out_parse_error;
 593                         for (i = 0; i < *nr_codecsp - 1; i++) {
 594                                 if(( (*codecsp)[i].name!=NULL) &&
 595                                     (!strcmp(token[0], (*codecsp)[i].name)) ) {
 596                                         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecNameNotUnique, token[0]);
 597                                         goto err_out_print_linenum;
 598                                 }
 599                         }
 600                         if (!(codec->name = strdup(token[0]))) {
 601                                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CantStrdupName, strerror(errno));
 602                                 goto err_out;
 603                         }
 604                 } else if (!strcmp(token[0], "info")) {
 605                         if (codec->info || get_token(1, 1) < 0)
 606                                 goto err_out_parse_error;
 607                         if (!(codec->info = strdup(token[0]))) {
 608                                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CantStrdupInfo, strerror(errno));
 609                                 goto err_out;
 610                         }
 611                 } else if (!strcmp(token[0], "comment")) {
 612                         if (get_token(1, 1) < 0)
 613                                 goto err_out_parse_error;
 614                         add_comment(token[0], &codec->comment);
 615                 } else if (!strcmp(token[0], "fourcc")) {
 616                         if (get_token(1, 2) < 0)
 617                                 goto err_out_parse_error;
 618                         if (!add_to_fourcc(token[0], token[1],
 619                                                 codec->fourcc,
 620                                                 codec->fourccmap))
 621                                 goto err_out_print_linenum;
 622                 } else if (!strcmp(token[0], "format")) {
 623                         if (get_token(1, 2) < 0)
 624                                 goto err_out_parse_error;
 625                         if (!add_to_format(token[0], token[1],
 626                                         codec->fourcc,codec->fourccmap))
 627                                 goto err_out_print_linenum;
 628                 } else if (!strcmp(token[0], "driver")) {
 629                         if (get_token(1, 1) < 0)
 630                                 goto err_out_parse_error;
 631                         if (!(codec->drv = strdup(token[0]))) {
 632                                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CantStrdupDriver, strerror(errno));
 633                                 goto err_out;
 634                         }
 635                 } else if (!strcmp(token[0], "dll")) {
 636                         if (get_token(1, 1) < 0)
 637                                 goto err_out_parse_error;
 638                         if (!(codec->dll = strdup(token[0]))) {
 639                                 mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CantStrdupDLL, strerror(errno));
 640                                 goto err_out;
 641                         }
 642                 } else if (!strcmp(token[0], "guid")) {
 643                         if (get_token(11, 11) < 0)
 644                                 goto err_out_parse_error;
 645                         codec->guid.f1=strtoul(token[0],&endptr,0);
 646                         if ((*endptr != ',' || *(endptr + 1) != '\0') &&
 647                                         *endptr != '\0')
 648                                 goto err_out_parse_error;
 649                         codec->guid.f2=strtoul(token[1],&endptr,0);
 650                         if ((*endptr != ',' || *(endptr + 1) != '\0') &&
 651                                         *endptr != '\0')
 652                                 goto err_out_parse_error;
 653                         codec->guid.f3=strtoul(token[2],&endptr,0);
 654                         if ((*endptr != ',' || *(endptr + 1) != '\0') &&
 655                                         *endptr != '\0')
 656                                 goto err_out_parse_error;
 657                         for (i = 0; i < 8; i++) {
 658                             codec->guid.f4[i]=strtoul(token[i + 3],&endptr,0);
 659                                 if ((*endptr != ',' || *(endptr + 1) != '\0') &&
 660                                                 *endptr != '\0')
 661                                         goto err_out_parse_error;
 662                         }
 663                 } else if (!strcmp(token[0], "out")) {
 664                         if (get_token(1, 2) < 0)
 665                                 goto err_out_parse_error;
 666                         if (!add_to_inout(token[0], token[1], codec->outfmt,
 667                                                 codec->outflags))
 668                                 goto err_out_print_linenum;
 669                 } else if (!strcmp(token[0], "in")) {
 670                         if (get_token(1, 2) < 0)
 671                                 goto err_out_parse_error;
 672                         if (!add_to_inout(token[0], token[1], codec->infmt,
 673                                                 codec->inflags))
 674                                 goto err_out_print_linenum;
 675                 } else if (!strcmp(token[0], "flags")) {
 676                         if (get_token(1, 1) < 0)
 677                                 goto err_out_parse_error;
 678                         if (!strcmp(token[0], "seekable"))
 679                                 codec->flags |= CODECS_FLAG_SEEKABLE;
 680                         else
 681                         if (!strcmp(token[0], "align16"))
 682                                 codec->flags |= CODECS_FLAG_ALIGN16;
 683                         else
 684                                 goto err_out_parse_error;
 685                 } else if (!strcmp(token[0], "status")) {
 686                         if (get_token(1, 1) < 0)
 687                                 goto err_out_parse_error;
 688                         if (!strcasecmp(token[0], "working"))
 689                                 codec->status = CODECS_STATUS_WORKING;
 690                         else if (!strcasecmp(token[0], "crashing"))
 691                                 codec->status = CODECS_STATUS_NOT_WORKING;
 692                         else if (!strcasecmp(token[0], "untested"))
 693                                 codec->status = CODECS_STATUS_UNTESTED;
 694                         else if (!strcasecmp(token[0], "buggy"))
 695                                 codec->status = CODECS_STATUS_PROBLEMS;
 696                         else
 697                                 goto err_out_parse_error;
 698                 } else if (!strcmp(token[0], "cpuflags")) {
 699                         if (get_token(1, 1) < 0)
 700                                 goto err_out_parse_error;
 701                         if (!(codec->cpuflags = get_cpuflags(token[0])))
 702                                 goto err_out_parse_error;
 703                 } else
 704                         goto err_out_parse_error;
 705         }
 706         if (!validate_codec(codec, codec_type))
 707                 goto err_out_not_valid;
 708         mp_msg(MSGT_CODECCFG,MSGL_INFO,MSGTR_AudioVideoCodecTotals, nr_acodecs, nr_vcodecs);
 709         if(video_codecs) video_codecs[nr_vcodecs].name = NULL;
 710         if(audio_codecs) audio_codecs[nr_acodecs].name = NULL;
 711 out:
 712         free(line);
 713         line=NULL;
 714         fclose(fp);
 715         return 1;
 716
 717 err_out_parse_error:
 718         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_ParseError);
 719 err_out_print_linenum:
 720         PRINT_LINENUM;
 721 err_out:
 722         codecs_uninit_free();
 723
 724         free(line);
 725         line=NULL;
 726         line_num = 0;
 727         fclose(fp);
 728         return 0;
 729 err_out_not_valid:
 730         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_CodecDefinitionIncorrect);
 731         goto err_out_print_linenum;
 732 err_out_release_num:
 733         mp_msg(MSGT_CODECCFG,MSGL_ERR,MSGTR_OutdatedCodecsConf);
 734         goto err_out_print_linenum;
 735 }
 736
 737 static void codecs_free(codecs_t* codecs,int count) {
 738         int i;
 739                 for ( i = 0; i < count; i++)
 740                         if ( codecs[i].name ) {
 741                                 if( codecs[i].name )
 742                                         free(codecs[i].name);
 743                                 if( codecs[i].info )
 744                                         free(codecs[i].info);
 745                                 if( codecs[i].comment )
 746                                         free(codecs[i].comment);
 747                                 if( codecs[i].dll )
 748                                         free(codecs[i].dll);
 749                                 if( codecs[i].drv )
 750                                         free(codecs[i].drv);
 751                         }
 752                 if (codecs)
 753                         free(codecs);
 754 }
 755
 756 void codecs_uninit_free(void) {
 757         if (video_codecs)
 758         codecs_free(video_codecs,nr_vcodecs);
 759         video_codecs=NULL;
 760         if (audio_codecs)
 761         codecs_free(audio_codecs,nr_acodecs);
 762         audio_codecs=NULL;
 763 }
 764
 765 codecs_t *find_audio_codec(unsigned int fourcc, unsigned int *fourccmap,
 766                 codecs_t *start, int force)
 767 {
 768         return find_codec(fourcc, fourccmap, start, 1, force);
 769 }
 770
 771 codecs_t *find_video_codec(unsigned int fourcc, unsigned int *fourccmap,
 772                 codecs_t *start, int force)
 773 {
 774         return find_codec(fourcc, fourccmap, start, 0, force);
 775 }
 776
 777 codecs_t* find_codec(unsigned int fourcc,unsigned int *fourccmap,
 778                 codecs_t *start, int audioflag, int force)
 779 {
 780         int i, j;
 781         codecs_t *c;
 782
 783 #if 0
 784         if (start) {
 785                 for (/* NOTHING */; start->name; start++) {
 786                         for (j = 0; j < CODECS_MAX_FOURCC; j++) {
 787                                 if (start->fourcc[j] == fourcc) {
 788                                         if (fourccmap)
 789                                                 *fourccmap = start->fourccmap[j];
 790                                         return start;
 791                                 }
 792                         }
 793                 }
 794         } else
 795 #endif
 796         {
 797                 if (audioflag) {
 798                         i = nr_acodecs;
 799                         c = audio_codecs;
 800                 } else {
 801                         i = nr_vcodecs;
 802                         c = video_codecs;
 803                 }
 804                 if(!i) return NULL;
 805                 for (/* NOTHING */; i--; c++) {
 806                         if(start && c<=start) continue;
 807                         for (j = 0; j < CODECS_MAX_FOURCC; j++) {
 808                                 // FIXME: do NOT hardwire 'null' name here:
 809                                 if (c->fourcc[j]==fourcc || !strcmp(c->drv,"null")) {
 810                                         if (fourccmap)
 811                                                 *fourccmap = c->fourccmap[j];
 812                                         return c;
 813                                 }
 814                         }
 815                         if (force) return c;
 816                 }
 817         }
 818         return NULL;
 819 }
 820
 821 void stringset_init(stringset_t *set) {
 822   *set = calloc(1, sizeof(char *));
 823 }
 824
 825 void stringset_free(stringset_t *set) {
 826   int count = 0;
 827   while ((*set)[count]) free((*set)[count++]);
 828   free(*set);
 829   *set = NULL;
 830 }
 831
 832 void stringset_add(stringset_t *set, const char *str) {
 833   int count = 0;
 834   while ((*set)[count]) count++;
 835   count++;
 836   *set = realloc(*set, sizeof(char *) * (count + 1));
 837   (*set)[count - 1] = strdup(str);
 838   (*set)[count] = NULL;
 839 }
 840
 841 int stringset_test(stringset_t *set, const char *str) {
 842   stringset_t s;
 843   for (s = *set; *s; s++)
 844     if (strcmp(*s, str) == 0)
 845       return 1;
 846   return 0;
 847 }
 848
 849 void list_codecs(int audioflag){
 850         int i;
 851         codecs_t *c;
 852
 853                 if (audioflag) {
 854                         i = nr_acodecs;
 855                         c = audio_codecs;
 856                         mp_msg(MSGT_CODECCFG,MSGL_INFO,"ac:         afm:      status:   info:  [lib/dll]\n");
 857                 } else {
 858                         i = nr_vcodecs;
 859                         c = video_codecs;
 860                         mp_msg(MSGT_CODECCFG,MSGL_INFO,"vc:         vfm:      status:   info:  [lib/dll]\n");
 861                 }
 862                 if(!i) return;
 863                 for (/* NOTHING */; i--; c++) {
 864                         char* s="unknown ";
 865                         switch(c->status){
 866                           case CODECS_STATUS_WORKING:     s="working ";break;
 867                           case CODECS_STATUS_PROBLEMS:    s="problems";break;
 868                           case CODECS_STATUS_NOT_WORKING: s="crashing";break;
 869                           case CODECS_STATUS_UNTESTED:    s="untested";break;
 870                         }
 871                         if(c->dll)
 872                           mp_msg(MSGT_CODECCFG,MSGL_INFO,"%-11s %-9s %s  %s  [%s]\n",c->name,c->drv,s,c->info,c->dll);
 873                         else
 874                           mp_msg(MSGT_CODECCFG,MSGL_INFO,"%-11s %-9s %s  %s\n",c->name,c->drv,s,c->info);
 875
 876                 }
 877
 878 }
 879
 880
 881
 882 #ifdef CODECS2HTML
 883 /*
 884  * Fake out GUI references when building the codecs2html utility.
 885  */
 886 #ifdef HAVE_NEW_GUI
 887 void gtkMessageBox( int type,char * str ) { return; }
 888 int use_gui = 0;
 889 #endif
 890
 891 void wrapline(FILE *f2,char *s){
 892     int c;
 893     if(!s){
 894         fprintf(f2,"-");
 895         return;
 896     }
 897     while((c=*s++)){
 898         if(c==',') fprintf(f2,"<br>"); else fputc(c,f2);
 899     }
 900 }
 901
 902 void parsehtml(FILE *f1,FILE *f2,codecs_t *codec,int section,int dshow){
 903         int c,d;
 904         while((c=fgetc(f1))>=0){
 905             if(c!='%'){
 906                 fputc(c,f2);
 907                 continue;
 908             }
 909             d=fgetc(f1);
 910
 911             switch(d){
 912             case '.':
 913                 return; // end of section
 914             case 'n':
 915                 wrapline(f2,codec->name); break;
 916             case 'i':
 917                 wrapline(f2,codec->info); break;
 918             case 'c':
 919                 wrapline(f2,codec->comment); break;
 920             case 'd':
 921                 wrapline(f2,codec->dll); break;
 922             case 'D':
 923                 fprintf(f2,"%c",!strcmp(codec->drv,"dshow")?'+':'-'); break;
 924             case 'F':
 925                 for(d=0;d<CODECS_MAX_FOURCC;d++)
 926                     if(!d || codec->fourcc[d]!=0xFFFFFFFF)
 927                         fprintf(f2,"%s%.4s",d?"<br>":"",(codec->fourcc[d]==0xFFFFFFFF || codec->fourcc[d]<0x20202020)?!d?"-":"":(char*) &codec->fourcc[d]);
 928                 break;
 929             case 'f':
 930                 for(d=0;d<CODECS_MAX_FOURCC;d++)
 931                     if(codec->fourcc[d]!=0xFFFFFFFF)
 932                         fprintf(f2,"%s0x%X",d?"<br>":"",codec->fourcc[d]);
 933                 break;
 934             case 'Y':
 935                 for(d=0;d<CODECS_MAX_OUTFMT;d++)
 936                     if(codec->outfmt[d]!=0xFFFFFFFF){
 937                         for (c=0; fmt_table[c].name; c++)
 938                             if(fmt_table[c].num==codec->outfmt[d]) break;
 939                         if(fmt_table[c].name)
 940                             fprintf(f2,"%s%s",d?"<br>":"",fmt_table[c].name);
 941                     }
 942                 break;
 943             default:
 944                 fputc(c,f2);
 945                 fputc(d,f2);
 946             }
 947         }
 948
 949 }
 950
 951 void skiphtml(FILE *f1){
 952         int c,d;
 953         while((c=fgetc(f1))>=0){
 954             if(c!='%'){
 955                 continue;
 956             }
 957             d=fgetc(f1);
 958             if(d=='.') return; // end of section
 959         }
 960 }
 961
 962 static void print_int_array(const int* a, int size)
 963 {
 964         printf("{ ");
 965         while (size--)
 966             if(abs(*a)<256)
 967                 printf("%d%s", *a++, size?", ":"");
 968             else
 969                 printf("0x%X%s", *a++, size?", ":"");
 970         printf(" }");
 971 }
 972
 973 static void print_char_array(const unsigned char* a, int size)
 974 {
 975         printf("{ ");
 976         while (size--)
 977             if((*a)<10)
 978                 printf("%d%s", *a++, size?", ":"");
 979             else
 980                 printf("0x%02x%s", *a++, size?", ":"");
 981         printf(" }");
 982 }
 983
 984 static void print_string(const char* s)
 985 {
 986         if (!s) printf("NULL");
 987         else printf("\"%s\"", s);
 988 }
 989
 990 int main(int argc, char* argv[])
 991 {
 992         codecs_t *cl;
 993         FILE *f1;
 994         FILE *f2;
 995         int c,d,i;
 996         int pos;
 997         int section=-1;
 998         int nr_codecs;
 999         int win32=-1;
1000         int dshow=-1;
1001         int win32ex=-1;
1002
1003         /*
1004          * Take path to codecs.conf from command line, or fall back on
1005          * etc/codecs.conf
1006          */
1007         if (!(nr_codecs = parse_codec_cfg((argc>1)?argv[1]:"etc/codecs.conf")))
1008                 exit(1);
1009
1010         if (argc > 1) {
1011                 int i, j;
1012                 const char* nm[2];
1013                 codecs_t* cod[2];
1014                 int nr[2];
1015
1016                 nm[0] = "builtin_video_codecs";
1017                 cod[0] = video_codecs;
1018                 nr[0] = nr_vcodecs;
1019
1020                 nm[1] = "builtin_audio_codecs";
1021                 cod[1] = audio_codecs;
1022                 nr[1] = nr_acodecs;
1023
1024                 printf("/* GENERATED FROM %s, DO NOT EDIT! */\n\n",argv[1]);
1025
1026                 for (i=0; i<2; i++) {
1027                         printf("const codecs_t %s[] = {\n", nm[i]);
1028                         for (j = 0; j < nr[i]; j++) {
1029                                 printf("{");
1030
1031                                 print_int_array(cod[i][j].fourcc, CODECS_MAX_FOURCC);
1032                                 printf(", /* fourcc */\n");
1033
1034                                 print_int_array(cod[i][j].fourccmap, CODECS_MAX_FOURCC);
1035                                 printf(", /* fourccmap */\n");
1036
1037                                 print_int_array(cod[i][j].outfmt, CODECS_MAX_OUTFMT);
1038                                 printf(", /* outfmt */\n");
1039
1040                                 print_char_array(cod[i][j].outflags, CODECS_MAX_OUTFMT);
1041                                 printf(", /* outflags */\n");
1042
1043                                 print_int_array(cod[i][j].infmt, CODECS_MAX_INFMT);
1044                                 printf(", /* infmt */\n");
1045
1046                                 print_char_array(cod[i][j].inflags, CODECS_MAX_INFMT);
1047                                 printf(", /* inflags */\n");
1048
1049                                 print_string(cod[i][j].name);    printf(", /* name */\n");
1050                                 print_string(cod[i][j].info);    printf(", /* info */\n");
1051                                 print_string(cod[i][j].comment); printf(", /* comment */\n");
1052                                 print_string(cod[i][j].dll);     printf(", /* dll */\n");
1053                                 print_string(cod[i][j].drv);     printf(", /* drv */\n");
1054
1055                                 printf("{ 0x%08lx, %hu, %hu,",
1056                                        cod[i][j].guid.f1,
1057                                        cod[i][j].guid.f2,
1058                                        cod[i][j].guid.f3);
1059                                 print_char_array(cod[i][j].guid.f4, sizeof(cod[i][j].guid.f4));
1060                                 printf(" }, /* GUID */\n");
1061                                 printf("%hd /* flags */, %hd /* status */, %hd /* cpuflags */ }\n",
1062                                        cod[i][j].flags,
1063                                        cod[i][j].status,
1064                                        cod[i][j].cpuflags);
1065                                 if (j < nr[i]) printf(",\n");
1066                         }
1067                         printf("};\n\n");
1068                 }
1069                 exit(0);
1070         }
1071
1072         f1=fopen("DOCS/tech/codecs-in.html","rb"); if(!f1) exit(1);
1073         f2=fopen("DOCS/codecs-status.html","wb"); if(!f2) exit(1);
1074
1075         while((c=fgetc(f1))>=0){
1076             if(c!='%'){
1077                 fputc(c,f2);
1078                 continue;
1079             }
1080             d=fgetc(f1);
1081             if(d>='0' && d<='9'){
1082                 // begin section
1083                 section=d-'0';
1084                 //printf("BEGIN %d\n",section);
1085                 if(section>=5){
1086                     // audio
1087                     cl = audio_codecs;
1088                     nr_codecs = nr_acodecs;
1089                     dshow=7;win32=4;
1090                 } else {
1091                     // video
1092                     cl = video_codecs;
1093                     nr_codecs = nr_vcodecs;
1094                     dshow=4;win32=2;win32ex=6;
1095                 }
1096                 pos=ftell(f1);
1097                 for(i=0;i<nr_codecs;i++){
1098                     fseek(f1,pos,SEEK_SET);
1099                     switch(section){
1100                     case 0:
1101                     case 5:
1102                         if(cl[i].status==CODECS_STATUS_WORKING)
1103 //                            if(!(!strcmp(cl[i].drv,"vfw") || !strcmp(cl[i].drv,"dshow") || !strcmp(cl[i].drv,"vfwex") || !strcmp(cl[i].drv,"acm")))
1104                                 parsehtml(f1,f2,&cl[i],section,dshow);
1105                         break;
1106 #if 0
1107                     case 1:
1108                     case 6:
1109                         if(cl[i].status==CODECS_STATUS_WORKING)
1110                             if((!strcmp(cl[i].drv,"vfw") || !strcmp(cl[i].drv,"dshow") || !strcmp(cl[i].drv,"vfwex") || !strcmp(cl[i].drv,"acm")))
1111                                 parsehtml(f1,f2,&cl[i],section,dshow);
1112                         break;
1113 #endif
1114                     case 2:
1115                     case 7:
1116                         if(cl[i].status==CODECS_STATUS_PROBLEMS)
1117                             parsehtml(f1,f2,&cl[i],section,dshow);
1118                         break;
1119                     case 3:
1120                     case 8:
1121                         if(cl[i].status==CODECS_STATUS_NOT_WORKING)
1122                             parsehtml(f1,f2,&cl[i],section,dshow);
1123                         break;
1124                     case 4:
1125                     case 9:
1126                         if(cl[i].status==CODECS_STATUS_UNTESTED)
1127                             parsehtml(f1,f2,&cl[i],section,dshow);
1128                         break;
1129                     default:
1130                         printf("Warning! unimplemented section: %d\n",section);
1131                     }
1132                 }
1133                 fseek(f1,pos,SEEK_SET);
1134                 skiphtml(f1);
1135 //void parsehtml(FILE *f1,FILE *f2,codecs_t *codec,int section,int dshow){
1136
1137                 continue;
1138             }
1139             fputc(c,f2);
1140             fputc(d,f2);
1141         }
1142
1143         fclose(f2);
1144         fclose(f1);
1145         return 0;
1146 }
1147
1148 #endif
1149
1150 #ifdef TESTING
1151 int main(void)
1152 {
1153         codecs_t *c;
1154         int i,j, nr_codecs, state;
1155
1156         if (!(parse_codec_cfg("etc/codecs.conf")))
1157                 return 0;
1158         if (!video_codecs)
1159                 printf("no videoconfig.\n");
1160         if (!audio_codecs)
1161                 printf("no audioconfig.\n");
1162
1163         printf("videocodecs:\n");
1164         c = video_codecs;
1165         nr_codecs = nr_vcodecs;
1166         state = 0;
1167 next:
1168         if (c) {
1169                 printf("number of %scodecs: %d\n", state==0?"video":"audio",
1170                     nr_codecs);
1171                 for(i=0;i<nr_codecs;i++, c++){
1172                     printf("\n============== %scodec %02d ===============\n",
1173                         state==0?"video":"audio",i);
1174                     printf("name='%s'\n",c->name);
1175                     printf("info='%s'\n",c->info);
1176                     printf("comment='%s'\n",c->comment);
1177                     printf("dll='%s'\n",c->dll);
1178                     printf("flags=%X  driver=%d status=%d cpuflags=%d\n",
1179                                     c->flags, c->driver, c->status, c->cpuflags);
1180
1181                     for(j=0;j<CODECS_MAX_FOURCC;j++){
1182                       if(c->fourcc[j]!=0xFFFFFFFF){
1183                           printf("fourcc %02d:  %08X (%.4s) ===> %08X (%.4s)\n",j,c->fourcc[j],(char *) &c->fourcc[j],c->fourccmap[j],(char *) &c->fourccmap[j]);
1184                       }
1185                     }
1186
1187                     for(j=0;j<CODECS_MAX_OUTFMT;j++){
1188                       if(c->outfmt[j]!=0xFFFFFFFF){
1189                           printf("outfmt %02d:  %08X (%.4s)  flags: %d\n",j,c->outfmt[j],(char *) &c->outfmt[j],c->outflags[j]);
1190                       }
1191                     }
1192
1193                     for(j=0;j<CODECS_MAX_INFMT;j++){
1194                       if(c->infmt[j]!=0xFFFFFFFF){
1195                           printf("infmt %02d:  %08X (%.4s)  flags: %d\n",j,c->infmt[j],(char *) &c->infmt[j],c->inflags[j]);
1196                       }
1197                     }
1198
1199                     printf("GUID: %08lX %04X %04X",c->guid.f1,c->guid.f2,c->guid.f3);
1200                     for(j=0;j<8;j++) printf(" %02X",c->guid.f4[j]);
1201                     printf("\n");
1202
1203
1204                 }
1205         }
1206         if (!state) {
1207                 printf("audiocodecs:\n");
1208                 c = audio_codecs;
1209                 nr_codecs = nr_acodecs;
1210                 state = 1;
1211                 goto next;
1212         }
1213         return 0;
1214 }
1215
1216 #endif