Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 10 Oct 2011 01:41:49 +0000 (03:41 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 10 Oct 2011 01:50:58 +0000 (03:50 +0200)
* qatar/master:
  mpeg4dec: use unsigned type for startcode in ff_mpeg4_decode_picture_header
  mpeg124: use sign_extend() function
  ac3dec: use get_sbits() instead of manually sign-extending
  4xm: fix signed overflow
  wmavoice: fix a signed overflow
  mpegvideo_enc: fix a signed overflow
  crc: fix signed overflow
  fate: run avconv with -nostats flag
  avtools: add -v as alias for -loglevel
  avconv: always print stats with AV_LOG_INFO
  doc/avconv: add forgotten output/per-stream info to -filter
  avconv: add -stats option to enable/disable printing encoding progress
  avconv: in output_packet() don't set decoded_data_size for video.
  avconv: remove pointless always true condition
  avconv: factorize common code in transcode_init()
  zmbv: remove memcpy() of decoded frame
  mpeg12enc: use sign_extend() function
  h264pred: use unsigned types for pixel values, fix signed overflows
  h264: fix signed overflows in x*0x01010101 expressions
  h264pred: remove unused variables

Conflicts:
avconv.c
tests/fate-run.sh

Merged-by: Michael Niedermayer <michaelni@gmx.at>
23 files changed:
1  2 
avconv.c
cmdutils.c
cmdutils_common_opts.h
doc/avconv.texi
doc/avtools-common-opts.texi
ffmpeg.c
libavcodec/4xm.c
libavcodec/ac3dec.c
libavcodec/h264.c
libavcodec/h264_mvpred.h
libavcodec/h264pred.c
libavcodec/h264pred_template.c
libavcodec/ituh263dec.c
libavcodec/ituh263enc.c
libavcodec/mpeg12.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videodec.c
libavcodec/mpegvideo_enc.c
libavcodec/wmavoice.c
libavcodec/zmbv.c
libavutil/crc.c
tests/fate-run.sh
tests/regression-funcs.sh

diff --cc avconv.c
+++ b/avconv.c
@@@ -1368,12 -1311,13 +1370,15 @@@ static void print_report(OutputFile *ou
      int64_t total_size;
      AVCodecContext *enc;
      int frame_number, vid, i;
 -    double bitrate, ti1, pts;
 +    double bitrate;
 +    int64_t pts = INT64_MAX;
      static int64_t last_time = -1;
      static int qp_histogram[52];
 +    int hours, mins, secs, us;
  
+     if (!print_stats && !is_last_report)
+         return;
      if (!is_last_report) {
          int64_t cur_time;
          /* display the report every 0.5 seconds */
@@@ -2221,8 -2161,7 +2221,8 @@@ static int transcode_init(OutputFile *o
                  break;
              }
              /* two pass mode */
-             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
 -            if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
++            if (codec->codec_id != CODEC_ID_H264 &&
 +                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                  char logfilename[1024];
                  FILE *f;
  
diff --cc cmdutils.c
Simple merge
@@@ -1,14 -1,15 +1,15 @@@
 -    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
 -    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
 -    { "?", OPT_EXIT, {(void*)show_help}, "show help" },
 -    { "help", OPT_EXIT, {(void*)show_help}, "show help" },
 -    { "-help", OPT_EXIT, {(void*)show_help}, "show help" },
 -    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
 -    { "formats"  , OPT_EXIT, {(void*)show_formats  }, "show available formats" },
 -    { "codecs"   , OPT_EXIT, {(void*)show_codecs   }, "show available codecs" },
 -    { "bsfs"     , OPT_EXIT, {(void*)show_bsfs     }, "show available bit stream filters" },
 -    { "protocols", OPT_EXIT, {(void*)show_protocols}, "show available protocols" },
 -    { "filters",   OPT_EXIT, {(void*)show_filters  }, "show available filters" },
 -    { "pix_fmts" , OPT_EXIT, {(void*)show_pix_fmts }, "show available pixel formats" },
 +    { "L", OPT_EXIT, {(void*)opt_license}, "show license" },
 +    { "h", OPT_EXIT, {(void*)opt_help}, "show help" },
 +    { "?", OPT_EXIT, {(void*)opt_help}, "show help" },
 +    { "help", OPT_EXIT, {(void*)opt_help}, "show help" },
 +    { "-help", OPT_EXIT, {(void*)opt_help}, "show help" },
 +    { "version", OPT_EXIT, {(void*)opt_version}, "show version" },
 +    { "formats"  , OPT_EXIT, {(void*)opt_formats  }, "show available formats" },
 +    { "codecs"   , OPT_EXIT, {(void*)opt_codecs   }, "show available codecs" },
 +    { "bsfs"     , OPT_EXIT, {(void*)opt_bsfs     }, "show available bit stream filters" },
 +    { "protocols", OPT_EXIT, {(void*)opt_protocols}, "show available protocols" },
 +    { "filters",   OPT_EXIT, {(void*)opt_filters  }, "show available filters" },
 +    { "pix_fmts" , OPT_EXIT, {(void*)opt_pix_fmts }, "show available pixel formats" },
      { "sample_fmts", OPT_EXIT, {.func_arg = show_sample_fmts }, "show available audio sample formats" },
      { "loglevel", HAS_ARG, {(void*)opt_loglevel}, "set libav* logging level", "loglevel" },
+     { "v", HAS_ARG, {(void*)opt_loglevel}, "set libav* logging level", "loglevel" },
diff --cc doc/avconv.texi
Simple merge
Simple merge
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -156,6 -221,11 +156,8 @@@ static int input_sync
  
  static float dts_delta_threshold = 10;
  
 -static int64_t timer_start;
++static int print_stats = 1;
  static uint8_t *audio_buf;
  static uint8_t *audio_out;
  static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
@@@ -1374,13 -1328,14 +1376,16 @@@ static void print_report(OutputFile *ou
      int64_t total_size;
      AVCodecContext *enc;
      int frame_number, vid, i;
 -    double bitrate, ti1, pts;
 +    double bitrate;
 +    int64_t pts = INT64_MAX;
      static int64_t last_time = -1;
      static int qp_histogram[52];
 +    int hours, mins, secs, us;
 +
++    if (!print_stats && !is_last_report)
++        return;
      if (!is_last_report) {
 -        int64_t cur_time;
 -        /* display the report every 0.5 seconds */
 -        cur_time = av_gettime();
          if (last_time == -1) {
              last_time = cur_time;
              return;
              vid = 1;
          }
          /* compute min output value */
 -        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
 -        if ((pts < ti1) && (pts > 0))
 -            ti1 = pts;
 +        pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
 +                                      ost->st->time_base, AV_TIME_BASE_Q));
      }
 -    if (ti1 < 0.01)
 -        ti1 = 0.01;
  
 -    if (verbose > 0 || is_last_report) {
 -        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 +    secs = pts / AV_TIME_BASE;
 +    us = pts % AV_TIME_BASE;
 +    mins = secs / 60;
 +    secs %= 60;
 +    hours = mins / 60;
 +    mins %= 60;
  
 -        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 -            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
 -            (double)total_size / 1024, ti1, bitrate);
 +    bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
  
 -        if (nb_frames_dup || nb_frames_drop)
 -          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
 -                  nb_frames_dup, nb_frames_drop);
 +    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 +             "size=%8.0fkB time=", total_size / 1024.0);
 +    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 +             "%02d:%02d:%02d.%02d ", hours, mins, secs,
 +             (100 * us) / AV_TIME_BASE);
 +    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 +             "bitrate=%6.1fkbits/s", bitrate);
  
 -        if (verbose >= 0)
 -            fprintf(stderr, "%s    \r", buf);
 +    if (nb_frames_dup || nb_frames_drop)
 +        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
 +                nb_frames_dup, nb_frames_drop);
  
-     av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s    \r", buf);
 -        fflush(stderr);
 -    }
++    av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
 +
 +    fflush(stderr);
  
 -    if (is_last_report && verbose >= 0){
 +    if (is_last_report{
          int64_t raw= audio_size + video_size + extra_size;
 -        fprintf(stderr, "\n");
 -        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
 -                video_size/1024.0,
 -                audio_size/1024.0,
 -                extra_size/1024.0,
 -                100.0*(total_size - raw)/raw
 +        av_log(NULL, AV_LOG_INFO, "\n");
 +        av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
 +               video_size/1024.0,
 +               audio_size/1024.0,
 +               extra_size/1024.0,
 +               100.0*(total_size - raw)/raw
          );
      }
  }
@@@ -1671,9 -1537,9 +1676,8 @@@ static int output_packet(InputStream *i
                      (ist->st->codec->sample_rate * ist->st->codec->channels);
                  break;}
              case AVMEDIA_TYPE_VIDEO:
--                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
 -                    /* XXX: allocate picture correctly */
 -                    avcodec_get_frame_defaults(&picture);
 +                    if (!(decoded_frame = avcodec_alloc_frame()))
 +                        return AVERROR(ENOMEM);
                      avpkt.pts = pkt_pts;
                      avpkt.dts = ist->pts;
                      pkt_pts = AV_NOPTS_VALUE;
@@@ -2143,6 -2157,6 +2147,8 @@@ static int transcode_init(OutputFile *o
          } else {
              if (!ost->enc)
                  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
++            ist->decoding_needed = 1;
++            ost->encoding_needed = 1;
              switch(codec->codec_type) {
              case AVMEDIA_TYPE_AUDIO:
                  ost->fifo= av_fifo_alloc(1024);
                  if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
                      codec->channel_layout = 0;
                  ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
 +                ost->audio_resample |=    codec->sample_fmt     != icodec->sample_fmt
 +                                       || codec->channel_layout != icodec->channel_layout;
                  icodec->request_channels = codec->channels;
--                ist->decoding_needed = 1;
--                ost->encoding_needed = 1;
                  ost->resample_sample_fmt  = icodec->sample_fmt;
                  ost->resample_sample_rate = icodec->sample_rate;
                  ost->resample_channels    = icodec->channels;
                  ost->resample_height = icodec->height;
                  ost->resample_width  = icodec->width;
                  ost->resample_pix_fmt= icodec->pix_fmt;
--                ost->encoding_needed = 1;
--                ist->decoding_needed = 1;
  
                  if (!ost->frame_rate.num)
                      ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
  #endif
                  break;
              case AVMEDIA_TYPE_SUBTITLE:
--                ost->encoding_needed = 1;
--                ist->decoding_needed = 1;
                  break;
              default:
                  abort();
                  break;
              }
              /* two pass mode */
-             if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
 -            if (ost->encoding_needed &&
++            if (codec->codec_id != CODEC_ID_H264 &&
                  (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                  char logfilename[1024];
                  FILE *f;
@@@ -2716,15 -2737,42 +2716,9 @@@ static int transcode(OutputFile *output
      return ret;
  }
  
 -static int opt_format(const char *opt, const char *arg)
 -{
 -    last_asked_format = arg;
 -    return 0;
 -}
 -
 -static int opt_video_rc_override_string(const char *opt, const char *arg)
 -{
 -    video_rc_override_string = arg;
 -    return 0;
 -}
 -
 -static int opt_me_threshold(const char *opt, const char *arg)
 -{
 -    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 -    return 0;
 -}
 -
--static int opt_verbose(const char *opt, const char *arg)
--{
-     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
 -    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
 -    return 0;
 -}
 -
 -static int opt_frame_rate(const char *opt, const char *arg)
 -{
 -    if (av_parse_video_rate(&frame_rate, arg) < 0) {
 -        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
 -        exit_program(1);
 -    }
--    return 0;
--}
--
  static int opt_frame_crop(const char *opt, const char *arg)
  {
 -    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
 +    av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
      return AVERROR(EINVAL);
  }
  
@@@ -4262,11 -4245,12 +4256,10 @@@ static const OptionDef options[] = 
        "dump each input packet" },
      { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
        "when dumping packets, also dump the payload" },
 -    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
 +    { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
      { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
      { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
-     { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
 -    { "v", HAS_ARG, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
 -    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
 -    { "threads",  HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
 +    { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
      { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
      { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
      { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
      { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
      { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
      { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
 -    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
      { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
      { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
 +    { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
 +    { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
 +    { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
 +    { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
 +#if CONFIG_AVFILTER
 +    { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
 +#endif
++    { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
  
      /* video options */
 -    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
 -    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
 -    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
 -    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
 -    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
 -    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
 +    { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
 +    { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
 +    { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
 +    { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
 +    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
 +    { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc libavutil/crc.c
Simple merge
@@@ -51,7 -50,7 +51,7 @@@ run()
  }
  
  avconv(){
-     run $tool -v 0 -threads $threads -thread_type $thread_type "$@"
 -    run avconv -nostats -threads $threads -thread_type $thread_type "$@"
++    run $tool -nostats -threads $threads -thread_type $thread_type "$@"
  }
  
  framecrc(){
Simple merge