opts.c 5.26 KB
Newer Older
1 2 3 4
/*
 * LGPL
 */

Michael Niedermayer's avatar
Michael Niedermayer committed
5 6 7
/**
 * @file opts.c
 * options parser.
8 9 10 11 12 13
 * typical parsed command line:
 * msmpeg4:bitrate=720000:qmax=16
 *
 */

#include "avcodec.h"
14
#include "os_support.h"
15

16
const AVOption avoptions_common[] = {
17 18 19 20 21 22 23 24 25
    AVOPTION_CODEC_FLAG("bit_exact", "use only bit-exact stuff", flags, CODEC_FLAG_BITEXACT, 0),
    AVOPTION_CODEC_FLAG("mm_force", "force mm flags", dsp_mask, FF_MM_FORCE, 0),
#ifdef HAVE_MMX
    AVOPTION_CODEC_FLAG("mm_mmx", "mask MMX feature", dsp_mask, FF_MM_MMX, 0),
    AVOPTION_CODEC_FLAG("mm_3dnow", "mask 3DNow feature", dsp_mask, FF_MM_3DNOW, 0),
    AVOPTION_CODEC_FLAG("mm_mmxext", "mask MMXEXT (MMX2) feature", dsp_mask, FF_MM_MMXEXT, 0),
    AVOPTION_CODEC_FLAG("mm_sse", "mask SSE feature", dsp_mask, FF_MM_SSE, 0),
    AVOPTION_CODEC_FLAG("mm_sse2", "mask SSE2 feature", dsp_mask, FF_MM_SSE2, 0),
#endif
26 27 28
    AVOPTION_END()
};

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
const AVOption avoptions_workaround_bug[] = {
    AVOPTION_CODEC_FLAG("bug_autodetect", "workaround bug autodetection", workaround_bugs, FF_BUG_AUTODETECT, 1),
    AVOPTION_CODEC_FLAG("bug_old_msmpeg4", "workaround old msmpeg4 bug", workaround_bugs, FF_BUG_OLD_MSMPEG4, 0),
    AVOPTION_CODEC_FLAG("bug_xvid_ilace", "workaround XviD interlace bug", workaround_bugs, FF_BUG_XVID_ILACE, 0),
    AVOPTION_CODEC_FLAG("bug_ump4", "workaround ump4 bug", workaround_bugs, FF_BUG_UMP4, 0),
    AVOPTION_CODEC_FLAG("bug_no_padding", "workaround padding bug", workaround_bugs, FF_BUG_NO_PADDING, 0),
    AVOPTION_CODEC_FLAG("bug_ac_vlc", "workaround ac VLC bug", workaround_bugs, FF_BUG_AC_VLC, 0),
    AVOPTION_CODEC_FLAG("bug_qpel_chroma", "workaround qpel chroma bug", workaround_bugs, FF_BUG_QPEL_CHROMA, 0),
    AVOPTION_CODEC_FLAG("bug_std_qpel", "workaround std qpel bug", workaround_bugs, FF_BUG_STD_QPEL, 0),
    AVOPTION_CODEC_FLAG("bug_qpel_chroma2", "workaround qpel chroma2 bug", workaround_bugs, FF_BUG_QPEL_CHROMA2, 0),
    AVOPTION_CODEC_FLAG("bug_direct_blocksize", "workaround direct blocksize bug", workaround_bugs, FF_BUG_DIRECT_BLOCKSIZE, 0),
    AVOPTION_END()
};


44
static int parse_bool(const AVOption *c, char *s, int *var)
45 46 47 48 49 50 51 52 53 54 55 56 57
{
    int b = 1; /* by default -on- when present */
    if (s) {
	if (!strcasecmp(s, "off") || !strcasecmp(s, "false")
	    || !strcmp(s, "0"))
	    b = 0;
	else if (!strcasecmp(s, "on") || !strcasecmp(s, "true")
		 || !strcmp(s, "1"))
	    b = 1;
	else
	    return -1;
    }

58 59 60 61 62 63 64
    if (c->type == FF_OPT_TYPE_FLAG) {
	if (b)
	    *var |= (int)c->min;
	else
            *var &= ~(int)c->min;
    } else
	*var = b;
65 66 67
    return 0;
}

68
static int parse_double(const AVOption *c, char *s, double *var)
69 70 71 72 73 74 75 76 77 78 79 80
{
    double d;
    if (!s)
        return -1;
    d = atof(s);
    if (c->min != c->max) {
	if (d < c->min || d > c->max) {
	    fprintf(stderr, "Option: %s double value: %f out of range <%f, %f>\n",
		    c->name, d, c->min, c->max);
	    return -1;
	}
    }
81
    *var = d;
82 83 84
    return 0;
}

85
static int parse_int(const AVOption* c, char* s, int* var)
86 87 88 89 90 91 92 93 94 95 96 97
{
    int i;
    if (!s)
        return -1;
    i = atoi(s);
    if (c->min != c->max) {
	if (i < (int)c->min || i > (int)c->max) {
	    fprintf(stderr, "Option: %s integer value: %d out of range <%d, %d>\n",
		    c->name, i, (int)c->min, (int)c->max);
	    return -1;
	}
    }
98
    *var = i;
99 100 101
    return 0;
}

102
static int parse_string(const AVOption *c, char *s, void* strct, char **var)
103 104 105 106
{
    if (!s)
	return -1;

107
    if (c->type == FF_OPT_TYPE_RCOVERRIDE) {
108 109 110
	int sf, ef, qs;
	float qf;
	if (sscanf(s, "%d,%d,%d,%f", &sf, &ef, &qs, &qf) == 4 && sf < ef) {
111
	    AVCodecContext *avctx = (AVCodecContext *) strct;
112 113 114 115
	    RcOverride *o;
	    avctx->rc_override = av_realloc(avctx->rc_override,
					    sizeof(RcOverride) * (avctx->rc_override_count + 1));
	    o = avctx->rc_override + avctx->rc_override_count++;
116 117 118 119 120 121 122 123 124 125
	    o->start_frame = sf;
	    o->end_frame = ef;
	    o->qscale = qs;
	    o->quality_factor = qf;

	    //printf("parsed Rc:  %d,%d,%d,%f  (%d)\n", sf,ef,qs,qf, avctx->rc_override_count);
	} else {
	    printf("incorrect/unparsable Rc: \"%s\"\n", s);
	}
    } else
126
	*var = av_strdup(s);
127 128 129
    return 0;
}

130
int avoption_parse(void* strct, const AVOption* list, const char *opts)
131
{
132 133 134 135 136 137 138
    int r = 0;
    char* dopts = av_strdup(opts);
    if (dopts) {
        char *str = dopts;

	while (str && *str && r == 0) {
	    const AVOption *stack[FF_OPT_MAX_DEPTH];
139
	    const AVOption *c = list;
140 141 142 143 144 145 146 147 148 149 150 151 152
	    int depth = 0;
	    char* e = strchr(str, ':');
	    char* p;
	    if (e)
		*e++ = 0;

	    p = strchr(str, '=');
	    if (p)
		*p++ = 0;

            // going through option structures
	    for (;;) {
		if (!c->name) {
153
		    if (c->help) {
154
			stack[depth++] = c;
155
			c = (const AVOption*) c->help;
156 157 158 159 160 161 162 163 164
			assert(depth > FF_OPT_MAX_DEPTH);
		    } else {
			if (depth == 0)
			    break; // finished
			c = stack[--depth];
                        c++;
		    }
		} else {
		    if (!strcmp(c->name, str)) {
165
			void* ptr = (char*)strct + c->offset;
166 167 168 169 170 171 172 173 174 175 176 177

			switch (c->type & FF_OPT_TYPE_MASK) {
			case FF_OPT_TYPE_BOOL:
			    r = parse_bool(c, p, (int*)ptr);
			    break;
			case FF_OPT_TYPE_DOUBLE:
			    r = parse_double(c, p, (double*)ptr);
			    break;
			case FF_OPT_TYPE_INT:
			    r = parse_int(c, p, (int*)ptr);
			    break;
			case FF_OPT_TYPE_STRING:
178
			    r = parse_string(c, p, strct, (char**)ptr);
179 180 181 182 183 184 185
			    break;
			default:
			    assert(0 == 1);
			}
		    }
		    c++;
		}
186
	    }
187
	    str = e;
188
	}
189 190 191
	av_free(dopts);
    }
    return r;
192
}