* 'externaly' visible option list begins avoptions_ prefix
[ffmpeg.git] / libavcodec / opts.c
1 /*
2  * LGPL
3  */
4
5 /**
6  * @file opts.c
7  * options parser.
8  * typical parsed command line:
9  * msmpeg4:bitrate=720000:qmax=16
10  *
11  */
12
13 #include "avcodec.h"
14
15 const AVOption avoptions_common[] = {
16     AVOPTION_CODEC_FLAG("bit_exact", "use only bit-exact stuff", flags, CODEC_FLAG_BITEXACT, 0),
17     AVOPTION_CODEC_FLAG("mm_force", "force mm flags", dsp_mask, FF_MM_FORCE, 0),
18 #ifdef HAVE_MMX
19     AVOPTION_CODEC_FLAG("mm_mmx", "mask MMX feature", dsp_mask, FF_MM_MMX, 0),
20     AVOPTION_CODEC_FLAG("mm_3dnow", "mask 3DNow feature", dsp_mask, FF_MM_3DNOW, 0),
21     AVOPTION_CODEC_FLAG("mm_mmxext", "mask MMXEXT (MMX2) feature", dsp_mask, FF_MM_MMXEXT, 0),
22     AVOPTION_CODEC_FLAG("mm_sse", "mask SSE feature", dsp_mask, FF_MM_SSE, 0),
23     AVOPTION_CODEC_FLAG("mm_sse2", "mask SSE2 feature", dsp_mask, FF_MM_SSE2, 0),
24 #endif
25     AVOPTION_END()
26 };
27
28 const AVOption avoptions_workaround_bug[] = {
29     AVOPTION_CODEC_FLAG("bug_autodetect", "workaround bug autodetection", workaround_bugs, FF_BUG_AUTODETECT, 1),
30     AVOPTION_CODEC_FLAG("bug_old_msmpeg4", "workaround old msmpeg4 bug", workaround_bugs, FF_BUG_OLD_MSMPEG4, 0),
31     AVOPTION_CODEC_FLAG("bug_xvid_ilace", "workaround XviD interlace bug", workaround_bugs, FF_BUG_XVID_ILACE, 0),
32     AVOPTION_CODEC_FLAG("bug_ump4", "workaround ump4 bug", workaround_bugs, FF_BUG_UMP4, 0),
33     AVOPTION_CODEC_FLAG("bug_no_padding", "workaround padding bug", workaround_bugs, FF_BUG_NO_PADDING, 0),
34     AVOPTION_CODEC_FLAG("bug_ac_vlc", "workaround ac VLC bug", workaround_bugs, FF_BUG_AC_VLC, 0),
35     AVOPTION_CODEC_FLAG("bug_qpel_chroma", "workaround qpel chroma bug", workaround_bugs, FF_BUG_QPEL_CHROMA, 0),
36     AVOPTION_CODEC_FLAG("bug_std_qpel", "workaround std qpel bug", workaround_bugs, FF_BUG_STD_QPEL, 0),
37     AVOPTION_CODEC_FLAG("bug_qpel_chroma2", "workaround qpel chroma2 bug", workaround_bugs, FF_BUG_QPEL_CHROMA2, 0),
38     AVOPTION_CODEC_FLAG("bug_direct_blocksize", "workaround direct blocksize bug", workaround_bugs, FF_BUG_DIRECT_BLOCKSIZE, 0),
39     AVOPTION_END()
40 };
41
42
43 static int parse_bool(const AVOption *c, char *s, int *var)
44 {
45     int b = 1; /* by default -on- when present */
46     if (s) {
47         if (!strcasecmp(s, "off") || !strcasecmp(s, "false")
48             || !strcmp(s, "0"))
49             b = 0;
50         else if (!strcasecmp(s, "on") || !strcasecmp(s, "true")
51                  || !strcmp(s, "1"))
52             b = 1;
53         else
54             return -1;
55     }
56
57     if (c->type == FF_OPT_TYPE_FLAG) {
58         if (b)
59             *var |= (int)c->min;
60         else
61             *var &= ~(int)c->min;
62     } else
63         *var = b;
64     return 0;
65 }
66
67 static int parse_double(const AVOption *c, char *s, double *var)
68 {
69     double d;
70     if (!s)
71         return -1;
72     d = atof(s);
73     if (c->min != c->max) {
74         if (d < c->min || d > c->max) {
75             fprintf(stderr, "Option: %s double value: %f out of range <%f, %f>\n",
76                     c->name, d, c->min, c->max);
77             return -1;
78         }
79     }
80     *var = d;
81     return 0;
82 }
83
84 static int parse_int(const AVOption* c, char* s, int* var)
85 {
86     int i;
87     if (!s)
88         return -1;
89     i = atoi(s);
90     if (c->min != c->max) {
91         if (i < (int)c->min || i > (int)c->max) {
92             fprintf(stderr, "Option: %s integer value: %d out of range <%d, %d>\n",
93                     c->name, i, (int)c->min, (int)c->max);
94             return -1;
95         }
96     }
97     *var = i;
98     return 0;
99 }
100
101 static int parse_string(const AVOption *c, char *s, void* strct, char **var)
102 {
103     if (!s)
104         return -1;
105
106     if (c->type == FF_OPT_TYPE_RCOVERRIDE) {
107         int sf, ef, qs;
108         float qf;
109         if (sscanf(s, "%d,%d,%d,%f", &sf, &ef, &qs, &qf) == 4 && sf < ef) {
110             AVCodecContext *avctx = (AVCodecContext *) strct;
111             RcOverride *o;
112             avctx->rc_override = av_realloc(avctx->rc_override,
113                                             sizeof(RcOverride) * (avctx->rc_override_count + 1));
114             o = avctx->rc_override + avctx->rc_override_count++;
115             o->start_frame = sf;
116             o->end_frame = ef;
117             o->qscale = qs;
118             o->quality_factor = qf;
119
120             //printf("parsed Rc:  %d,%d,%d,%f  (%d)\n", sf,ef,qs,qf, avctx->rc_override_count);
121         } else {
122             printf("incorrect/unparsable Rc: \"%s\"\n", s);
123         }
124     } else
125         *var = av_strdup(s);
126     return 0;
127 }
128
129 int avoption_parse(void* strct, const AVOption* list, const char *opts)
130 {
131     int r = 0;
132     char* dopts = av_strdup(opts);
133     if (dopts) {
134         char *str = dopts;
135
136         while (str && *str && r == 0) {
137             const AVOption *stack[FF_OPT_MAX_DEPTH];
138             const AVOption *c = list;
139             int depth = 0;
140             char* e = strchr(str, ':');
141             char* p;
142             if (e)
143                 *e++ = 0;
144
145             p = strchr(str, '=');
146             if (p)
147                 *p++ = 0;
148
149             // going through option structures
150             for (;;) {
151                 if (!c->name) {
152                     if (c->help) {
153                         stack[depth++] = c;
154                         c = (const AVOption*) c->help;
155                         assert(depth > FF_OPT_MAX_DEPTH);
156                     } else {
157                         if (depth == 0)
158                             break; // finished
159                         c = stack[--depth];
160                         c++;
161                     }
162                 } else {
163                     if (!strcmp(c->name, str)) {
164                         void* ptr = (char*)strct + c->offset;
165
166                         switch (c->type & FF_OPT_TYPE_MASK) {
167                         case FF_OPT_TYPE_BOOL:
168                             r = parse_bool(c, p, (int*)ptr);
169                             break;
170                         case FF_OPT_TYPE_DOUBLE:
171                             r = parse_double(c, p, (double*)ptr);
172                             break;
173                         case FF_OPT_TYPE_INT:
174                             r = parse_int(c, p, (int*)ptr);
175                             break;
176                         case FF_OPT_TYPE_STRING:
177                             r = parse_string(c, p, strct, (char**)ptr);
178                             break;
179                         default:
180                             assert(0 == 1);
181                         }
182                     }
183                     c++;
184                 }
185             }
186             str = e;
187         }
188         av_free(dopts);
189     }
190     return r;
191 }