params.h

这个库实现了录象功能

/*******************************************************************************
 params.h

 libquicktime - A library for reading and writing quicktime/avi/mp4 files.
 http://libquicktime.sourceforge.net

 Copyright (C) 2002 Heroine Virtual Ltd.
 Copyright (C) 2002-2007 Members of the libquicktime project.

 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2.1 of the License, or (at your option)
 any later version.

 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 details.

 You should have received a copy of the GNU Lesser General Public License along
 with this library; if not, write to the Free Software Foundation, Inc., 51
 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*******************************************************************************/ 

/*
 *   IMPORTANT: To keep the mess at a reasonable level,
 *   *all* parameters *must* appear in the same order as in
 *   the AVCocecContext structure, except the flags, which come at the very end
 */


/** Rate control */
#define PARAM_BITRATE_AUDIO \
  { \
    .name =        "ff_bit_rate_audio", \
    .real_name =   TRS("Bit rate (kbps)"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 128 }, \
  }

/** Rate control */
#define PARAM_BITRATE_VIDEO \
  { \
    .name =        "ff_bit_rate_video", \
    .real_name =   TRS("Bit rate (kbps)"),      \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 800 }, \
  }

/** Rate control */
#define PARAM_BITRATE_TOLERANCE \
  { \
    .name =        "ff_bit_rate_tolerance", \
    .real_name =   TRS("Bitrate tolerance (kbps)"),     \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 8000 }, \
    .help_string = TRS("Number of bits the bitstream is allowed to diverge from \
the reference. Unused for constant quantizer encoding") \
  }

/** Motion estimation */
#define PARAM_ME_METHOD \
  { \
    .name =        "ff_me_method", \
    .real_name =   TRS("Motion estimation method"),     \
    .type =        LQT_PARAMETER_STRINGLIST, \
    .val_default = { .val_string = "Zero" }, \
    .stringlist_options = (char *[]){ TRS("Zero"), TRS("Phods"), TRS("Log"), \
                                      TRS("X1"), TRS("Epzs"), TRS("Full"), \
                                      (char *)0 }  \
  }

/** Frame types */
#define PARAM_GOP_SIZE \
  { \
    .name =        "gop_size", \
    .real_name =   TRS("GOP size (0 = intra only)"),    \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 250 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 300 }, \
  } \

/** Quantizer */
#define PARAM_QCOMPRESS \
  { \
    .name =        "ff_qcompress", \
    .real_name =   TRS("Quantizer compression"),        \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 0.5 }, \
    .val_min =     { .val_float = 0.0 }, \
    .val_max =     { .val_float = 1.0 }, \
    .num_digits =  2, \
    .help_string = TRS("Amount of qscale change between easy & hard scenes") \
  }

/** Quantizer */
#define PARAM_QBLUR \
  { \
    .name =        "ff_qblur", \
    .real_name =   TRS("Quantizer blur"),       \
    .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("Amount of qscale smoothing over time"),      \
  }

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

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

/** Quantizer */
#define PARAM_MAX_QDIFF \
  { \
    .name =        "ff_max_qdiff", \
    .real_name =   TRS("Maximum quantizer difference"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 3 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 31 }, \
    .help_string = TRS("Maximum quantizer difference between frames") \
  }

/** Frame types */
#define PARAM_MAX_B_FRAMES \
  { \
    .name =        "ff_max_b_frames", \
    .real_name =   TRS("Max B-Frames"),         \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = FF_MAX_B_FRAMES }, \
    .help_string = TRS("Maximum number of B-frames between non B-frames") \
  }

/** Quantizer */
#define PARAM_B_QUANT_FACTOR \
  { \
    .name =        "ff_b_quant_factor", \
    .real_name =   TRS("B quantizer factor"),   \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 1.25 }, \
    .val_min =     { .val_float = -31.0 }, \
    .val_max =     { .val_float = 31.0 }, \
    .num_digits =  2, \
    .help_string = TRS("Quantizer factor between B-frames and non-B-frames"), \
  }

/** Frame types */
#define PARAM_B_FRAME_STRATEGY \
  { \
    .name =        "ff_b_frame_strategy", \
    .real_name =   TRS("Avoid B-frames in high motion scenes"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .val_min =     { .val_int = 0 }, \
    .val_max =     { .val_int = 1 }, \
  }

#define PARAM_LUMA_ELIM_THRESHOLD \
  { \
    .name =        "ff_luma_elim_threshold", \
    .real_name =   TRS("Luma elimination threshold"),   \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int =  0 }, \
    .val_min =     { .val_int = -99 }, \
    .val_max =     { .val_int =  99 }, \
    .help_string = TRS("Single coefficient elimination threshold for luminance. \
Negative values also consider dc coefficient. -4 is JVT \
recommendation") \
  }
    
#define PARAM_CHROMA_ELIM_THRESHOLD \
  { \
    .name =        "ff_chroma_elim_threshold", \
    .real_name =   TRS("Chroma elimination threshold"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int =  0 }, \
    .val_min =     { .val_int = -99 }, \
    .val_max =     { .val_int =  99 }, \
    .help_string = TRS("Single coefficient elimination threshold for \
chrominamce. Negative values also consider dc \
coefficient. 7 is JVT recommendation") \
  }

#define PARAM_STRICT_STANDARD_COMPLIANCE \
  { \
    .name =        "ff_strict_std_compliance", \
    .real_name =   TRS("Standards compliance"), \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int =  0 }, \
    .val_min =     { .val_int = -2 }, \
    .val_max =     { .val_int =  2 }, \
    .help_string = TRS("2 = Strictly conform to a older more strict version of \
the spec or reference software\n \
1: Strictly conform to all the things in the spec no  \
matter what consequences\n \
0: Default\n \
-1: Allow inofficial extensions\n \
-2: Allow non standarized experimental things") \
  }

/** Quantizer */
#define PARAM_B_QUANT_OFFSET \
  { \
    .name =        "ff_b_quant_offset", \
    .real_name =   TRS("B quantizer offset"),   \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 1.25 }, \
    .val_min =     { .val_float = 0.0 }, \
    .val_max =     { .val_float = 31.0 }, \
    .num_digits =  2, \
    .help_string = TRS("Quantizer offset between B-frames and non-B-frames\n\
if > 0 then the last p frame quantizer will be used \
(q= lastp_q*factor+offset)\n \
if < 0 then normal ratecontrol will be done \
(q= -normal_q*factor+offset)\n") \
  }

/** Rate control */
#define PARAM_RC_MIN_RATE \
  { \
    .name =        "ff_rc_min_rate", \
    .real_name =   TRS("Minimum bitrate (kbps)"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .help_string = TRS("Minimum bitrate (0 means arbitrary)"),  \
  }

/** Rate control */
#define PARAM_RC_MAX_RATE \
  { \
    .name =        "ff_rc_max_rate", \
    .real_name =   TRS("Maximum bitrate (kbps)"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .help_string = TRS("Maximum bitrate (0 means arbitrary)"),  \
  }

/** Rate control */
#define PARAM_RC_BUFFER_SIZE \
  { \
    .name =        "ff_rc_buffer_size", \
    .real_name =   TRS("RC buffer size"),       \
    .type =        LQT_PARAMETER_INT, \
    .val_default = { .val_int = 0 }, \
    .help_string = TRS("Decoder bitstream buffer size in kbits. When encoding \
with max and/or min bitrate, this must be specified.") \
  }

/** Rate control */
#define PARAM_RC_BUFFER_AGGRESSIVITY \
  { \
    .name =        "ff_rc_buffer_aggressivity", \
    .real_name =   TRS("RC buffer aggressivity"),       \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = 1.0 }, \
    .val_min =     { .val_float = 0.01 }, \
    .val_max =     { .val_float = 99.0 }, \
    .num_digits =  2, \
  }

/** Quantizer */
#define PARAM_I_QUANT_FACTOR \
  { \
    .name =      "ff_i_quant_factor", \
    .real_name = TRS("I quantizer factor"),     \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float = -0.8 }, \
    .val_min =     { .val_float = -31.0 }, \
    .val_max =     { .val_float = 31.0 }, \
    .num_digits =  1, \
    .help_string = TRS("Quantizer factor between P-frames and I-frames.\n" \
                   "If > 0 then the last P frame quantizer will be used " \
                   "(q= lastp_q*factor+offset).\n" \
                   "If < 0 then normal ratecontrol will be done " \
                       "(q= -normal_q*factor+offset)\n"),         \
  }

/** Quantizer */
#define PARAM_I_QUANT_OFFSET \
  { \
    .name =        "ff_i_quant_offset", \
    .real_name =   TRS("I quantizer offset"),   \
    .type =        LQT_PARAMETER_FLOAT, \
    .val_default = { .val_float =  0.0 }, \
    .val_min =     { .val_float =  0.0 }, \
    .val_max =     { .val_float = 31.0 }, \
    .num_digits =  1, \
       .help_string = TRS("Quantizer offset between P-frames and I-frames"), \
  }

/** Rate control */
#define PARAM_RC_INITIAL_COMPLEX \
  { \
    .name =        "ff_rc_initial_cplx", \
    .real_name =   TRS("Initial RC complexity"),        \
    .type =        LQT_PARAMETER_FLOAT,\
    .val_default = { .val_float =  0.0 }, \
    .val_min =     { .val_float =  0.0 }, \
    .val_max =     { .val_float = 99.0 }, \
    .num_digits =  1, \
  }

/** Masking */
#define PARAM_LUMI_MASKING \
  { \
    .name =        "ff_lumi_masking", \
    .real_name =   TRS("Luminance 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 very bright image parts with reduced quality. " \
                       "0 means disabled, 0-0.3 is a sane range."),     \
  }

/** Masking */
#define PARAM_TEMPORAL_CPLX_MASKING \
  { \
    .name =        "ff_temporal_cplx_masking", \
    .real_name =   TRS("Temporary complexity 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 very fast moving image parts with reduced " \
                       "quality. 0 means disabled."),                   \
  }

/** Masking */
#define PARAM_SPATIAL_CPLX_MASKING \
  { \
    .name =        "ff_spatial_cplx_masking", \
    .real_name =   TRS("Spatial complexity 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 very complex image parts with reduced quality. " \
                       "0 means disabled, 0-0.5 is a sane range."),     \
  }

/** Masking */
#define PARAM_P_MASKING \
  { \
    .name =        "ff_p_masking", \
    .real_name =   TRS("Inter block 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 inter blocks with reduced quality (increases the " \
                   "quality of intra blocks). 0 means disabled, 1 will " \
                       "double the bits allocated for intra blocks."),  \
  }

/** Masking */
#define PARAM_DARK_MASKING \
  { \
    .name =        "ff_dark_masking", \
    .real_name =   TRS("Darkness 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 very dark image parts with reduced quality. " \
                       "0 means disabled, 0-0.3 is a sane range."),     \
  }

#define PARAM_PREDICTION_METHOD \
  { \
    .name =        "ff_prediction_method", \
    .real_name =   TRS("Precition method"),  \
    .type =        LQT_PARAMETER_STRINGLIST, \