params.h

这个库实现了录象功能

    .name =        "ff_mb_threshold", \
    .real_name =   TRS("MB Theshold"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 4000000 }, \
    .help_string = TRS("Macroblock threshold. under which the user specified " \
                       "macroblock types will be used")                 \
  }

#define PARAM_NSSE_WEIGHT \
  { \
    .name =        "ff_nsse_weight", \
    .real_name =   TRS("NSSE weight"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 8 },\
    .help_string = TRS("Noise vs. SSE weight for the NSSE comparsion function. " \
                       "0 is identical to SSE")                         \
  }

/** Masking */
#define PARAM_BORDER_MASKING \
  { \
    .name =        "ff_border_masking", \
    .real_name =   TRS("Border masking"),       \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 0.0 }, \
    .val_min =     { .val_float = 0.0 }, \
    .val_max =     { .val_float = 1.0 }, \
    .num_digits =  2, \
    .help_string = TRS("Encode image parts near the border with reduced quality." \
                       "0 means disabled")                              \
  }

#define PARAM_MB_LMIN \
  { \
    .name =        "ff_mb_lmin", \
    .real_name =   TRS("Minimum MB lagrange multipler"),        \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 2.0 }, \
    .val_min =     { .val_float = 1.0 }, \
    .val_min =     { .val_float = 31.0 }, \
    .num_digits =  1, \
       .help_string = TRS("Minimum macroblock Lagrange multiplier.")    \
  }

#define PARAM_MB_LMAX \
  { \
    .name =        "ff_mb_lmax", \
    .real_name =   TRS("Maximum MB lagrange multipler"),        \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 31.0 }, \
    .val_min =     { .val_float = 1.0 }, \
    .val_min =     { .val_float = 31.0 }, \
    .num_digits =  1, \
       .help_string = TRS("Maximum macroblock Lagrange multiplier.")    \
  }

/** Motion estimation */
#define PARAM_ME_PENALTY_COMPENSATION \
  { \
    .name =        "ff_me_penalty_compensation", \
    .real_name =   TRS("ME penalty compensation"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 256 }, \
  }

#define PARAM_BIDIR_REFINE \
  { \
    .name =        "ff_bidir_refine", \
    .real_name =   TRS("Bidir refine"),         \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 4 }, \
  }

#define PARAM_BRD_SCALE \
  { \
    .name =        "ff_brd_scale", \
    .real_name =   TRS("BRD scale"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 10 }, \
  }


/** Frame types */
#define PARAM_SCENECHANGE_FACTOR \
  { \
    .name =        "ff_scenechange_factor", \
    .real_name =   TRS("Scenechange factor"),   \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .help_string = TRS("Multiplied by qscale for each frame and added to " \
                       "scene_change_score")                            \
  }

/** Quantizer */
#define PARAM_QSCALE \
  { \
    .name =        "ff_qscale", \
    .real_name =   TRS("Fixed quantizer"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 10 }, \
    .val_min =     { .val_int = 1 }, \
    .val_max =     { .val_int = 31 }, \
    .help_string = TRS("Quantizer for fixed quality encoding. Lower means " \
                       "better, 1 is not recommended")                  \
  }

/* Flags */

/** Quantizer */
#define PARAM_FLAG_QSCALE \
  { \
    .name =        "ff_flag_qscale", \
    .real_name =   TRS("Use fixed quantizer"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Use fixed quality encoding"),        \
  }

/** Motion estimation */
#define PARAM_FLAG_4MV \
  { \
    .name =        "ff_flag_4mv", \
    .real_name =   TRS("4 MV per MB allowed"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("Allow 4 motion vectors per macroblock (slightly better " \
                   "quality). Works better if MB decision mode is " \
                       "\"Fewest bits\" or \"Rate distoration\".")  \
  }

/** Motion estimation */
#define PARAM_FLAG_QPEL \
  { \
    .name =        "ff_flag_qpel", \
    .real_name =   TRS("Use qpel MC"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("Use 1/4 pixel motion compensation. Warning: QPEL is not " \
                       "supported by all decoders.")                    \
  }

/** Motion estimation */
#define PARAM_FLAG_GMC \
  { \
    .name =        "ff_flag_gmc", \
    .real_name =   TRS("Use global motion compensation"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Warning: GMC is not supported by all decoders") \
  }

/** Motion estimation */
#define PARAM_FLAG_MV0 \
  { \
    .name =        "ff_flag_mv0", \
    .real_name =   TRS("Always try a MB with MV=<0,0>"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }


#define PARAM_FLAG_PART \
  { \
    .name =        "ff_flag_part", \
    .real_name =   TRS("Use data partitioning"),        \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("Use data partitioning for more robustness if the video " \
                       "is for transmitting over unreliable channels")  \
  }


#define PARAM_FLAG_GRAY \
  { \
    .name =        "ff_flag_gray", \
    .real_name =   TRS("Grayscale mode"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG_EMU_EGDE \
  { \
    .name =        "ff_flag_emu_edge", \
    .real_name =   TRS("Don't draw edges"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Masking */
#define PARAM_FLAG_NORMALIZE_AQP \
  { \
    .name =        "ff_flag_normalize_aqp", \
    .real_name =   TRS("Normalize adaptive quantization"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("When using masking, try to adjust the per " \
                       "macroblock quantizers to maintain the desired average") \
  }

#define PARAM_FLAG_ALT_SCAN \
  { \
    .name =        "ff_flag_alt_scan", \
    .real_name =   TRS("Use alternative scantable"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Quantizer */
#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)

#define PARAM_TRELLIS \
  { \
    .name =        "ff_flag_trellis_quant", \
    .real_name =   TRS("Use trellis quantization"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Use trellis quantization (improves quality)") \
  }
#else
#define PARAM_TRELLIS \
  { \
    .name =        "ff_trellis", \
    .real_name =   TRS("Use trellis quantization"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Use trellis quantization (improves quality)") \
  }
#endif

#define PARAM_FLAG_BITEXACT \
  { \
    .name =        "ff_flag_bitexact", \
    .real_name =   TRS("Use only bitexact stuff"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Use only bitexact stuff (except (i)dct)")    \
  }

#define PARAM_FLAG_AC_PRED_H263 \
  { \
    .name =        "ff_flag_ac_pred", \
    .real_name =   TRS("Advanced intra coding"),        \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG_AC_PRED_MPEG4 \
  { \
    .name =        "ff_flag_ac_pred", \
    .real_name =   TRS("MPEG-4 AC prediction"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG_H263P_UMV \
  { \
    .name =        "ff_flag_h263p_umv", \
    .real_name =   TRS("Unlimited motion vector"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG_CBP_RD \
  { \
    .name =        "ff_flag_cbp_rd", \
    .real_name =   TRS("CBP RD"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Use rate distortion optimization for cbp. This can only be used together with trellis quantization."),  \
  }

#define PARAM_FLAG_QP_RD \
  { \
    .name =        "ff_flag_qp_rd", \
    .real_name =   TRS("QP RD"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("Use rate distortion optimization for qp selection. Can only be used if MB decision mode is \"Rate distoration\""), \
  }

#define PARAM_FLAG_H263P_AIV \
  { \
    .name =        "ff_flag_h263p_aiv", \
    .real_name =   TRS("Alternative inter vlc"),        \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/* H.263(+) */
#define PARAM_FLAG_OBMC \
  { \
    .name =        "ff_flag_obmc", \
    .real_name =   TRS("OBMC"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
    .help_string = TRS("Overlapped block motion compensation (only supported " \
                       "with simple MB decision)")                      \
  }

#define PARAM_FLAG_LOOP_FILTER \
  { \
    .name =        "ff_flag_loop_filter", \
    .real_name =   TRS("Loop filter"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG_H263P_SLICE_STRUCT \
  { \
    .name =        "ff_flag_h263p_slice_struct", \
    .real_name =   TRS("Slice struct"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Frame types */
#define PARAM_FLAG_CLOSED_GOP \
  { \
    .name =        "ff_flag_closed_gop", \
    .real_name =   TRS("Close all GOPs"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_FLAG2_FAST \
  { \
    .name =        "ff_flag2_fast", \
    .real_name =   TRS("Allow fast encoding"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
       .help_string = TRS("Allow non spec compliant speedup tricks")    \
  }

/** Frame types */
#define PARAM_FLAG2_STRICT_GOP \
  { \
    .name =        "ff_flag2_strict_gop", \
    .real_name =   TRS("Strictly enforce GOP size"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }