extern/ffmpeg/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 double av_parse_num(const char *name, char **tail){
  31     double d;
  32     d= strtod(name, tail);
  33     if(*tail>name && (**tail=='/' || **tail==':'))
  34         d/=strtod((*tail)+1, tail);
  35     return d;
  36 }
  37
  38 //FIXME order them and do a bin search
  39 static AVOption *find_opt(void *v, const char *name, const char *unit){
  40     AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
  41     AVOption *o= c->option;
  42
  43     for(;o && o->name; o++){
  44         if(!strcmp(o->name, name) && (!unit || !strcmp(o->unit, unit)) )
  45             return o;
  46     }
  47     return NULL;
  48 }
  49
  50 AVOption *av_next_option(void *obj, AVOption *last){
  51     if(last && last[1].name) return ++last;
  52     else if(last)            return NULL;
  53     else                     return (*(AVClass**)obj)->option;
  54 }
  55
  56 static AVOption *av_set_number(void *obj, const char *name, double num, int den, int64_t intnum){
  57     AVOption *o= find_opt(obj, name, NULL);
  58     void *dst;
  59     if(!o || o->offset<=0)
  60         return NULL;
  61
  62     if(o->max*den < num*intnum || o->min*den > num*intnum)
  63         return NULL;
  64
  65     dst= ((uint8_t*)obj) + o->offset;
  66
  67     switch(o->type){
  68     case FF_OPT_TYPE_FLAGS:
  69     case FF_OPT_TYPE_INT:   *(int       *)dst= lrintf(num/den)*intnum; break;
  70     case FF_OPT_TYPE_INT64: *(int64_t   *)dst= lrintf(num/den)*intnum; break;
  71     case FF_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
  72     case FF_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
  73     case FF_OPT_TYPE_RATIONAL:
  74         if((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
  75         else                *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
  76     default:
  77         return NULL;
  78     }
  79     return o;
  80 }
  81
  82 static AVOption *set_all_opt(void *v, const char *unit, double d){
  83     AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
  84     AVOption *o= c->option;
  85     AVOption *ret=NULL;
  86
  87     for(;o && o->name; o++){
  88         if(o->type != FF_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)){
  89             double tmp= d;
  90             if(o->type == FF_OPT_TYPE_FLAGS)
  91                 tmp= av_get_int(v, o->name, NULL) | (int64_t)d;
  92
  93             av_set_number(v, o->name, tmp, 1, 1);
  94             ret= o;
  95         }
  96     }
  97     return ret;
  98 }
  99
 100 //FIXME use eval.c maybe?
 101 AVOption *av_set_string(void *obj, const char *name, const char *val){
 102     AVOption *o= find_opt(obj, name, NULL);
 103     if(o && o->offset==0 && o->type == FF_OPT_TYPE_CONST && o->unit){
 104         return set_all_opt(obj, o->unit, o->default_val);
 105     }
 106     if(!o || !val || o->offset<=0)
 107         return NULL;
 108     if(o->type != FF_OPT_TYPE_STRING){
 109         for(;;){
 110             int i;
 111             char buf[256], *tail;
 112             int cmd=0;
 113             double d;
 114
 115             if(*val == '+' || *val == '-')
 116                 cmd= *(val++);
 117
 118             for(i=0; i<sizeof(buf)-1 && val[i] && val[i]!='+' && val[i]!='-'; i++)
 119                 buf[i]= val[i];
 120             buf[i]=0;
 121             val+= i;
 122
 123             d= av_parse_num(buf, &tail);
 124             if(tail <= buf){
 125                 AVOption *o_named= find_opt(obj, buf, o->unit);
 126                 if(o_named && o_named->type == FF_OPT_TYPE_CONST)
 127                     d= o_named->default_val;
 128                 else if(!strcmp(buf, "default")) d= o->default_val;
 129                 else if(!strcmp(buf, "max"    )) d= o->max;
 130                 else if(!strcmp(buf, "min"    )) d= o->min;
 131                 else return NULL;
 132             }
 133             if(o->type == FF_OPT_TYPE_FLAGS){
 134                 if     (cmd=='+') d= av_get_int(obj, name, NULL) | (int64_t)d;
 135                 else if(cmd=='-') d= av_get_int(obj, name, NULL) &~(int64_t)d;
 136             }else if(cmd=='-')
 137                 d= -d;
 138
 139             av_set_number(obj, name, d, 1, 1);
 140             if(!*val)
 141                 return o;
 142         }
 143         return NULL;
 144     }
 145
 146     memcpy(((uint8_t*)obj) + o->offset, val, sizeof(val));
 147     return o;
 148 }
 149
 150 AVOption *av_set_double(void *obj, const char *name, double n){
 151     return av_set_number(obj, name, n, 1, 1);
 152 }
 153
 154 AVOption *av_set_q(void *obj, const char *name, AVRational n){
 155     return av_set_number(obj, name, n.num, n.den, 1);
 156 }
 157
 158 AVOption *av_set_int(void *obj, const char *name, int64_t n){
 159     return av_set_number(obj, name, 1, 1, n);
 160 }
 161
 162 /**
 163  *
 164  * @param buf a buffer which is used for returning non string values as strings, can be NULL
 165  * @param buf_len allocated length in bytes of buf
 166  */
 167 const char *av_get_string(void *obj, const char *name, AVOption **o_out, char *buf, int buf_len){
 168     AVOption *o= find_opt(obj, name, NULL);
 169     void *dst;
 170     if(!o || o->offset<=0)
 171         return NULL;
 172     if(o->type != FF_OPT_TYPE_STRING && (!buf || !buf_len))
 173         return NULL;
 174
 175     dst= ((uint8_t*)obj) + o->offset;
 176     if(o_out) *o_out= o;
 177
 178     if(o->type == FF_OPT_TYPE_STRING)
 179         return dst;
 180
 181     switch(o->type){
 182     case FF_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
 183     case FF_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
 184     case FF_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
 185     case FF_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
 186     case FF_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
 187     case FF_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
 188     default: return NULL;
 189     }
 190     return buf;
 191 }
 192
 193 static int av_get_number(void *obj, const char *name, AVOption **o_out, double *num, int *den, int64_t *intnum){
 194     AVOption *o= find_opt(obj, name, NULL);
 195     void *dst;
 196     if(!o || o->offset<=0)
 197         goto error;
 198
 199     dst= ((uint8_t*)obj) + o->offset;
 200
 201     if(o_out) *o_out= o;
 202
 203     switch(o->type){
 204     case FF_OPT_TYPE_FLAGS:
 205     case FF_OPT_TYPE_INT:       *intnum= *(int    *)dst;return 0;
 206     case FF_OPT_TYPE_INT64:     *intnum= *(int64_t*)dst;return 0;
 207     case FF_OPT_TYPE_FLOAT:     *num=    *(float  *)dst;return 0;
 208     case FF_OPT_TYPE_DOUBLE:    *num=    *(double *)dst;return 0;
 209     case FF_OPT_TYPE_RATIONAL:  *intnum= ((AVRational*)dst)->num;
 210                                 *den   = ((AVRational*)dst)->den;
 211                                                         return 0;
 212     }
 213 error:
 214     *den=*intnum=0;
 215     return -1;
 216 }
 217
 218 double av_get_double(void *obj, const char *name, AVOption **o_out){
 219     int64_t intnum=1;
 220     double num=1;
 221     int den=1;
 222
 223     av_get_number(obj, name, o_out, &num, &den, &intnum);
 224     return num*intnum/den;
 225 }
 226
 227 AVRational av_get_q(void *obj, const char *name, AVOption **o_out){
 228     int64_t intnum=1;
 229     double num=1;
 230     int den=1;
 231
 232     av_get_number(obj, name, o_out, &num, &den, &intnum);
 233     if(num == 1.0 && (int)intnum == intnum)
 234         return (AVRational){intnum, den};
 235     else
 236         return av_d2q(num*intnum/den, 1<<24);
 237 }
 238
 239 int64_t av_get_int(void *obj, const char *name, AVOption **o_out){
 240     int64_t intnum=1;
 241     double num=1;
 242     int den=1;
 243
 244     av_get_number(obj, name, o_out, &num, &den, &intnum);
 245     return num*intnum/den;
 246 }
 247
 248 int av_opt_show(void *obj, void *av_log_obj){
 249     AVOption *opt=NULL;
 250
 251     if(!obj)
 252         return -1;
 253
 254     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
 255
 256     while((opt= av_next_option(obj, opt))){
 257         if(!(opt->flags & (AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM)))
 258             continue;
 259
 260         av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
 261
 262         switch( opt->type )
 263         {
 264             case FF_OPT_TYPE_FLAGS:
 265                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>" );
 266                 break;
 267             case FF_OPT_TYPE_INT:
 268                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int>" );
 269                 break;
 270             case FF_OPT_TYPE_INT64:
 271                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>" );
 272                 break;
 273             case FF_OPT_TYPE_DOUBLE:
 274                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<double>" );
 275                 break;
 276             case FF_OPT_TYPE_FLOAT:
 277                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<float>" );
 278                 break;
 279             case FF_OPT_TYPE_STRING:
 280                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<string>" );
 281                 break;
 282             case FF_OPT_TYPE_RATIONAL:
 283                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>" );
 284                 break;
 285             case FF_OPT_TYPE_CONST:
 286             default:
 287                 av_log( av_log_obj, AV_LOG_INFO, "%-7s ", "" );
 288                 break;
 289         }
 290         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
 291         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
 292         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
 293         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
 294         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
 295
 296         if(opt->help)
 297             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
 298         av_log(av_log_obj, AV_LOG_INFO, "\n");
 299     }
 300     return 0;
 301 }