?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move vo_depthonscreen to x11 struct
[mplayer.git] / codec-cfg.c
blob1ffd22c2f7853fed4d989b909e971b20cb8fb9fe
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 printf("#include <stddef.h>\n",argv[1]);
1026 printf("#include \"codec-cfg.h\"\n\n",argv[1]);
1027
1028 for (i=0; i<2; i++) {
1029 printf("const codecs_t %s[] = {\n", nm[i]);
1030 for (j = 0; j < nr[i]; j++) {
1031 printf("{");
1032
1033 print_int_array(cod[i][j].fourcc, CODECS_MAX_FOURCC);
1034 printf(", /* fourcc */\n");
1035
1036 print_int_array(cod[i][j].fourccmap, CODECS_MAX_FOURCC);
1037 printf(", /* fourccmap */\n");
1038
1039 print_int_array(cod[i][j].outfmt, CODECS_MAX_OUTFMT);
1040 printf(", /* outfmt */\n");
1041
1042 print_char_array(cod[i][j].outflags, CODECS_MAX_OUTFMT);
1043 printf(", /* outflags */\n");
1044
1045 print_int_array(cod[i][j].infmt, CODECS_MAX_INFMT);
1046 printf(", /* infmt */\n");
1047
1048 print_char_array(cod[i][j].inflags, CODECS_MAX_INFMT);
1049 printf(", /* inflags */\n");
1050
1051 print_string(cod[i][j].name); printf(", /* name */\n");
1052 print_string(cod[i][j].info); printf(", /* info */\n");
1053 print_string(cod[i][j].comment); printf(", /* comment */\n");
1054 print_string(cod[i][j].dll); printf(", /* dll */\n");
1055 print_string(cod[i][j].drv); printf(", /* drv */\n");
1056
1057 printf("{ 0x%08lx, %hu, %hu,",
1058 cod[i][j].guid.f1,
1059 cod[i][j].guid.f2,
1060 cod[i][j].guid.f3);
1061 print_char_array(cod[i][j].guid.f4, sizeof(cod[i][j].guid.f4));
1062 printf(" }, /* GUID */\n");
1063 printf("%hd /* flags */, %hd /* status */, %hd /* cpuflags */ }\n",
1064 cod[i][j].flags,
1065 cod[i][j].status,
1066 cod[i][j].cpuflags);
1067 if (j < nr[i]) printf(",\n");
1068 }
1069 printf("};\n\n");
1070 }
1071 exit(0);
1072 }
1073
1074 f1=fopen("DOCS/tech/codecs-in.html","rb"); if(!f1) exit(1);
1075 f2=fopen("DOCS/codecs-status.html","wb"); if(!f2) exit(1);
1076
1077 while((c=fgetc(f1))>=0){
1078 if(c!='%'){
1079 fputc(c,f2);
1080 continue;
1081 }
1082 d=fgetc(f1);
1083 if(d>='0' && d<='9'){
1084 // begin section
1085 section=d-'0';
1086 //printf("BEGIN %d\n",section);
1087 if(section>=5){
1088 // audio
1089 cl = audio_codecs;
1090 nr_codecs = nr_acodecs;
1091 dshow=7;win32=4;
1092 } else {
1093 // video
1094 cl = video_codecs;
1095 nr_codecs = nr_vcodecs;
1096 dshow=4;win32=2;win32ex=6;
1097 }
1098 pos=ftell(f1);
1099 for(i=0;i<nr_codecs;i++){
1100 fseek(f1,pos,SEEK_SET);
1101 switch(section){
1102 case 0:
1103 case 5:
1104 if(cl[i].status==CODECS_STATUS_WORKING)
1105 // if(!(!strcmp(cl[i].drv,"vfw") || !strcmp(cl[i].drv,"dshow") || !strcmp(cl[i].drv,"vfwex") || !strcmp(cl[i].drv,"acm")))
1106 parsehtml(f1,f2,&cl[i],section,dshow);
1107 break;
1108 #if 0
1109 case 1:
1110 case 6:
1111 if(cl[i].status==CODECS_STATUS_WORKING)
1112 if((!strcmp(cl[i].drv,"vfw") || !strcmp(cl[i].drv,"dshow") || !strcmp(cl[i].drv,"vfwex") || !strcmp(cl[i].drv,"acm")))
1113 parsehtml(f1,f2,&cl[i],section,dshow);
1114 break;
1115 #endif
1116 case 2:
1117 case 7:
1118 if(cl[i].status==CODECS_STATUS_PROBLEMS)
1119 parsehtml(f1,f2,&cl[i],section,dshow);
1120 break;
1121 case 3:
1122 case 8:
1123 if(cl[i].status==CODECS_STATUS_NOT_WORKING)
1124 parsehtml(f1,f2,&cl[i],section,dshow);
1125 break;
1126 case 4:
1127 case 9:
1128 if(cl[i].status==CODECS_STATUS_UNTESTED)
1129 parsehtml(f1,f2,&cl[i],section,dshow);
1130 break;
1131 default:
1132 printf("Warning! unimplemented section: %d\n",section);
1133 }
1134 }
1135 fseek(f1,pos,SEEK_SET);
1136 skiphtml(f1);
1137 //void parsehtml(FILE *f1,FILE *f2,codecs_t *codec,int section,int dshow){
1138
1139 continue;
1140 }
1141 fputc(c,f2);
1142 fputc(d,f2);
1143 }
1144
1145 fclose(f2);
1146 fclose(f1);
1147 return 0;
1148 }
1149
1150 #endif
1151
1152 #ifdef TESTING
1153 int main(void)
1154 {
1155 codecs_t *c;
1156 int i,j, nr_codecs, state;
1157
1158 if (!(parse_codec_cfg("etc/codecs.conf")))
1159 return 0;
1160 if (!video_codecs)
1161 printf("no videoconfig.\n");
1162 if (!audio_codecs)
1163 printf("no audioconfig.\n");
1164
1165 printf("videocodecs:\n");
1166 c = video_codecs;
1167 nr_codecs = nr_vcodecs;
1168 state = 0;
1169 next:
1170 if (c) {
1171 printf("number of %scodecs: %d\n", state==0?"video":"audio",
1172 nr_codecs);
1173 for(i=0;i<nr_codecs;i++, c++){
1174 printf("\n============== %scodec %02d ===============\n",
1175 state==0?"video":"audio",i);
1176 printf("name='%s'\n",c->name);
1177 printf("info='%s'\n",c->info);
1178 printf("comment='%s'\n",c->comment);
1179 printf("dll='%s'\n",c->dll);
1180 printf("flags=%X driver=%d status=%d cpuflags=%d\n",
1181 c->flags, c->driver, c->status, c->cpuflags);
1182
1183 for(j=0;j<CODECS_MAX_FOURCC;j++){
1184 if(c->fourcc[j]!=0xFFFFFFFF){
1185 printf("fourcc %02d: %08X (%.4s) ===> %08X (%.4s)\n",j,c->fourcc[j],(char *) &c->fourcc[j],c->fourccmap[j],(char *) &c->fourccmap[j]);
1186 }
1187 }
1188
1189 for(j=0;j<CODECS_MAX_OUTFMT;j++){
1190 if(c->outfmt[j]!=0xFFFFFFFF){
1191 printf("outfmt %02d: %08X (%.4s) flags: %d\n",j,c->outfmt[j],(char *) &c->outfmt[j],c->outflags[j]);
1192 }
1193 }
1194
1195 for(j=0;j<CODECS_MAX_INFMT;j++){
1196 if(c->infmt[j]!=0xFFFFFFFF){
1197 printf("infmt %02d: %08X (%.4s) flags: %d\n",j,c->infmt[j],(char *) &c->infmt[j],c->inflags[j]);
1198 }
1199 }
1200
1201 printf("GUID: %08lX %04X %04X",c->guid.f1,c->guid.f2,c->guid.f3);
1202 for(j=0;j<8;j++) printf(" %02X",c->guid.f4[j]);
1203 printf("\n");
1204
1205
1206 }
1207 }
1208 if (!state) {
1209 printf("audiocodecs:\n");
1210 c = audio_codecs;
1211 nr_codecs = nr_acodecs;
1212 state = 1;
1213 goto next;
1214 }
1215 return 0;
1216 }
1217
1218 #endif
MPlayer development branch