Mercurial > libavcodec.hg

comparison opt.c @ 12522:776789af0304 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Move AVOptions from libavcodec to libavutil
author michael
date Sun, 26 Sep 2010 14:25:22 +0000
parents 7220936dc29c
children
comparison
equal deleted inserted replaced
12521:db36486a6f89 12522:776789af0304
1 /* 1 /*
2 * AVOptions 2 * AVOptions ABI compatibility wrapper
3 * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at> 3 * Copyright (c) 2010 Michael Niedermayer <michaelni@gmx.at>
4 * 4 *
5 * This file is part of FFmpeg. 5 * This file is part of FFmpeg.
6 * 6 *
7 * FFmpeg is free software; you can redistribute it and/or 7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public 8 * modify it under the terms of the GNU Lesser General Public
17 * You should have received a copy of the GNU Lesser General Public 17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software 18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */ 20 */
21 21
22 /**
23 * @file
24 * AVOptions
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #include "avcodec.h" 22 #include "avcodec.h"
29 #include "opt.h" 23 #include "opt.h"
30 #include "libavutil/eval.h"
31 24
32 //FIXME order them and do a bin search 25 #if LIBAVCODEC_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
33 const AVOption *av_find_opt(void *v, const char *name, const char *unit, int mask, int flags){
34 AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
35 const AVOption *o= c->option;
36 26
37 for(;o && o->name; o++){ 27 FF_SYMVER(const AVOption *, av_find_opt, (void *obj, const char *name, const char *unit, int mask, int flags), "LIBAVCODEC_52"){
38 if(!strcmp(o->name, name) && (!unit || (o->unit && !strcmp(o->unit, unit))) && (o->flags & mask) == flags ) 28 return av_find_opt(obj, name, unit, mask, flags);
39 return o;
40 }
41 return NULL;
42 } 29 }
43 30 FF_SYMVER(int, av_set_string3, (void *obj, const char *name, const char *val, int alloc, const AVOption **o_out), "LIBAVCODEC_52"){
44 const AVOption *av_next_option(void *obj, const AVOption *last){ 31 return av_set_string3(obj, name, val, alloc, o_out);
45 if(last && last[1].name) return ++last;
46 else if(last) return NULL;
47 else return (*(AVClass**)obj)->option;
48 } 32 }
49 33 FF_SYMVER(const AVOption *, av_set_double, (void *obj, const char *name, double n), "LIBAVCODEC_52"){
50 static int av_set_number2(void *obj, const char *name, double num, int den, int64_t intnum, const AVOption **o_out){ 34 return av_set_double(obj, name, n);
51 const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
52 void *dst;
53 if(o_out)
54 *o_out= o;
55 if(!o || o->offset<=0)
56 return AVERROR(ENOENT);
57
58 if(o->max*den < num*intnum || o->min*den > num*intnum) {
59 av_log(obj, AV_LOG_ERROR, "Value %lf for parameter '%s' out of range\n", num, name);
60 return AVERROR(ERANGE);
61 }
62
63 dst= ((uint8_t*)obj) + o->offset;
64
65 switch(o->type){
66 case FF_OPT_TYPE_FLAGS:
67 case FF_OPT_TYPE_INT: *(int *)dst= llrint(num/den)*intnum; break;
68 case FF_OPT_TYPE_INT64: *(int64_t *)dst= llrint(num/den)*intnum; break;
69 case FF_OPT_TYPE_FLOAT: *(float *)dst= num*intnum/den; break;
70 case FF_OPT_TYPE_DOUBLE:*(double *)dst= num*intnum/den; break;
71 case FF_OPT_TYPE_RATIONAL:
72 if((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
73 else *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
74 break;
75 default:
76 return AVERROR(EINVAL);
77 }
78 return 0;
79 } 35 }
80 36 FF_SYMVER(const AVOption *, av_set_q, (void *obj, const char *name, AVRational n), "LIBAVCODEC_52"){
81 static const AVOption *av_set_number(void *obj, const char *name, double num, int den, int64_t intnum){ 37 return av_set_q(obj, name, n);
82 const AVOption *o = NULL;
83 if (av_set_number2(obj, name, num, den, intnum, &o) < 0)
84 return NULL;
85 else
86 return o;
87 } 38 }
88 39 FF_SYMVER(const AVOption *, av_set_int, (void *obj, const char *name, int64_t n), "LIBAVCODEC_52"){
89 static const double const_values[]={ 40 return av_set_int(obj, name, n);
90 M_PI,
91 M_E,
92 FF_QP2LAMBDA,
93 0
94 };
95
96 static const char * const const_names[]={
97 "PI",
98 "E",
99 "QP2LAMBDA",
100 0
101 };
102
103 static int hexchar2int(char c) {
104 if (c >= '0' && c <= '9') return c - '0';
105 if (c >= 'a' && c <= 'f') return c - 'a' + 10;
106 if (c >= 'A' && c <= 'F') return c - 'A' + 10;
107 return -1;
108 } 41 }
109 42 FF_SYMVER(double, av_get_double, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
110 int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out){ 43 return av_get_double(obj, name, o_out);
111 int ret;
112 const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
113 if (o_out)
114 *o_out = o;
115 if(!o)
116 return AVERROR(ENOENT);
117 if(!val || o->offset<=0)
118 return AVERROR(EINVAL);
119
120 if(o->type == FF_OPT_TYPE_BINARY){
121 uint8_t **dst = (uint8_t **)(((uint8_t*)obj) + o->offset);
122 int *lendst = (int *)(dst + 1);
123 uint8_t *bin, *ptr;
124 int len = strlen(val);
125 av_freep(dst);
126 *lendst = 0;
127 if (len & 1) return AVERROR(EINVAL);
128 len /= 2;
129 ptr = bin = av_malloc(len);
130 while (*val) {
131 int a = hexchar2int(*val++);
132 int b = hexchar2int(*val++);
133 if (a < 0 || b < 0) {
134 av_free(bin);
135 return AVERROR(EINVAL);
136 }
137 *ptr++ = (a << 4) | b;
138 }
139 *dst = bin;
140 *lendst = len;
141 return 0;
142 }
143 if(o->type != FF_OPT_TYPE_STRING){
144 int notfirst=0;
145 for(;;){
146 int i;
147 char buf[256];
148 int cmd=0;
149 double d;
150
151 if(*val == '+' || *val == '-')
152 cmd= *(val++);
153
154 for(i=0; i<sizeof(buf)-1 && val[i] && val[i]!='+' && val[i]!='-'; i++)
155 buf[i]= val[i];
156 buf[i]=0;
157
158 {
159 const AVOption *o_named= av_find_opt(obj, buf, o->unit, 0, 0);
160 if(o_named && o_named->type == FF_OPT_TYPE_CONST)
161 d= o_named->default_val;
162 else if(!strcmp(buf, "default")) d= o->default_val;
163 else if(!strcmp(buf, "max" )) d= o->max;
164 else if(!strcmp(buf, "min" )) d= o->min;
165 else if(!strcmp(buf, "none" )) d= 0;
166 else if(!strcmp(buf, "all" )) d= ~0;
167 else {
168 int res = av_parse_and_eval_expr(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
169 if (res < 0) {
170 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
171 return res;
172 }
173 }
174 }
175 if(o->type == FF_OPT_TYPE_FLAGS){
176 if (cmd=='+') d= av_get_int(obj, name, NULL) | (int64_t)d;
177 else if(cmd=='-') d= av_get_int(obj, name, NULL) &~(int64_t)d;
178 }else{
179 if (cmd=='+') d= notfirst*av_get_double(obj, name, NULL) + d;
180 else if(cmd=='-') d= notfirst*av_get_double(obj, name, NULL) - d;
181 }
182
183 if ((ret = av_set_number2(obj, name, d, 1, 1, o_out)) < 0)
184 return ret;
185 val+= i;
186 if(!*val)
187 return 0;
188 notfirst=1;
189 }
190 return AVERROR(EINVAL);
191 }
192
193 if(alloc){
194 av_free(*(void**)(((uint8_t*)obj) + o->offset));
195 val= av_strdup(val);
196 }
197
198 memcpy(((uint8_t*)obj) + o->offset, &val, sizeof(val));
199 return 0;
200 } 44 }
45 FF_SYMVER(AVRational, av_get_q, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
46 return av_get_q(obj, name, o_out);
47 }
48 FF_SYMVER(int64_t, av_get_int, (void *obj, const char *name, const AVOption **o_out), "LIBAVCODEC_52"){
49 return av_get_int(obj, name, o_out);
50 }
51 FF_SYMVER(const char *, av_get_string, (void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len), "LIBAVCODEC_52"){
52 return av_get_string(obj, name, o_out, buf, buf_len);
53 }
54 FF_SYMVER(const AVOption *, av_next_option, (void *obj, const AVOption *last), "LIBAVCODEC_52"){
55 return av_next_option(obj, last);
56 }
57 FF_SYMVER(int, av_opt_show2, (void *obj, void *av_log_obj, int req_flags, int rej_flags), "LIBAVCODEC_52"){
58 return av_opt_show2(obj, av_log_obj, req_flags, rej_flags);
59 }
60 FF_SYMVER(void, av_opt_set_defaults, (void *s), "LIBAVCODEC_52"){
61 return av_opt_set_defaults(s);
62 }
63 FF_SYMVER(void, av_opt_set_defaults2, (void *s, int mask, int flags), "LIBAVCODEC_52"){
64 return av_opt_set_defaults2(s, mask, flags);
65 }
66 #endif
201 67
202 #if LIBAVCODEC_VERSION_MAJOR < 53 68 #if LIBAVCODEC_VERSION_MAJOR < 53
203 const AVOption *av_set_string2(void *obj, const char *name, const char *val, int alloc){ 69 const AVOption *av_set_string2(void *obj, const char *name, const char *val, int alloc){
204 const AVOption *o; 70 const AVOption *o;
205 if (av_set_string3(obj, name, val, alloc, &o) < 0) 71 if (av_set_string3(obj, name, val, alloc, &o) < 0)
213 return NULL; 79 return NULL;
214 return o; 80 return o;
215 } 81 }
216 #endif 82 #endif
217 83
218 const AVOption *av_set_double(void *obj, const char *name, double n){
219 return av_set_number(obj, name, n, 1, 1);
220 }
221
222 const AVOption *av_set_q(void *obj, const char *name, AVRational n){
223 return av_set_number(obj, name, n.num, n.den, 1);
224 }
225
226 const AVOption *av_set_int(void *obj, const char *name, int64_t n){
227 return av_set_number(obj, name, 1, 1, n);
228 }
229
230 /**
231 *
232 * @param buf a buffer which is used for returning non string values as strings, can be NULL
233 * @param buf_len allocated length in bytes of buf
234 */
235 const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len){
236 const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
237 void *dst;
238 uint8_t *bin;
239 int len, i;
240 if(!o || o->offset<=0)
241 return NULL;
242 if(o->type != FF_OPT_TYPE_STRING && (!buf || !buf_len))
243 return NULL;
244
245 dst= ((uint8_t*)obj) + o->offset;
246 if(o_out) *o_out= o;
247
248 switch(o->type){
249 case FF_OPT_TYPE_FLAGS: snprintf(buf, buf_len, "0x%08X",*(int *)dst);break;
250 case FF_OPT_TYPE_INT: snprintf(buf, buf_len, "%d" , *(int *)dst);break;
251 case FF_OPT_TYPE_INT64: snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
252 case FF_OPT_TYPE_FLOAT: snprintf(buf, buf_len, "%f" , *(float *)dst);break;
253 case FF_OPT_TYPE_DOUBLE: snprintf(buf, buf_len, "%f" , *(double *)dst);break;
254 case FF_OPT_TYPE_RATIONAL: snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
255 case FF_OPT_TYPE_STRING: return *(void**)dst;
256 case FF_OPT_TYPE_BINARY:
257 len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
258 if(len >= (buf_len + 1)/2) return NULL;
259 bin = *(uint8_t**)dst;
260 for(i = 0; i < len; i++) snprintf(buf + i*2, 3, "%02X", bin[i]);
261 break;
262 default: return NULL;
263 }
264 return buf;
265 }
266
267 static int av_get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum){
268 const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
269 void *dst;
270 if(!o || o->offset<=0)
271 goto error;
272
273 dst= ((uint8_t*)obj) + o->offset;
274
275 if(o_out) *o_out= o;
276
277 switch(o->type){
278 case FF_OPT_TYPE_FLAGS: *intnum= *(unsigned int*)dst;return 0;
279 case FF_OPT_TYPE_INT: *intnum= *(int *)dst;return 0;
280 case FF_OPT_TYPE_INT64: *intnum= *(int64_t*)dst;return 0;
281 case FF_OPT_TYPE_FLOAT: *num= *(float *)dst;return 0;
282 case FF_OPT_TYPE_DOUBLE: *num= *(double *)dst;return 0;
283 case FF_OPT_TYPE_RATIONAL: *intnum= ((AVRational*)dst)->num;
284 *den = ((AVRational*)dst)->den;
285 return 0;
286 }
287 error:
288 *den=*intnum=0;
289 return -1;
290 }
291
292 double av_get_double(void *obj, const char *name, const AVOption **o_out){
293 int64_t intnum=1;
294 double num=1;
295 int den=1;
296
297 av_get_number(obj, name, o_out, &num, &den, &intnum);
298 return num*intnum/den;
299 }
300
301 AVRational av_get_q(void *obj, const char *name, const 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 if(num == 1.0 && (int)intnum == intnum)
308 return (AVRational){intnum, den};
309 else
310 return av_d2q(num*intnum/den, 1<<24);
311 }
312
313 int64_t av_get_int(void *obj, const char *name, const AVOption **o_out){
314 int64_t intnum=1;
315 double num=1;
316 int den=1;
317
318 av_get_number(obj, name, o_out, &num, &den, &intnum);
319 return num*intnum/den;
320 }
321
322 static void opt_list(void *obj, void *av_log_obj, const char *unit,
323 int req_flags, int rej_flags)
324 {
325 const AVOption *opt=NULL;
326
327 while((opt= av_next_option(obj, opt))){
328 if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
329 continue;
330
331 /* Don't print CONST's on level one.
332 * Don't print anything but CONST's on level two.
333 * Only print items from the requested unit.
334 */
335 if (!unit && opt->type==FF_OPT_TYPE_CONST)
336 continue;
337 else if (unit && opt->type!=FF_OPT_TYPE_CONST)
338 continue;
339 else if (unit && opt->type==FF_OPT_TYPE_CONST && strcmp(unit, opt->unit))
340 continue;
341 else if (unit && opt->type == FF_OPT_TYPE_CONST)
342 av_log(av_log_obj, AV_LOG_INFO, " %-15s ", opt->name);
343 else
344 av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
345
346 switch( opt->type )
347 {
348 case FF_OPT_TYPE_FLAGS:
349 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>" );
350 break;
351 case FF_OPT_TYPE_INT:
352 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int>" );
353 break;
354 case FF_OPT_TYPE_INT64:
355 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>" );
356 break;
357 case FF_OPT_TYPE_DOUBLE:
358 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<double>" );
359 break;
360 case FF_OPT_TYPE_FLOAT:
361 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<float>" );
362 break;
363 case FF_OPT_TYPE_STRING:
364 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<string>" );
365 break;
366 case FF_OPT_TYPE_RATIONAL:
367 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>" );
368 break;
369 case FF_OPT_TYPE_BINARY:
370 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>" );
371 break;
372 case FF_OPT_TYPE_CONST:
373 default:
374 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "" );
375 break;
376 }
377 av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
378 av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
379 av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM ) ? 'V' : '.');
380 av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM ) ? 'A' : '.');
381 av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
382
383 if(opt->help)
384 av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
385 av_log(av_log_obj, AV_LOG_INFO, "\n");
386 if (opt->unit && opt->type != FF_OPT_TYPE_CONST) {
387 opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
388 }
389 }
390 }
391
392 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
393 {
394 if(!obj)
395 return -1;
396
397 av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
398
399 opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
400
401 return 0;
402 }
403
404 #if FF_API_OPT_SHOW 84 #if FF_API_OPT_SHOW
405 int av_opt_show(void *obj, void *av_log_obj){ 85 int av_opt_show(void *obj, void *av_log_obj){
406 return av_opt_show2(obj, av_log_obj, 86 return av_opt_show2(obj, av_log_obj,
407 AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0); 87 AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
408 } 88 }
409 #endif 89 #endif
410
411 /** Set the values of the AVCodecContext or AVFormatContext structure.
412 * They are set to the defaults specified in the according AVOption options
413 * array default_val field.
414 *
415 * @param s AVCodecContext or AVFormatContext for which the defaults will be set
416 */
417 void av_opt_set_defaults2(void *s, int mask, int flags)
418 {
419 const AVOption *opt = NULL;
420 while ((opt = av_next_option(s, opt)) != NULL) {
421 if((opt->flags & mask) != flags)
422 continue;
423 switch(opt->type) {
424 case FF_OPT_TYPE_CONST:
425 /* Nothing to be done here */
426 break;
427 case FF_OPT_TYPE_FLAGS:
428 case FF_OPT_TYPE_INT: {
429 int val;
430 val = opt->default_val;
431 av_set_int(s, opt->name, val);
432 }
433 break;
434 case FF_OPT_TYPE_INT64:
435 if((double)(opt->default_val+0.6) == opt->default_val)
436 av_log(s, AV_LOG_DEBUG, "loss of precision in default of %s\n", opt->name);
437 av_set_int(s, opt->name, opt->default_val);
438 break;
439 case FF_OPT_TYPE_FLOAT: {
440 double val;
441 val = opt->default_val;
442 av_set_double(s, opt->name, val);
443 }
444 break;
445 case FF_OPT_TYPE_RATIONAL: {
446 AVRational val;
447 val = av_d2q(opt->default_val, INT_MAX);
448 av_set_q(s, opt->name, val);
449 }
450 break;
451 case FF_OPT_TYPE_STRING:
452 case FF_OPT_TYPE_BINARY:
453 /* Cannot set default for string as default_val is of type * double */
454 break;
455 default:
456 av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
457 }
458 }
459 }
460
461 void av_opt_set_defaults(void *s){
462 av_opt_set_defaults2(s, 0, 0);
463 }
464