Inform the user that a certain AVOption is out of range.
[ffmpeg.git] / libavcodec / opt.c
1 /*
2  * AVOptions
3  * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  *
19  */
20
21 /**
22  * @file opt.c
23  * AVOptions
24  * @author Michael Niedermayer <michaelni@gmx.at>
25  */
26
27 #include "avcodec.h"
28 #include "opt.h"
29
30 static int8_t si_prefixes['z' - 'E' + 1]={
31     ['y'-'E']= -24,
32     ['z'-'E']= -21,
33     ['a'-'E']= -18,
34     ['f'-'E']= -15,
35     ['p'-'E']= -12,
36     ['n'-'E']= - 9,
37     ['u'-'E']= - 6,
38     ['m'-'E']= - 3,
39     ['c'-'E']= - 2,
40     ['d'-'E']= - 1,
41     ['h'-'E']=   2,
42     ['k'-'E']=   3,
43     ['K'-'E']=   3,
44     ['M'-'E']=   6,
45     ['G'-'E']=   9,
46     ['T'-'E']=  12,
47     ['P'-'E']=  15,
48     ['E'-'E']=  18,
49     ['Z'-'E']=  21,
50     ['Y'-'E']=  24,
51 };
52
53 /** strtod() function extended with 'k', 'M', 'G', 'ki', 'Mi', 'Gi' and 'B'
54  * postfixes.  This allows using f.e. kB, MiB, G and B as a postfix. This
55  * function assumes that the unit of numbers is bits not bytes.
56  */
57 double av_strtod(const char *name, char **tail) {
58     double d;
59     int p = 0;
60     char *next;
61     d = strtod(name, &next);
62     /* if parsing succeeded, check for and interpret postfixes */
63     if (next!=name) {
64
65         if(*next >= 'E' && *next <= 'z'){
66             int e= si_prefixes[*next - 'E'];
67             if(e){
68                 if(next[1] == 'i'){
69                     d*= pow( 2, e/0.3);
70                     next+=2;
71                 }else{
72                     d*= pow(10, e);
73                     next++;
74                 }
75             }
76         }
77
78         if(*next=='B') {
79             d*=8;
80             *next++;
81         }
82     }
83     /* if requested, fill in tail with the position after the last parsed
84        character */
85     if (tail)
86         *tail = next;
87     return d;
88 }
89
90 static double av_parse_num(const char *name, char **tail){
91     double d;
92     d= av_strtod(name, tail);
93     if(*tail>name && (**tail=='/' || **tail==':'))
94         d/=av_strtod((*tail)+1, tail);
95     return d;
96 }
97
98 //FIXME order them and do a bin search
99 static AVOption *find_opt(void *v, const char *name, const char *unit){
100     AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
101     AVOption *o= c->option;
102
103     for(;o && o->name; o++){
104         if(!strcmp(o->name, name) && (!unit || !strcmp(o->unit, unit)) )
105             return o;
106     }
107     return NULL;
108 }
109
110 AVOption *av_next_option(void *obj, AVOption *last){
111     if(last && last[1].name) return ++last;
112     else if(last)            return NULL;
113     else                     return (*(AVClass**)obj)->option;
114 }
115
116 static AVOption *av_set_number(void *obj, const char *name, double num, int den, int64_t intnum){
117     AVOption *o= find_opt(obj, name, NULL);
118     void *dst;
119     if(!o || o->offset<=0)
120         return NULL;
121
122     if(o->max*den < num*intnum || o->min*den > num*intnum) {
123         av_log(NULL, AV_LOG_ERROR, "Value %lf for parameter '%s' out of range.\n", num, name);
124         return NULL;
125     }
126
127     dst= ((uint8_t*)obj) + o->offset;
128
129     switch(o->type){
130     case FF_OPT_TYPE_FLAGS:
131     case FF_OPT_TYPE_INT:   *(int       *)dst= lrintf(num/den)*intnum; break;
132     case FF_OPT_TYPE_INT64: *(int64_t   *)dst= lrintf(num/den)*intnum; break;
133     case FF_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
134     case FF_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
135     case FF_OPT_TYPE_RATIONAL:
136         if((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
137         else                *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
138     default:
139         return NULL;
140     }
141     return o;
142 }
143
144 static AVOption *set_all_opt(void *v, const char *unit, double d){
145     AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
146     AVOption *o= c->option;
147     AVOption *ret=NULL;
148
149     for(;o && o->name; o++){
150         if(o->type != FF_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)){
151             double tmp= d;
152             if(o->type == FF_OPT_TYPE_FLAGS)
153                 tmp= av_get_int(v, o->name, NULL) | (int64_t)d;
154
155             av_set_number(v, o->name, tmp, 1, 1);
156             ret= o;
157         }
158     }
159     return ret;
160 }
161
162 //FIXME use eval.c maybe?
163 AVOption *av_set_string(void *obj, const char *name, const char *val){
164     AVOption *o= find_opt(obj, name, NULL);
165     if(o && o->offset==0 && o->type == FF_OPT_TYPE_CONST && o->unit){
166         return set_all_opt(obj, o->unit, o->default_val);
167     }
168     if(!o || !val || o->offset<=0)
169         return NULL;
170     if(o->type != FF_OPT_TYPE_STRING){
171         for(;;){
172             int i;
173             char buf[256], *tail;
174             int cmd=0;
175             double d;
176
177             if(*val == '+' || *val == '-')
178                 cmd= *(val++);
179
180             for(i=0; i<sizeof(buf)-1 && val[i] && val[i]!='+' && val[i]!='-'; i++)
181                 buf[i]= val[i];
182             buf[i]=0;
183             val+= i;
184
185             d= av_parse_num(buf, &tail);
186             if(tail <= buf){
187                 AVOption *o_named= find_opt(obj, buf, o->unit);
188                 if(o_named && o_named->type == FF_OPT_TYPE_CONST)
189                     d= o_named->default_val;
190                 else if(!strcmp(buf, "default")) d= o->default_val;
191                 else if(!strcmp(buf, "max"    )) d= o->max;
192                 else if(!strcmp(buf, "min"    )) d= o->min;
193                 else return NULL;
194             }
195             if(o->type == FF_OPT_TYPE_FLAGS){
196                 if     (cmd=='+') d= av_get_int(obj, name, NULL) | (int64_t)d;
197                 else if(cmd=='-') d= av_get_int(obj, name, NULL) &~(int64_t)d;
198             }else if(cmd=='-')
199                 d= -d;
200
201             av_set_number(obj, name, d, 1, 1);
202             if(!*val)
203                 return o;
204         }
205         return NULL;
206     }
207
208     memcpy(((uint8_t*)obj) + o->offset, val, sizeof(val));
209     return o;
210 }
211
212 AVOption *av_set_double(void *obj, const char *name, double n){
213     return av_set_number(obj, name, n, 1, 1);
214 }
215
216 AVOption *av_set_q(void *obj, const char *name, AVRational n){
217     return av_set_number(obj, name, n.num, n.den, 1);
218 }
219
220 AVOption *av_set_int(void *obj, const char *name, int64_t n){
221     return av_set_number(obj, name, 1, 1, n);
222 }
223
224 /**
225  *
226  * @param buf a buffer which is used for returning non string values as strings, can be NULL
227  * @param buf_len allocated length in bytes of buf
228  */
229 const char *av_get_string(void *obj, const char *name, AVOption **o_out, char *buf, int buf_len){
230     AVOption *o= find_opt(obj, name, NULL);
231     void *dst;
232     if(!o || o->offset<=0)
233         return NULL;
234     if(o->type != FF_OPT_TYPE_STRING && (!buf || !buf_len))
235         return NULL;
236
237     dst= ((uint8_t*)obj) + o->offset;
238     if(o_out) *o_out= o;
239
240     if(o->type == FF_OPT_TYPE_STRING)
241         return dst;
242
243     switch(o->type){
244     case FF_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
245     case FF_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
246     case FF_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
247     case FF_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
248     case FF_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
249     case FF_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
250     default: return NULL;
251     }
252     return buf;
253 }
254
255 static int av_get_number(void *obj, const char *name, AVOption **o_out, double *num, int *den, int64_t *intnum){
256     AVOption *o= find_opt(obj, name, NULL);
257     void *dst;
258     if(!o || o->offset<=0)
259         goto error;
260
261     dst= ((uint8_t*)obj) + o->offset;
262
263     if(o_out) *o_out= o;
264
265     switch(o->type){
266     case FF_OPT_TYPE_FLAGS:
267     case FF_OPT_TYPE_INT:       *intnum= *(int    *)dst;return 0;
268     case FF_OPT_TYPE_INT64:     *intnum= *(int64_t*)dst;return 0;
269     case FF_OPT_TYPE_FLOAT:     *num=    *(float  *)dst;return 0;
270     case FF_OPT_TYPE_DOUBLE:    *num=    *(double *)dst;return 0;
271     case FF_OPT_TYPE_RATIONAL:  *intnum= ((AVRational*)dst)->num;
272                                 *den   = ((AVRational*)dst)->den;
273                                                         return 0;
274     }
275 error:
276     *den=*intnum=0;
277     return -1;
278 }
279
280 double av_get_double(void *obj, const char *name, AVOption **o_out){
281     int64_t intnum=1;
282     double num=1;
283     int den=1;
284
285     av_get_number(obj, name, o_out, &num, &den, &intnum);
286     return num*intnum/den;
287 }
288
289 AVRational av_get_q(void *obj, const char *name, AVOption **o_out){
290     int64_t intnum=1;
291     double num=1;
292     int den=1;
293
294     av_get_number(obj, name, o_out, &num, &den, &intnum);
295     if(num == 1.0 && (int)intnum == intnum)
296         return (AVRational){intnum, den};
297     else
298         return av_d2q(num*intnum/den, 1<<24);
299 }
300
301 int64_t av_get_int(void *obj, const char *name, AVOption **o_out){
302     int64_t intnum=1;
303     double num=1;
304     int den=1;
305
306     av_get_number(obj, name, o_out, &num, &den, &intnum);
307     return num*intnum/den;
308 }
309
310 int av_opt_show(void *obj, void *av_log_obj){
311     AVOption *opt=NULL;
312
313     if(!obj)
314         return -1;
315
316     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
317
318     while((opt= av_next_option(obj, opt))){
319         if(!(opt->flags & (AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM)))
320             continue;
321
322         av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
323
324         switch( opt->type )
325         {
326             case FF_OPT_TYPE_FLAGS:
327                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>" );
328                 break;
329             case FF_OPT_TYPE_INT:
330                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int>" );
331                 break;
332             case FF_OPT_TYPE_INT64:
333                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>" );
334                 break;
335             case FF_OPT_TYPE_DOUBLE:
336                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<double>" );
337                 break;
338             case FF_OPT_TYPE_FLOAT:
339                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<float>" );
340                 break;
341             case FF_OPT_TYPE_STRING:
342                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<string>" );
343                 break;
344             case FF_OPT_TYPE_RATIONAL:
345                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>" );
346                 break;
347             case FF_OPT_TYPE_CONST:
348             default:
349                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "" );
350                 break;
351         }
352         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
353         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
354         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
355         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
356         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
357
358         if(opt->help)
359             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
360         av_log(av_log_obj, AV_LOG_INFO, "\n");
361     }
362     return 0;
363 }
364
365 /** Set the values of the AVCodecContext or AVFormatContext structure.
366  * They are set to the defaults specified in the according AVOption options
367  * array default_val field.
368  *
369  * @param s AVCodecContext or AVFormatContext for which the defaults will be set
370  */
371 void av_opt_set_defaults(void *s)
372 {
373     AVOption *opt = NULL;
374     while ((opt = av_next_option(s, opt)) != NULL) {
375         switch(opt->type) {
376             case FF_OPT_TYPE_CONST:
377                 /* Nothing to be done here */
378             break;
379             case FF_OPT_TYPE_FLAGS:
380             case FF_OPT_TYPE_INT: {
381                 int val;
382                 val = opt->default_val;
383                 av_set_int(s, opt->name, val);
384             }
385             break;
386             case FF_OPT_TYPE_FLOAT: {
387                 double val;
388                 val = opt->default_val;
389                 av_set_double(s, opt->name, val);
390             }
391             break;
392             case FF_OPT_TYPE_RATIONAL: {
393                 AVRational val;
394                 val = av_d2q(opt->default_val, INT_MAX);
395                 av_set_q(s, opt->name, val);
396             }
397             break;
398             case FF_OPT_TYPE_STRING:
399                 /* Cannot set default for string as default_val is of type * double */
400             break;
401             default:
402                 av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
403         }
404     }
405 }
406