Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 24 Aug 2011 18:26:48 +0000 (20:26 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 24 Aug 2011 18:26:48 +0000 (20:26 +0200)
* qatar/master:
  avconv: Replace goto redo on decode fail with continue.
  avconv: Remove dead store.
  libx264: add 'crf_max' private option.
  libx264: add 'weightp' private option.
  libx264: add 'rc_lookahead' private option.
  libx264: add 'psy_trellis' private option.
  libx264: add 'psy_rd' private option.
  libx264: add 'aq_strength' private option.
  libx264: add 'aq_mode' private option.
  libx264: add 'cqp' private option.
  libx264: add 'crf' private option.
  lavc: remove vbv_delay option
  lavf utils: Fix bad indentation.
  avconv: use av_clip_int16 for audio clipping

Conflicts:
libavcodec/libx264.c
libavcodec/options.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
avconv.c
libavcodec/avcodec.h
libavcodec/libx264.c
libavcodec/options.c
libavcodec/version.h
libavformat/utils.c

diff --cc avconv.c
+++ b/avconv.c
@@@ -2307,60 -2246,8 +2304,59 @@@ static int transcode(OutputFile *output
          int64_t ipts_min;
          double opts_min;
  
-     redo:
          ipts_min = INT64_MAX;
          opts_min= 1e100;
 +        /* if 'q' pressed, exits */
 +        if (!using_stdin) {
 +            if (q_pressed)
 +                break;
 +            /* read_key() returns 0 on EOF */
 +            key = read_key();
 +            if (key == 'q')
 +                break;
 +            if (key == '+') verbose++;
 +            if (key == '-') verbose--;
 +            if (key == 's') qp_hist     ^= 1;
 +            if (key == 'h'){
 +                if (do_hex_dump){
 +                    do_hex_dump = do_pkt_dump = 0;
 +                } else if(do_pkt_dump){
 +                    do_hex_dump = 1;
 +                } else
 +                    do_pkt_dump = 1;
 +                av_log_set_level(AV_LOG_DEBUG);
 +            }
 +            if (key == 'd' || key == 'D'){
 +                int debug=0;
 +                if(key == 'D') {
 +                    debug = input_streams[0].st->codec->debug<<1;
 +                    if(!debug) debug = 1;
 +                    while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
 +                        debug += debug;
 +                }else
 +                    scanf("%d", &debug);
 +                for(i=0;i<nb_input_streams;i++) {
 +                    input_streams[i].st->codec->debug = debug;
 +                }
 +                for(i=0;i<nb_output_streams;i++) {
 +                    ost = &output_streams[i];
 +                    ost->st->codec->debug = debug;
 +                }
 +                if(debug) av_log_set_level(AV_LOG_DEBUG);
 +                fprintf(stderr,"debug=%d\n", debug);
 +            }
 +            if (key == '?'){
 +                fprintf(stderr, "key    function\n"
 +                                "?      show this help\n"
 +                                "+      increase verbosity\n"
 +                                "-      decrease verbosity\n"
 +                                "D      cycle through available debug modes\n"
 +                                "h      dump packets/hex press to cycle through the 3 states\n"
 +                                "q      quit\n"
 +                                "s      Show QP histogram\n"
 +                );
 +            }
 +        }
  
          /* select the stream that we must read now by looking at the
             smallest output pts */
Simple merge
@@@ -39,11 -40,16 +40,20 @@@ typedef struct X264Context 
      char *preset;
      char *tune;
      char *profile;
 +    char *level;
      int fastfirstpass;
-     char *weightp;
 +    char *stats;
++    char *wpredp;
 +    char *x264opts;
+     float crf;
+     float crf_max;
+     int cqp;
+     int aq_mode;
+     float aq_strength;
+     float psy_rd;
+     float psy_trellis;
+     int rc_lookahead;
+     int weightp;
  } X264Context;
  
  static void X264_log(void *p, int level, const char *fmt, va_list args)
@@@ -316,8 -266,6 +320,8 @@@ static av_cold int X264_init(AVCodecCon
      x4->params.p_log_private        = avctx;
      x4->params.i_log_level          = X264_LOG_DEBUG;
  
-     OPT_STR("weightp", x4->weightp);
++    OPT_STR("weightp", x4->wpredp);
 +
      x4->params.b_intra_refresh      = avctx->flags2 & CODEC_FLAG2_INTRA_REFRESH;
      if (avctx->bit_rate) {
          x4->params.rc.i_bitrate   = avctx->bit_rate / 1000;
              x4->params.rc.i_rc_method   = X264_RC_CQP;
              x4->params.rc.i_qp_constant = avctx->cqp;
          }
+ #endif
+         if (x4->crf >= 0) {
+             x4->params.rc.i_rc_method   = X264_RC_CRF;
+             x4->params.rc.f_rf_constant = x4->crf;
+         } else if (x4->cqp >= 0) {
+             x4->params.rc.i_rc_method   = X264_RC_CQP;
+             x4->params.rc.i_qp_constant = x4->cqp;
+         }
+         if (x4->crf_max >= 0)
+             x4->params.rc.f_rf_constant_max = x4->crf_max;
      }
  
 +    OPT_STR("stats", x4->stats);
 +
      if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy &&
          (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
          x4->params.rc.f_vbv_buffer_init =
              (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
      }
  
 -    x4->params.rc.b_mb_tree               = !!(avctx->flags2 & CODEC_FLAG2_MBTREE);
 -    x4->params.rc.f_ip_factor             = 1 / fabs(avctx->i_quant_factor);
 -    x4->params.rc.f_pb_factor             = avctx->b_quant_factor;
 -    x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
 +    OPT_STR("level", x4->level);
 +
 +    if(x4->x264opts){
 +        const char *p= x4->x264opts;
 +        while(p){
 +            char param[256]={0}, val[256]={0};
 +            sscanf(p, "%255[^:=]=%255[^:]", param, val);
 +            OPT_STR(param, val);
 +            p= strchr(p, ':');
 +            p+=!!p;
 +        }
 +    }
  
+ #if FF_API_X264_GLOBAL_OPTS
+     if (avctx->aq_mode >= 0)
+         x4->params.rc.i_aq_mode = avctx->aq_mode;
+     if (avctx->aq_strength >= 0)
+         x4->params.rc.f_aq_strength = avctx->aq_strength;
+     if (avctx->psy_rd >= 0)
+         x4->params.analyse.f_psy_rd           = avctx->psy_rd;
+     if (avctx->psy_trellis >= 0)
+         x4->params.analyse.f_psy_trellis      = avctx->psy_trellis;
+     if (avctx->rc_lookahead >= 0)
+         x4->params.rc.i_lookahead             = avctx->rc_lookahead;
+     if (avctx->weighted_p_pred >= 0)
+         x4->params.analyse.i_weighted_pred    = avctx->weighted_p_pred;
+ #endif
+     if (x4->aq_mode >= 0)
+         x4->params.rc.i_aq_mode = x4->aq_mode;
+     if (x4->aq_strength >= 0)
+         x4->params.rc.f_aq_strength = x4->aq_strength;
+     if (x4->psy_rd >= 0)
+         x4->params.analyse.f_psy_rd = x4->psy_rd;
+     if (x4->psy_trellis >= 0)
+         x4->params.analyse.f_psy_trellis = x4->psy_trellis;
+     if (x4->rc_lookahead >= 0)
+         x4->params.rc.i_lookahead = x4->rc_lookahead;
+     if (x4->weightp >= 0)
+         x4->params.analyse.i_weighted_pred = x4->weightp;
      if (x4->fastfirstpass)
          x264_param_apply_fastfirstpass(&x4->params);
  
@@@ -431,10 -413,21 +480,25 @@@ static const AVOption options[] = 
      { "tune",          "Tune the encoding params (cf. x264 --fullhelp)",  OFFSET(tune),          FF_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
      { "profile",       "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile),       FF_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
      { "fastfirstpass", "Use fast settings when encoding first pass",      OFFSET(fastfirstpass), FF_OPT_TYPE_INT,    { 1 }, 0, 1, VE},
-     {"wpredp", "Weighted prediction for P-frames", OFFSET(weightp), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"level", "Specify level (as defined by Annex A)", OFFSET(level), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
++    {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"x264opts", "x264 options", OFFSET(x264opts), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
+     { "crf",           "Select the quality for constant quality mode",    OFFSET(crf),           FF_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE },
+     { "crf_max",       "In CRF mode, prevents VBV from lowering quality beyond this point.",OFFSET(crf_max), FF_OPT_TYPE_FLOAT, {-1 }, -1, FLT_MAX, VE },
+     { "cqp",           "Constant quantization parameter rate control method",OFFSET(cqp),        FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE },
+     { "aq_mode",       "AQ method",                                       OFFSET(aq_mode),       FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "aq_mode"},
+     { "none",          NULL,                              0, FF_OPT_TYPE_CONST, {X264_AQ_NONE},         INT_MIN, INT_MAX, VE, "aq_mode" },
+     { "variance",      "Variance AQ (complexity mask)",   0, FF_OPT_TYPE_CONST, {X264_AQ_VARIANCE},     INT_MIN, INT_MAX, VE, "aq_mode" },
+     { "autovariance",  "Auto-variance AQ (experimental)", 0, FF_OPT_TYPE_CONST, {X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
+     { "aq_strength",   "AQ strength. Reduces blocking and blurring in flat and textured areas.", OFFSET(aq_strength), FF_OPT_TYPE_FLOAT, {-1}, -1, FLT_MAX, VE},
+     { "pdy_rd",        "Psy RD strength.",                                OFFSET(psy_rd),        FF_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE},
+     { "psy_trellis",   "Psy trellis strength",                            OFFSET(psy_trellis),   FF_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE},
+     { "rc_lookahead",  "Number of frames to look ahead for frametype and ratecontrol", OFFSET(rc_lookahead), FF_OPT_TYPE_INT, {-1 }, -1, INT_MAX, VE },
+     { "weightp",       "Weighted prediction analysis method.",            OFFSET(weightp),       FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "weightp" },
+     { "none",          NULL, 0, FF_OPT_TYPE_CONST, {X264_WEIGHTP_NONE},   INT_MIN, INT_MAX, VE, "weightp" },
+     { "simple",        NULL, 0, FF_OPT_TYPE_CONST, {X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
+     { "smart",         NULL, 0, FF_OPT_TYPE_CONST, {X264_WEIGHTP_SMART},  INT_MIN, INT_MAX, VE, "weightp" },
      { NULL },
  };
  
@@@ -375,10 -377,12 +377,12 @@@ static const AVOption options[]=
  {"all"             , NULL, 0, FF_OPT_TYPE_CONST, {.dbl = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), FF_OPT_TYPE_INT, {.dbl = 1 }, 0, 4, V|E},
  {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, 10, V|E},
 -{"crf", "enables constant quality mode, and selects the quality (x264)", OFFSET(crf), FF_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 51, V|E},
+ #if FF_API_X264_GLOBAL_OPTS
 +{"crf", "enables constant quality mode, and selects the quality (x264/VP8)", OFFSET(crf), FF_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 63, V|E},
  {"cqp", "constant quantization parameter rate control method", OFFSET(cqp), FF_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, V|E},
 -{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), FF_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 -{"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs), FF_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
+ #endif
 +{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), FF_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 +{"refs", "reference frames to consider for motion compensation", OFFSET(refs), FF_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
  {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"bframebias", "influences how often B-frames are used", OFFSET(bframebias), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
Simple merge
Simple merge