PeerStreamer

#define LIBAVCODEC_VERSION_MAJOR 52

#define LIBAVCODEC_VERSION_MINOR 72

#define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

                                               LIBAVCODEC_VERSION_MINOR, \

    return NAN;

}

void ff_free_expr(AVExpr * e) {

    if (!e) return;

    av_freep(&e);

}

    AVExpr * d = av_mallocz(sizeof(AVExpr));

    char *next= p->s;

    if (!d)

    /* number */

    d->value = av_strtod(p->s, &next);

    if(next != p->s){

        d->type = e_value;

        p->s= next;

    }

    d->value = 1;

            p->s+= strlen(p->const_name[i]);

            d->type = e_const;

            d->a.const_index = i;

        }

    }

        av_log(p, AV_LOG_ERROR, "undefined constant or missing (\n");

        p->s= next;

        ff_free_expr(d);

    }

    p->s++; // "("

    if (*next == '(') { // special case do-nothing

        av_freep(&d);

        if(p->s[0] != ')'){

            av_log(p, AV_LOG_ERROR, "missing )\n");

            ff_free_expr(d);

        }

        p->s++; // ")"

    }

    if(p->s[0]== ','){

        p->s++; // ","

    }

    if(p->s[0] != ')'){

        av_log(p, AV_LOG_ERROR, "missing )\n");

        ff_free_expr(d);

    }

    p->s++; // ")"

            if(strmatch(next, p->func1_name[i])){

                d->a.func1 = p->func1[i];

                d->type = e_func1;

            }

        }

            if(strmatch(next, p->func2_name[i])){

                d->a.func2 = p->func2[i];

                d->type = e_func2;

            }

        }

        av_log(p, AV_LOG_ERROR, "unknown function\n");

        ff_free_expr(d);

    }

}

static AVExpr * new_eval_expr(int type, int value, AVExpr *p0, AVExpr *p1){

    return e;

}

    *sign= (*p->s == '+') - (*p->s == '-');

    p->s += *sign&1;

}

    while(p->s[0]=='^'){

        p->s++;

    }

}

    while(p->s[0]=='*' || p->s[0]=='/'){

        int c= *p->s++;

    }

}

    while(*p->s == '+' || *p->s == '-') {

    };

}

    if(p->stack_index <= 0) //protect against stack overflows

    p->stack_index--;

    while(*p->s == ';') {

        p->s++;

    };

    p->stack_index++;

}

static int verify_expr(AVExpr * e) {

    }

}

                      const char * const *const_name,

                      const char * const *func1_name, double (* const *func1)(void *, double),

                      const char * const *func2_name, double (* const *func2)(void *, double, double),

    AVExpr *e = NULL;

    char *w = av_malloc(strlen(s) + 1);

    char *wp = w;

    if (!w)

    while (*s)

        if (!isspace(*s++)) *wp++ = s[-1];

    p.log_offset = log_offset;

    p.log_ctx    = log_ctx;

    if (!verify_expr(e)) {

        ff_free_expr(e);

    }

end:

    av_free(w);

}

double ff_eval_expr(AVExpr * e, const double *const_value, void *opaque) {

    return eval_expr(&p, e);

}

                              const char * const *const_name, const double *const_value,

                              const char * const *func1_name, double (* const *func1)(void *, double),

                              const char * const *func2_name, double (* const *func2)(void *, double, double),

                              void *opaque, int log_offset, void *log_ctx)

{

    ff_free_expr(e);

}

#ifdef TEST

};

int main(void){

    int i;

    for(i=0; i<1050; i++){

        START_TIMER

        STOP_TIMER("ff_parse_and_eval_expr")

    }

    return 0;

 * Parses and evaluates an expression.

 * Note, this is significantly slower than ff_eval_expr().

 *

 * @param s expression as a zero terminated string for example "1+2^3+5*5+sin(2/3)"

 * @param const_name NULL terminated array of zero terminated strings of constant identifers for example {"PI", "E", 0}

 * @param const_value a zero terminated array of values for the identifers from const_name

 * @param func2 NULL terminated array of function pointers for functions which take 2 arguments

 * @param opaque a pointer which will be passed to all functions from func1 and func2

 * @param log_ctx parent logging context

 */

                              const char * const *const_name, const double *const_value,

                              const char * const *func1_name, double (* const *func1)(void *, double),

                              const char * const *func2_name, double (* const *func2)(void *, double, double),

/**

 * Parses an expression.

 *

 * @param s expression as a zero terminated string for example "1+2^3+5*5+sin(2/3)"

 * @param const_name NULL terminated array of zero terminated strings of constant identifers for example {"PI", "E", 0}

 * @param func1_name NULL terminated array of zero terminated strings of func1 identifers

 * @param func2_name NULL terminated array of zero terminated strings of func2 identifers

 * @param func2 NULL terminated array of function pointers for functions which take 2 arguments

 * @param log_ctx parent logging context

 */

                      const char * const *const_name,

                      const char * const *func1_name, double (* const *func1)(void *, double),

                      const char * const *func2_name, double (* const *func2)(void *, double, double),

                else if(!strcmp(buf, "none"   )) d= 0;

                else if(!strcmp(buf, "all"    )) d= ~0;

                else {

                        av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);

                    }

                }

            }

int ff_rate_control_init(MpegEncContext *s)

{

    RateControlContext *rcc= &s->rc_context;

    static const char * const const_names[]={

        "PI",

        "E",

    };

    emms_c();

        av_log(s->avctx, AV_LOG_ERROR, "Error parsing rc_eq \"%s\"\n", s->avctx->rc_eq);

    }

    for(i=0; i<5; i++){