params.h

这个库实现了录象功能

    .val_default = { .val_string = "Left" },\
    .stringlist_options = (char*[]){ TRS("Left"), TRS("Plane"), TRS("Median"), (char*)0 }, \
  }

/** Quantizer */
#define PARAM_MB_QMIN \
  { \
    .name =        "ff_mb_qmin", \
    .real_name =   TRS("Minimum MB quantizer"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 2 },\
    .val_min =     { .val_int = 0 },\
    .val_max =     { .val_int = 31 },\
  }

/** Quantizer */
#define PARAM_MB_QMAX \
  { \
    .name =        "ff_mb_qmax", \
    .real_name =   TRS("Maximum MB quantizer"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 31 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 31 }, \
  }

#define COMPARE_FUNCS (char*[]){ TRS("SAD"), TRS("SSE"), TRS("SATD"), TRS("DCT"), TRS("PSNR"), \
                                 TRS("BIT"), TRS("RD"), TRS("ZERO"), TRS("VSAD"), TRS("VSSE"), \
                                 TRS("NSSE"), \
                                 (char*)0 }

#define COMPARE_FUNCS_HELP "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences"

/** Motion estimation */
#define PARAM_ME_CMP \
  { \
    .name =        "ff_me_cmp", \
    .real_name =   TRS("ME compare function"),  \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "SAD" }, \
    .stringlist_options = COMPARE_FUNCS, \
       .help_string = TRS("Motion estimation compare function.\n"      \
                   "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences") \
  }

/** Motion estimation */
#define PARAM_ME_CMP_CHROMA \
  { \
    .name =        "ff_me_cmp_chroma", \
    .real_name =   TRS("Enable chroma ME compare"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Motion estimation */
#define PARAM_ME_SUB_CMP \
  { \
    .name =        "ff_me_sub_cmp", \
    .real_name =   TRS("Subpixel ME compare function"), \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "SAD" }, \
    .stringlist_options = COMPARE_FUNCS, \
    .help_string = TRS("Subpixel motion estimation compare function.\n" \
                       "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences")                              \
  }

/** Motion estimation */
#define PARAM_ME_SUB_CMP_CHROMA \
  { \
    .name =        "ff_me_sub_cmp_chroma", \
    .real_name =   TRS("Enable chroma subpixel ME compare"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }


#define PARAM_MB_CMP \
  { \
    .name =        "ff_mb_cmp", \
    .real_name =   TRS("MB compare function"),  \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "SAD" }, \
    .stringlist_options = COMPARE_FUNCS, \
    .help_string = TRS("Macroblock compare function.\n" \
                       "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences")              \
  }

#define PARAM_MB_CMP_CHROMA \
  { \
    .name =        "ff_mb_cmp_chroma", \
    .real_name =   TRS("Enable chroma macroblock ME compare"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }


#define PARAM_ILDCT_CMP \
  { \
    .name =        "ff_ildct_cmp", \
    .real_name =   TRS("ILDCT compare function"),       \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "SAD" }, \
    .stringlist_options = COMPARE_FUNCS, \
    .help_string = TRS("Interlaced dct compare function.\n" \
                       "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences")                  \
  }

#define PARAM_ICDCT_CMP_CHROMA \
  { \
    .name =        "ff_ildct_cmp_chroma", \
    .real_name =   TRS("Enable chroma ILDCT ME compare"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Motion estimation */
#define PARAM_DIA_SIZE \
  { \
    .name =        "ff_dia_size", \
    .real_name =   TRS("ME diamond size & shape"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = -9 }, \
    .val_max =     { .val_int =  9 }, \
    .help_string = TRS("Motion estimation diamond size. Negative means shape " \
                       "adaptive.")                                     \
  }

#define PARAM_LAST_PREDICTOR_COUNT \
  { \
    .name =        "ff_last_predictor_count", \
    .real_name =   TRS("Last predictor count"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 99 }, \
    .help_string = TRS("Amount of motion predictors from the previous frame.\n" \
                   "0 (default)\n" \
                   "a Will use 2a+1 x 2a+1 macroblock square of motion " \
                       "vector predictors from the previous frame.")    \
  }

/** Motion estimation */
#define PARAM_PRE_ME \
  { \
    .name =        "ff_pre_me", \
    .real_name =   TRS("ME pre-pass"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 2 }, \
    .help_string = TRS("Motion estimation pre-pass\n" \
                   "0: disabled\n" \
                   "1: only after I-frames\n" \
                       "2: always")           \
   }

/** Motion estimation */
#define PARAM_ME_PRE_CMP \
  { \
    .name =        "ff_me_pre_cmp", \
    .real_name =   TRS("ME pre-pass compare function"), \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "SAD" }, \
    .stringlist_options = COMPARE_FUNCS, \
    .help_string = TRS("Motion estimation pre-pass compare function.\n" \
                       "SAD: Sum of absolute differences\n" \
"SSE: Sum of squared errors\n" \
"SATD: Sum of absolute Hadamard transformed differences\n" \
"DCT: Sum of absolute DCT transformed differences\n" \
"PSNR: Sum of squared quantization errors (low quality)\n" \
"BIT: Number of bits needed for the block\n" \
"RD: Rate distortion optimal (slow)\n" \
"ZERO: 0\n" \
"VSAD: Sum of absolute vertical differences\n" \
"VSSE: Sum of squared vertical differences\n" \
"NSSE: Noise preserving sum of squared differences")                              \
  }

/** Motion estimation */
#define PARAM_ME_PRE_CMP_CHROMA \
  { \
    .name =        "ff_me_pre_cmp_chroma", \
    .real_name =   TRS("Enable chroma ME pre-pass compare"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

/** Motion estimation */
#define PARAM_PRE_DIA_SIZE \
  { \
    .name =        "ff_pre_dia_size", \
    .real_name =   TRS("ME pre-pass diamond size & shape"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = -9 }, \
    .val_max =     { .val_int = 9 }, \
    .help_string = TRS("Motion estimation pre-pass diamond size. Negative means " \
                       "shape adaptive.")                               \
  }

/** Motion estimation */
#define PARAM_ME_SUBPEL_QUALITY \
  { \
    .name =        "ff_me_subpel_quality", \
    .real_name =   TRS("Subpel ME quality"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 8 }, \
    .val_min =     { .val_int = 1 }, \
    .val_max =     { .val_int = 8 }, \
    .help_string = TRS("Subpel motion estimation refinement quality (for qpel). " \
                       "Higher values mean higher quality but slower encoding.") \
  }

/** Motion estimation */
#define PARAM_ME_RANGE \
  { \
    .name =        "ff_me_range", \
    .real_name =   TRS("Motion estimation range"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1000 }, \
       .help_string = TRS("Motion estimation search range (0 means unlimited)"), \
  }

/** Motion estimation */
#define PARAM_MB_DECISION \
  { \
    .name =        "ff_mb_decision", \
    .real_name =   TRS("MB decision mode"),  \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "Use compare function" }, \
    .stringlist_options = (char*[]){ TRS("Use compare function"), TRS("Fewest bits"), \
                                     TRS("Rate distoration"), (char*)0 }, \
  }

/** Frame types */
#define PARAM_SCENE_CHANGE_THRESHOLD \
  { \
    .name =        "ff_scenechange_threshold", \
    .real_name =   TRS("Scenechange threshold"),        \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = -1000000000 }, \
    .val_max =     { .val_int = 1000000000 }, \
    .help_string = TRS("Threshold for scene change detection.\n" \
                       "Negative values mean more sensitivity (more keyframes)") \
  }

/** Rate control */
#define PARAM_LMIN \
  { \
    .name =        "ff_lmin", \
    .real_name =   TRS("Minimum 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 Lagrange multiplier for ratecontrol. " \
                       "Should possibly be the same as minimum quantizer scale.") \
  }

/** Rate control */
#define PARAM_LMAX \
  { \
    .name =        "ff_lmax", \
    .real_name =   TRS("Maximum 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 Lagrange multiplier for ratecontrol. Should " \
                       "possibly be the same as maximum quantizer scale.") \
  }

#define PARAM_NOISE_REDUCTION \
  { \
    .name =        "ff_noise_reduction", \
    .real_name =   TRS("Noise reduction"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 2000 }, \
  }

/** Rate control */
#define PARAM_RC_INITIAL_BUFFER_OCCUPANCY \
  { \
    .name =        "ff_rc_initial_buffer_occupancy", \
    .real_name =   TRS("Initial RC buffer occupancy"),  \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .help_string = TRS("Number of kilobits which should be loaded into the rc " \
                   "buffer before encoding starts. Must not be larger than " \
                       "RC buffer size")                                \
  }


/* Does nothing */
/** Frame types */
#define PARAM_INTER_THRESHOLD \
  { \
    .name =        "ff_inter_threshold", \
    .real_name =   TRS("Inter threshold"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
  }

/** Quantizer */
#define PARAM_QUANTIZER_NOISE_SHAPING \
  { \
    .name =        "ff_quantizer_noise_shaping", \
    .real_name =   TRS("Quantizer noise shaping"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 3 }, \
    .help_string = TRS("Choose quantization such that noise will be masked by " \
                       "similar-frequency content in the image")        \
  }

/** Motion estimation */
#define PARAM_ME_THRESHOLD \
  { \
    .name =        "ff_me_threshold", \
    .real_name =   TRS("ME Theshold"),          \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 4000000 }, \
    .help_string = TRS("Motion estimation threshold. under which no motion " \
                   "estimation is performed, but instead the user specified " \
                       "motion vectors are used")                       \
  }

#define PARAM_MB_THRESHOLD \
  { \