PeerStreamer

The parameters @var{width}, @var{height}, @var{x}, and @var{y} are

expressions containing the following constants:

@table @option

@item E, PI, PHI

the corresponding mathematical approximated values for e

(euler number), pi (greek PI), phi (golden ratio)

@item in_w, in_h

the input video width and heigth

@item iw, ih

same as @var{in_w} and @var{in_h}

@item out_w, out_h

the output width and heigth, that is the size of the padded area as

specified by the @var{width} and @var{height} expressions

@item ow, oh

same as @var{out_w} and @var{out_h}

@item x, y

x and y offsets as specified by the @var{x} and @var{y}

expressions, or NAN if not yet specified

@item a

input display aspect ratio, same as @var{iw} / @var{ih}

@item hsub, vsub

horizontal and vertical chroma subsample values. For example for the

pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.

@end table

The @var{width} expression can reference the value set by the

@var{height} expression, and viceversa.

The @var{x} expression can reference the value set by the @var{y}

expression, and viceversa.

Some examples follow:

# pad the input to get an output with dimensions increased bt 3/2,

# and put the input video at the center of the padded area

pad="3/2*iw:3/2*ih:(ow-iw)/2:(oh-ih)/2"

# pad the input to get a squared output with size equal to the maximum

# value between the input width and height, and put the input video at

# the center of the padded area

pad="max(iw\,ih):ow:(ow-iw)/2:(oh-ih)/2"

# pad the input to get a final w/h ratio of 16:9

pad="ih*16/9:ih:(ow-iw)/2:(oh-ih)/2"

# double output size and put the input video in the bottom-right

# corner of the output padded area

pad="2*iw:2*ih:ow-iw:oh-ih"

#define LIBAVFILTER_VERSION_MICRO  1

#include "libavutil/avstring.h"

#include "libavutil/eval.h"

static const char *var_names[] = {

    "PI",

    "PHI",

    "E",

    "in_w",   "iw",

    "in_h",   "ih",

    "out_w",  "ow",

    "out_h",  "oh",

    "x",

    "y",

    "a",

    "hsub",

    "vsub",

    NULL

};

enum var_name {

    VAR_PI,

    VAR_PHI,

    VAR_E,

    VAR_IN_W,   VAR_IW,

    VAR_IN_H,   VAR_IH,

    VAR_OUT_W,  VAR_OW,

    VAR_OUT_H,  VAR_OH,

    VAR_X,

    VAR_Y,

    VAR_A,

    VAR_HSUB,

    VAR_VSUB,

    VARS_NB

};

    char w_expr[256];       ///< width  expression string

    char h_expr[256];       ///< height expression string

    char x_expr[256];       ///< width  expression string

    char y_expr[256];       ///< height expression string

    av_strlcpy(pad->w_expr, "iw", sizeof(pad->w_expr));

    av_strlcpy(pad->h_expr, "ih", sizeof(pad->h_expr));

    av_strlcpy(pad->x_expr, "0" , sizeof(pad->w_expr));

    av_strlcpy(pad->y_expr, "0" , sizeof(pad->h_expr));

        sscanf(args, "%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255s",

               pad->w_expr, pad->h_expr, pad->x_expr, pad->y_expr, color_string);

    int ret, is_packed_rgba;

    double var_values[VARS_NB], res;

    char *expr;

    var_values[VAR_PI]    = M_PI;

    var_values[VAR_PHI]   = M_PHI;

    var_values[VAR_E]     = M_E;

    var_values[VAR_IN_W]  = var_values[VAR_IW] = inlink->w;

    var_values[VAR_IN_H]  = var_values[VAR_IH] = inlink->h;

    var_values[VAR_OUT_W] = var_values[VAR_OW] = NAN;

    var_values[VAR_OUT_H] = var_values[VAR_OH] = NAN;

    var_values[VAR_A]     = (float) inlink->w / inlink->h;

    var_values[VAR_HSUB]  = 1<<pad->hsub;

    var_values[VAR_VSUB]  = 2<<pad->vsub;

    /* evaluate width and height */

    av_expr_parse_and_eval(&res, (expr = pad->w_expr),

                           var_names, var_values,

                           NULL, NULL, NULL, NULL, NULL, 0, ctx);

    pad->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;

    if ((ret = av_expr_parse_and_eval(&res, (expr = pad->h_expr),

                                      var_names, var_values,

                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)

        goto eval_fail;

    pad->h = var_values[VAR_OUT_H] = var_values[VAR_OH] = res;

    /* evaluate the width again, as it may depend on the evaluated output height */

    if ((ret = av_expr_parse_and_eval(&res, (expr = pad->w_expr),

                                      var_names, var_values,

                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)

        goto eval_fail;

    pad->w = var_values[VAR_OUT_W] = var_values[VAR_OW] = res;

    /* evaluate x and y */

    av_expr_parse_and_eval(&res, (expr = pad->x_expr),

                           var_names, var_values,

                           NULL, NULL, NULL, NULL, NULL, 0, ctx);

    pad->x = var_values[VAR_X] = res;

    if ((ret = av_expr_parse_and_eval(&res, (expr = pad->y_expr),

                                      var_names, var_values,

                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)

        goto eval_fail;

    pad->y = var_values[VAR_Y] = res;

    /* evaluate x again, as it may depend on the evaluated y value */

    if ((ret = av_expr_parse_and_eval(&res, (expr = pad->x_expr),

                                      var_names, var_values,

                                      NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0)

        goto eval_fail;

    pad->x = var_values[VAR_X] = res;

    /* sanity check params */

    if (pad->w < 0 || pad->h < 0 || pad->x < 0 || pad->y < 0) {

        av_log(ctx, AV_LOG_ERROR, "Negative values are not acceptable.\n");

        return AVERROR(EINVAL);

    }

eval_fail:

    av_log(NULL, AV_LOG_ERROR,

           "Error when evaluating the expression '%s'\n", expr);

    return ret;