synfig-core/tags/synfig_0_61_04/synfig-core/src/modules/mod_libavcodec/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 /* avoid compatibility problems by redefining it */
  43 static int av_strcasecmp(const char *s1, const char *s2)
  44 {
  45     signed char val;
  46
  47     for(;;) {
  48         val = toupper(*s1) - toupper(*s2);
  49         if (val != 0)
  50             break;
  51         if (*s1 != '\0')
  52             break;
  53         s1++;
  54         s2++;
  55     }
  56     return val;
  57 }
  58
  59
  60 static int parse_bool(const AVOption *c, char *s, int *var)
  61 {
  62     int b = 1; /* by default -on- when present */
  63     if (s) {
  64         if (!av_strcasecmp(s, "off") || !av_strcasecmp(s, "false")
  65             || !strcmp(s, "0"))
  66             b = 0;
  67         else if (!av_strcasecmp(s, "on") || !av_strcasecmp(s, "true")
  68                  || !strcmp(s, "1"))
  69             b = 1;
  70         else
  71             return -1;
  72     }
  73
  74     if (c->type == FF_OPT_TYPE_FLAG) {
  75         if (b)
  76             *var |= (int)c->min;
  77         else
  78             *var &= ~(int)c->min;
  79     } else
  80         *var = b;
  81     return 0;
  82 }
  83
  84 static int parse_double(const AVOption *c, char *s, double *var)
  85 {
  86     double d;
  87     if (!s)
  88         return -1;
  89     d = atof(s);
  90     if (c->min != c->max) {
  91         if (d < c->min || d > c->max) {
  92             fprintf(stderr, "Option: %s double value: %f out of range <%f, %f>\n",
  93                     c->name, d, c->min, c->max);
  94             return -1;
  95         }
  96     }
  97     *var = d;
  98     return 0;
  99 }
 100
 101 static int parse_int(const AVOption* c, char* s, int* var)
 102 {
 103     int i;
 104     if (!s)
 105         return -1;
 106     i = atoi(s);
 107     if (c->min != c->max) {
 108         if (i < (int)c->min || i > (int)c->max) {
 109             fprintf(stderr, "Option: %s integer value: %d out of range <%d, %d>\n",
 110                     c->name, i, (int)c->min, (int)c->max);
 111             return -1;
 112         }
 113     }
 114     *var = i;
 115     return 0;
 116 }
 117
 118 static int parse_string(const AVOption *c, char *s, void* strct, char **var)
 119 {
 120     if (!s)
 121         return -1;
 122
 123     if (c->type == FF_OPT_TYPE_RCOVERRIDE) {
 124         int sf, ef, qs;
 125         float qf;
 126         if (sscanf(s, "%d,%d,%d,%f", &sf, &ef, &qs, &qf) == 4 && sf < ef) {
 127             AVCodecContext *avctx = (AVCodecContext *) strct;
 128             RcOverride *o;
 129             avctx->rc_override = av_realloc(avctx->rc_override,
 130                                             sizeof(RcOverride) * (avctx->rc_override_count + 1));
 131             o = avctx->rc_override + avctx->rc_override_count++;
 132             o->start_frame = sf;
 133             o->end_frame = ef;
 134             o->qscale = qs;
 135             o->quality_factor = qf;
 136
 137             //printf("parsed Rc:  %d,%d,%d,%f  (%d)\n", sf,ef,qs,qf, avctx->rc_override_count);
 138         } else {
 139             printf("incorrect/unparsable Rc: \"%s\"\n", s);
 140         }
 141     } else
 142         *var = av_strdup(s);
 143     return 0;
 144 }
 145
 146 int avoption_parse(void* strct, const AVOption* list, const char *opts)
 147 {
 148     int r = 0;
 149     char* dopts = av_strdup(opts);
 150     if (dopts) {
 151         char *str = dopts;
 152
 153         while (str && *str && r == 0) {
 154             const AVOption *stack[FF_OPT_MAX_DEPTH];
 155             const AVOption *c = list;
 156             int depth = 0;
 157             char* e = strchr(str, ':');
 158             char* p;
 159             if (e)
 160                 *e++ = 0;
 161
 162             p = strchr(str, '=');
 163             if (p)
 164                 *p++ = 0;
 165
 166             // going through option structures
 167             for (;;) {
 168                 if (!c->name) {
 169                     if (c->help) {
 170                         stack[depth++] = c;
 171                         c = (const AVOption*) c->help;
 172                         assert(depth > FF_OPT_MAX_DEPTH);
 173                     } else {
 174                         if (depth == 0)
 175                             break; // finished
 176                         c = stack[--depth];
 177                         c++;
 178                     }
 179                 } else {
 180                     if (!strcmp(c->name, str)) {
 181                         void* ptr = (char*)strct + c->offset;
 182
 183                         switch (c->type & FF_OPT_TYPE_MASK) {
 184                         case FF_OPT_TYPE_BOOL:
 185                             r = parse_bool(c, p, (int*)ptr);
 186                             break;
 187                         case FF_OPT_TYPE_DOUBLE:
 188                             r = parse_double(c, p, (double*)ptr);
 189                             break;
 190                         case FF_OPT_TYPE_INT:
 191                             r = parse_int(c, p, (int*)ptr);
 192                             break;
 193                         case FF_OPT_TYPE_STRING:
 194                             r = parse_string(c, p, strct, (char**)ptr);
 195                             break;
 196                         default:
 197                             assert(0 == 1);
 198                         }
 199                     }
 200                     c++;
 201                 }
 202             }
 203             str = e;
 204         }
 205         av_free(dopts);
 206     }
 207     return r;
 208 }