codec-cfg.c

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