codec-cfg.c

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