Description:

source/libvpx/vpxenc.c

 /*
  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "vpx_config.h"
 
-#if defined(_WIN32) || !CONFIG_OS_SUPPORT
+#if defined(_WIN32) || defined(__OS2__) || !CONFIG_OS_SUPPORT
 #define USE_POSIX_MMAP 0
 #else
 #define USE_POSIX_MMAP 1
 #endif
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <limits.h>
@@ skipping 16 matching lines @@
 #if CONFIG_VP8_DECODER || CONFIG_VP9_DECODER
 #include "vpx/vp8dx.h"
 #endif
 
 #include "vpx_ports/mem_ops.h"
 #include "vpx_ports/vpx_timer.h"
 #include "tools_common.h"
 #include "y4minput.h"
 #include "libmkv/EbmlWriter.h"
 #include "libmkv/EbmlIDs.h"
+#include "third_party/libyuv/include/libyuv/scale.h"
 
 /* Need special handling of these functions on Windows */
 #if defined(_MSC_VER)
 /* MSVS doesn't define off_t, and uses _f{seek,tell}i64 */
 typedef __int64 off_t;
 #define fseeko _fseeki64
 #define ftello _ftelli64
 #elif defined(_WIN32)
 /* MinGW defines off_t as long
    and uses f{seek,tell}o64/off64_t for large files */
@@ skipping 72 matching lines @@
   LOG_ERROR("Fatal");
   exit(EXIT_FAILURE);
 }
 
 
 void warn(const char *fmt, ...) {
   LOG_ERROR("Warning");
 }
 
 
-static void ctx_exit_on_error(vpx_codec_ctx_t *ctx, const char *s, ...) {
-  va_list ap;
-
-  va_start(ap, s);
+static void warn_or_exit_on_errorv(vpx_codec_ctx_t *ctx, int fatal,
+                                   const char *s, va_list ap) {
   if (ctx->err) {
     const char *detail = vpx_codec_error_detail(ctx);
 
     vfprintf(stderr, s, ap);
     fprintf(stderr, ": %s\n", vpx_codec_error(ctx));
 
     if (detail)
       fprintf(stderr, "    %s\n", detail);
 
-    exit(EXIT_FAILURE);
+    if (fatal)
+      exit(EXIT_FAILURE);
   }
 }
 
+static void ctx_exit_on_error(vpx_codec_ctx_t *ctx, const char *s, ...) {
+  va_list ap;
+
+  va_start(ap, s);
+  warn_or_exit_on_errorv(ctx, 1, s, ap);
+  va_end(ap);
+}
+
+static void warn_or_exit_on_error(vpx_codec_ctx_t *ctx, int fatal,
+                                  const char *s, ...) {
+  va_list ap;
+
+  va_start(ap, s);
+  warn_or_exit_on_errorv(ctx, fatal, s, ap);
+  va_end(ap);
+}
+
 /* This structure is used to abstract the different ways of handling
  * first pass statistics.
  */
 typedef struct {
   vpx_fixed_buf_t buf;
   int             pass;
   FILE           *file;
   char           *buf_ptr;
   size_t          buf_alloc_sz;
 } stats_io_t;
@@ skipping 125 matching lines @@
 struct detect_buffer {
   char buf[4];
   size_t buf_read;
   size_t position;
 };
 
 
 struct input_state {
   char                 *fn;
   FILE                 *file;
+  off_t                 length;
   y4m_input             y4m;
   struct detect_buffer  detect;
   enum video_file_type  file_type;
   unsigned int          w;
   unsigned int          h;
   struct vpx_rational   framerate;
   int                   use_i420;
 };
 
 
@@ skipping 628 matching lines @@
 static const arg_def_t good_dl          = ARG_DEF(NULL, "good", 0,
                                                   "Use Good Quality Deadline");
 static const arg_def_t rt_dl            = ARG_DEF(NULL, "rt", 0,
                                                   "Use Realtime Quality Deadline");
 static const arg_def_t quietarg         = ARG_DEF("q", "quiet", 0,
                                                   "Do not print encode progress");
 static const arg_def_t verbosearg       = ARG_DEF("v", "verbose", 0,
                                                   "Show encoder parameters");
 static const arg_def_t psnrarg          = ARG_DEF(NULL, "psnr", 0,
                                                   "Show PSNR in status line");
-static const arg_def_t recontest        = ARG_DEF(NULL, "test-decode", 0,
-                                                  "Test encode/decode mismatch");
+enum TestDecodeFatality {
+  TEST_DECODE_OFF,
+  TEST_DECODE_FATAL,
+  TEST_DECODE_WARN,
+};
+static const struct arg_enum_list test_decode_enum[] = {
+  {"off",   TEST_DECODE_OFF},
+  {"fatal", TEST_DECODE_FATAL},
+  {"warn",  TEST_DECODE_WARN},
+  {NULL, 0}
+};
+static const arg_def_t recontest = ARG_DEF_ENUM(NULL, "test-decode", 1,
+                                                "Test encode/decode mismatch",
+                                                test_decode_enum);
 static const arg_def_t framerate        = ARG_DEF(NULL, "fps", 1,
                                                   "Stream frame rate (rate/scale)");
 static const arg_def_t use_ivf          = ARG_DEF(NULL, "ivf", 0,
                                                   "Output IVF (default is WebM)");
 static const arg_def_t out_part = ARG_DEF("P", "output-partitions", 0,
                                           "Makes encoder output partitions. Requires IVF output!");
 static const arg_def_t q_hist_n         = ARG_DEF(NULL, "q-hist", 1,
                                                   "Show quantizer histogram (n-buckets)");
 static const arg_def_t rate_hist_n         = ARG_DEF(NULL, "rate-hist", 1,
                                                      "Show rate histogram (n-buckets)");
@@ skipping 594 matching lines @@
   int                       passes;
   int                       pass;
   int                       usage;
   int                       deadline;
   int                       use_i420;
   int                       quiet;
   int                       verbose;
   int                       limit;
   int                       skip_frames;
   int                       show_psnr;
-  int                       test_decode;
+  enum TestDecodeFatality   test_decode;
   int                       have_framerate;
   struct vpx_rational       framerate;
   int                       out_part;
   int                       debug;
   int                       show_q_hist_buckets;
   int                       show_rate_hist_buckets;
 };
 
 
 /* Per-stream configuration */
@@ skipping 20 matching lines @@
   uint64_t                  psnr_sse_total;
   uint64_t                  psnr_samples_total;
   double                    psnr_totals[4];
   int                       psnr_count;
   int                       counts[64];
   vpx_codec_ctx_t           encoder;
   unsigned int              frames_out;
   uint64_t                  cx_time;
   size_t                    nbytes;
   stats_io_t                stats;
+  struct vpx_image         *img;
   vpx_codec_ctx_t           decoder;
   vpx_ref_frame_t           ref_enc;
   vpx_ref_frame_t           ref_dec;
   int                       mismatch_seen;
 };
 
 
 void validate_positive_rational(const char          *msg,
                                 struct vpx_rational *rat) {
   if (rat->den < 0) {
@@ skipping 64 matching lines @@
       global->quiet = 1;
     else if (arg_match(&arg, &verbosearg, argi))
       global->verbose = 1;
     else if (arg_match(&arg, &limit, argi))
       global->limit = arg_parse_uint(&arg);
     else if (arg_match(&arg, &skip, argi))
       global->skip_frames = arg_parse_uint(&arg);
     else if (arg_match(&arg, &psnrarg, argi))
       global->show_psnr = 1;
     else if (arg_match(&arg, &recontest, argi))
-      global->test_decode = 1;
+      global->test_decode = arg_parse_enum_or_int(&arg);
     else if (arg_match(&arg, &framerate, argi)) {
       global->framerate = arg_parse_rational(&arg);
       validate_positive_rational(arg.name, &global->framerate);
       global->have_framerate = 1;
     } else if (arg_match(&arg, &out_part, argi))
       global->out_part = 1;
     else if (arg_match(&arg, &debugmode, argi))
       global->debug = 1;
     else if (arg_match(&arg, &q_hist_n, argi))
       global->show_q_hist_buckets = arg_parse_uint(&arg);
@@ skipping 19 matching lines @@
 void open_input_file(struct input_state *input) {
   unsigned int fourcc;
 
   /* Parse certain options from the input file, if possible */
   input->file = strcmp(input->fn, "-") ? fopen(input->fn, "rb")
                 : set_binary_mode(stdin);
 
   if (!input->file)
     fatal("Failed to open input file");
 
+  if (!fseeko(input->file, 0, SEEK_END)) {
+    /* Input file is seekable. Figure out how long it is, so we can get
+     * progress info.
+     */
+    input->length = ftello(input->file);
+    rewind(input->file);
+  }
+
   /* For RAW input sources, these bytes will applied on the first frame
    *  in read_frame().
    */
   input->detect.buf_read = fread(input->detect.buf, 1, 4, input->file);
   input->detect.position = 0;
 
   if (input->detect.buf_read == 4
       && file_is_y4m(input->file, &input->y4m, input->detect.buf)) {
     if (y4m_input_open(&input->y4m, input->file, input->detect.buf, 4) >= 0) {
       input->file_type = FILE_TYPE_Y4M;
@@ skipping 263 matching lines @@
         fatal("Stream %d: duplicate stats file (from stream %d)",
               streami->index, stream->index);
     }
   }
 }
 
 
 static void set_stream_dimensions(struct stream_state *stream,
                                   unsigned int w,
                                   unsigned int h) {
-  if ((stream->config.cfg.g_w && stream->config.cfg.g_w != w)
-      || (stream->config.cfg.g_h && stream->config.cfg.g_h != h))
-    fatal("Stream %d: Resizing not yet supported", stream->index);
-  stream->config.cfg.g_w = w;
-  stream->config.cfg.g_h = h;
+  if (!stream->config.cfg.g_w) {
+    if (!stream->config.cfg.g_h)
+      stream->config.cfg.g_w = w;
+    else
+      stream->config.cfg.g_w = w * stream->config.cfg.g_h / h;
+  }
+  if (!stream->config.cfg.g_h) {
+    stream->config.cfg.g_h = h * stream->config.cfg.g_w / w;
+  }
 }
 
 
 static void set_default_kf_interval(struct stream_state  *stream,
                                     struct global_config *global) {
   /* Use a max keyframe interval of 5 seconds, if none was
    * specified on the command line.
    */
   if (!stream->config.have_kf_max_dist) {
     double framerate = (double)global->framerate.num / global->framerate.den;
@@ skipping 139 matching lines @@
     int ctrl = stream->config.arg_ctrls[i][0];
     int value = stream->config.arg_ctrls[i][1];
     if (vpx_codec_control_(&stream->encoder, ctrl, value))
       fprintf(stderr, "Error: Tried to set control %d = %d\n",
               ctrl, value);
 
     ctx_exit_on_error(&stream->encoder, "Failed to control codec");
   }
 
 #if CONFIG_DECODERS
-  if (global->test_decode) {
+  if (global->test_decode != TEST_DECODE_OFF) {
     int width, height;
 
     vpx_codec_dec_init(&stream->decoder, global->codec->dx_iface(), NULL, 0);
 
     width = (stream->config.cfg.g_w + 15) & ~15;
     height = (stream->config.cfg.g_h + 15) & ~15;
     vpx_img_alloc(&stream->ref_enc.img, VPX_IMG_FMT_I420, width, height, 1);
     vpx_img_alloc(&stream->ref_dec.img, VPX_IMG_FMT_I420, width, height, 1);
     stream->ref_enc.frame_type = VP8_LAST_FRAME;
     stream->ref_dec.frame_type = VP8_LAST_FRAME;
   }
 #endif
 }
 
 
 static void encode_frame(struct stream_state  *stream,
                          struct global_config *global,
                          struct vpx_image     *img,
                          unsigned int          frames_in) {
   vpx_codec_pts_t frame_start, next_frame_start;
   struct vpx_codec_enc_cfg *cfg = &stream->config.cfg;
   struct vpx_usec_timer timer;
 
   frame_start = (cfg->g_timebase.den * (int64_t)(frames_in - 1)
                  * global->framerate.den)
                 / cfg->g_timebase.num / global->framerate.num;
   next_frame_start = (cfg->g_timebase.den * (int64_t)(frames_in)
                       * global->framerate.den)
                      / cfg->g_timebase.num / global->framerate.num;
+
+  /* Scale if necessary */
+  if (img && (img->d_w != cfg->g_w || img->d_h != cfg->g_h)) {
+    if (!stream->img)
+      stream->img = vpx_img_alloc(NULL, VPX_IMG_FMT_I420,
+                                  cfg->g_w, cfg->g_h, 16);
+    I420Scale(img->planes[VPX_PLANE_Y], img->stride[VPX_PLANE_Y],
+              img->planes[VPX_PLANE_U], img->stride[VPX_PLANE_U],
+              img->planes[VPX_PLANE_V], img->stride[VPX_PLANE_V],
+              img->d_w, img->d_h,
+              stream->img->planes[VPX_PLANE_Y],
+              stream->img->stride[VPX_PLANE_Y],
+              stream->img->planes[VPX_PLANE_U],
+              stream->img->stride[VPX_PLANE_U],
+              stream->img->planes[VPX_PLANE_V],
+              stream->img->stride[VPX_PLANE_V],
+              stream->img->d_w, stream->img->d_h,
+              kFilterBox);
+
+    img = stream->img;
+  }
+
   vpx_usec_timer_start(&timer);
   vpx_codec_encode(&stream->encoder, img, frame_start,
                    (unsigned long)(next_frame_start - frame_start),
                    0, global->deadline);
   vpx_usec_timer_mark(&timer);
   stream->cx_time += vpx_usec_timer_elapsed(&timer);
   ctx_exit_on_error(&stream->encoder, "Stream %d: Failed to encode frame",
                     stream->index);
 }
 
@@ skipping 19 matching lines @@
   *got_data = 0;
   while ((pkt = vpx_codec_get_cx_data(&stream->encoder, &iter))) {
     static size_t fsize = 0;
     static off_t ivf_header_pos = 0;
 
     switch (pkt->kind) {
       case VPX_CODEC_CX_FRAME_PKT:
         if (!(pkt->data.frame.flags & VPX_FRAME_IS_FRAGMENT)) {
           stream->frames_out++;
         }
-        if (!global->quiet)
-          fprintf(stderr, " %6luF",
-                  (unsigned long)pkt->data.frame.sz);
 
         update_rate_histogram(&stream->rate_hist, cfg, pkt);
         if (stream->config.write_webm) {
           /* Update the hash */
           if (!stream->ebml.debug)
             stream->hash = murmur(pkt->data.frame.buf,
                                   (int)pkt->data.frame.sz,
                                   stream->hash);
 
           write_webm_block(&stream->ebml, cfg, pkt);
@@ skipping 14 matching lines @@
             }
           }
 
           (void) fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz,
                         stream->file);
         }
         stream->nbytes += pkt->data.raw.sz;
 
         *got_data = 1;
 #if CONFIG_DECODERS
-        if (global->test_decode) {
+        if (global->test_decode != TEST_DECODE_OFF && !stream->mismatch_seen) {
           vpx_codec_decode(&stream->decoder, pkt->data.frame.buf,
                            pkt->data.frame.sz, NULL, 0);
-          ctx_exit_on_error(&stream->decoder, "Failed to decode frame");
+          if (stream->decoder.err) {
+            warn_or_exit_on_error(&stream->decoder,
+                                  global->test_decode == TEST_DECODE_FATAL,
+                                  "Failed to decode frame %d in stream %d",
+                                  stream->frames_out + 1, stream->index);
+            stream->mismatch_seen = stream->frames_out + 1;
+          }
         }
 #endif
         break;
       case VPX_CODEC_STATS_PKT:
         stream->frames_out++;
-        if (!global->quiet)
-          fprintf(stderr, " %6luS",
-                  (unsigned long)pkt->data.twopass_stats.sz);
         stats_write(&stream->stats,
                     pkt->data.twopass_stats.buf,
                     pkt->data.twopass_stats.sz);
         stream->nbytes += pkt->data.raw.sz;
         break;
       case VPX_CODEC_PSNR_PKT:
 
         if (global->show_psnr) {
           int i;
 
           stream->psnr_sse_total += pkt->data.psnr.sse[0];
           stream->psnr_samples_total += pkt->data.psnr.samples[0];
           for (i = 0; i < 4; i++) {
-            if (!global->quiet)
-              fprintf(stderr, "%.3f ", pkt->data.psnr.psnr[i]);
             stream->psnr_totals[i] += pkt->data.psnr.psnr[i];
           }
           stream->psnr_count++;
         }
 
         break;
       default:
         break;
     }
   }
@@ skipping 12 matching lines @@
                         (double)stream->psnr_sse_total);
   fprintf(stderr, " %.3f", ovpsnr);
 
   for (i = 0; i < 4; i++) {
     fprintf(stderr, " %.3f", stream->psnr_totals[i] / stream->psnr_count);
   }
   fprintf(stderr, "\n");
 }
 
 
-float usec_to_fps(uint64_t usec, unsigned int frames) {
+static float usec_to_fps(uint64_t usec, unsigned int frames) {
   return (float)(usec > 0 ? frames * 1000000.0 / (float)usec : 0);
 }
 
 
-static void test_decode(struct stream_state  *stream) {
+static void test_decode(struct stream_state  *stream,
+                        enum TestDecodeFatality fatal) {
+  if (stream->mismatch_seen)
+    return;
+
   vpx_codec_control(&stream->encoder, VP8_COPY_REFERENCE, &stream->ref_enc);
   ctx_exit_on_error(&stream->encoder, "Failed to get encoder reference frame");
   vpx_codec_control(&stream->decoder, VP8_COPY_REFERENCE, &stream->ref_dec);
   ctx_exit_on_error(&stream->decoder, "Failed to get decoder reference frame");
 
-  if (!stream->mismatch_seen
-      && !compare_img(&stream->ref_enc.img, &stream->ref_dec.img)) {
-    /* TODO(jkoleszar): make fatal. */
+  if (!compare_img(&stream->ref_enc.img, &stream->ref_dec.img)) {
     int y[2], u[2], v[2];
     find_mismatch(&stream->ref_enc.img, &stream->ref_dec.img,
                   y, u, v);
-    warn("Stream %d: Encode/decode mismatch on frame %d"
-         " at Y[%d, %d], U[%d, %d], V[%d, %d]",
-         stream->index, stream->frames_out,
-         y[0], y[1], u[0], u[1], v[0], v[1]);
+    warn_or_exit_on_error(&stream->decoder, fatal == TEST_DECODE_FATAL,
+                          "Stream %d: Encode/decode mismatch on frame %d"
+                          " at Y[%d, %d], U[%d, %d], V[%d, %d]",
+                          stream->index, stream->frames_out,
+                          y[0], y[1], u[0], u[1], v[0], v[1]);
     stream->mismatch_seen = stream->frames_out;
   }
 }
 
+
+static void print_time(const char *label, int64_t etl) {
+  int hours, mins, secs;
+
+  if (etl >= 0) {
+    hours = etl / 3600;
+    etl -= hours * 3600;
+    mins = etl / 60;
+    etl -= mins * 60;
+    secs = etl;
+
+    fprintf(stderr, "[%3s %2d:%02d:%02d] ",
+            label, hours, mins, secs);
+  } else {
+    fprintf(stderr, "[%3s  unknown] ", label);
+  }
+}
+
 int main(int argc, const char **argv_) {
   int                    pass;
   vpx_image_t            raw;
   int                    frame_avail, got_data;
 
   struct input_state       input = {0};
   struct global_config     global;
   struct stream_state     *streams = NULL;
   char                   **argv, **argi;
-  unsigned long            cx_time = 0;
+  uint64_t                 cx_time = 0;
   int                      stream_cnt = 0;
+  int                      res = 0;
 
   exec_name = argv_[0];
 
   if (argc < 3)
     usage_exit();
 
   /* Setup default input stream settings */
   input.framerate.num = 30;
   input.framerate.den = 1;
   input.use_i420 = 1;
@@ skipping 25 matching lines @@
     if (argi[0][0] == '-' && argi[0][1])
       die("Error: Unrecognized option %s\n", *argi);
 
   /* Handle non-option arguments */
   input.fn = argv[0];
 
   if (!input.fn)
     usage_exit();
 
   for (pass = global.pass ? global.pass - 1 : 0; pass < global.passes; pass++) {
-    int frames_in = 0;
+    int frames_in = 0, seen_frames = 0;
+    int64_t estimated_time_left = -1;
+    int64_t average_rate = -1;
+    off_t lagged_count = 0;
 
     open_input_file(&input);
 
     /* If the input file doesn't specify its w/h (raw files), try to get
      * the data from the first stream's configuration.
      */
     if (!input.w || !input.h)
       FOREACH_STREAM( {
       if (stream->config.cfg.g_w && stream->config.cfg.g_h) {
         input.w = stream->config.cfg.g_w;
         input.h = stream->config.cfg.g_h;
         break;
       }
     });
 
     /* Update stream configurations from the input file's parameters */
+    if (!input.w || !input.h)
+      fatal("Specify stream dimensions with --width (-w) "
+            " and --height (-h)");
     FOREACH_STREAM(set_stream_dimensions(stream, input.w, input.h));
     FOREACH_STREAM(validate_stream_config(stream));
 
     /* Ensure that --passes and --pass are consistent. If --pass is set and
      * --passes=2, ensure --fpf was set.
      */
     if (global.pass && global.passes == 2)
       FOREACH_STREAM( {
       if (!stream->config.stats_fn)
         die("Stream %d: Must specify --fpf when --pass=%d"
@@ skipping 38 matching lines @@
     got_data = 0;
 
     while (frame_avail || got_data) {
       struct vpx_usec_timer timer;
 
       if (!global.limit || frames_in < global.limit) {
         frame_avail = read_frame(&input, &raw);
 
         if (frame_avail)
           frames_in++;
+        seen_frames = frames_in > global.skip_frames ?
+                          frames_in - global.skip_frames : 0;
 
         if (!global.quiet) {
+          float fps = usec_to_fps(cx_time, seen_frames);
+          fprintf(stderr, "\rPass %d/%d ", pass + 1, global.passes);
+
           if (stream_cnt == 1)
             fprintf(stderr,
-                    "\rPass %d/%d frame %4d/%-4d %7"PRId64"B \033[K",
-                    pass + 1, global.passes, frames_in,
-                    streams->frames_out, (int64_t)streams->nbytes);
+                    "frame %4d/%-4d %7"PRId64"B ",
+                    frames_in, streams->frames_out, (int64_t)streams->nbytes);
           else
-            fprintf(stderr,
-                    "\rPass %d/%d frame %4d %7lu %s (%.2f fps)\033[K",
-                    pass + 1, global.passes, frames_in,
-                    cx_time > 9999999 ? cx_time / 1000 : cx_time,
-                    cx_time > 9999999 ? "ms" : "us",
-                    usec_to_fps(cx_time, frames_in));
+            fprintf(stderr, "frame %4d ", frames_in);
+
+          fprintf(stderr, "%7"PRId64" %s %.2f %s ",
+                  cx_time > 9999999 ? cx_time / 1000 : cx_time,
+                  cx_time > 9999999 ? "ms" : "us",
+                  fps >= 1.0 ? fps : 1000.0 / fps,
+                  fps >= 1.0 ? "fps" : "ms/f");
+          print_time("ETA", estimated_time_left);
+          fprintf(stderr, "\033[K");
         }
 
       } else
         frame_avail = 0;
 
       if (frames_in > global.skip_frames) {
         vpx_usec_timer_start(&timer);
         FOREACH_STREAM(encode_frame(stream, &global,
                                     frame_avail ? &raw : NULL,
                                     frames_in));
         vpx_usec_timer_mark(&timer);
-        cx_time += (unsigned long)vpx_usec_timer_elapsed(&timer);
+        cx_time += vpx_usec_timer_elapsed(&timer);
 
         FOREACH_STREAM(update_quantizer_histogram(stream));
 
         got_data = 0;
         FOREACH_STREAM(get_cx_data(stream, &global, &got_data));
 
-        if (got_data && global.test_decode)
-          FOREACH_STREAM(test_decode(stream));
+        if (!got_data && input.length && !streams->frames_out) {
+          lagged_count = global.limit ? seen_frames : ftello(input.file);
+        } else if (input.length) {
+          int64_t remaining;
+          int64_t rate;
+
+          if (global.limit) {
+            int frame_in_lagged = (seen_frames - lagged_count) * 1000;
+
+            rate = cx_time ? frame_in_lagged * (int64_t)1000000 / cx_time : 0;
+            remaining = 1000 * (global.limit - global.skip_frames
+                                - seen_frames + lagged_count);
+          } else {
+            off_t input_pos = ftello(input.file);
+            off_t input_pos_lagged = input_pos - lagged_count;
+            int64_t limit = input.length;
+
+            rate = cx_time ? input_pos_lagged * (int64_t)1000000 / cx_time : 0;
+            remaining = limit - input_pos + lagged_count;
+          }
+
+          average_rate = (average_rate <= 0)
+              ? rate
+              : (average_rate * 7 + rate) / 8;
+          estimated_time_left = average_rate ? remaining / average_rate : -1;
+        }
+
+        if (got_data && global.test_decode != TEST_DECODE_OFF)
+          FOREACH_STREAM(test_decode(stream, global.test_decode));
       }
 
       fflush(stdout);
     }
 
     if (stream_cnt > 1)
       fprintf(stderr, "\n");
 
     if (!global.quiet)
       FOREACH_STREAM(fprintf(
                        stderr,
                        "\rPass %d/%d frame %4d/%-4d %7"PRId64"B %7lub/f %7"PRId64"b/s"
                        " %7"PRId64" %s (%.2f fps)\033[K\n", pass + 1,
                        global.passes, frames_in, stream->frames_out, (int64_t)stream->nbytes,
-                       frames_in ? (unsigned long)(stream->nbytes * 8 / frames_in) : 0,
-                       frames_in ? (int64_t)stream->nbytes * 8
+                       seen_frames ? (unsigned long)(stream->nbytes * 8 / seen_frames) : 0,
+                       seen_frames ? (int64_t)stream->nbytes * 8
                        * (int64_t)global.framerate.num / global.framerate.den
-                       / frames_in
+                       / seen_frames
                        : 0,
                        stream->cx_time > 9999999 ? stream->cx_time / 1000 : stream->cx_time,
                        stream->cx_time > 9999999 ? "ms" : "us",
-                       usec_to_fps(stream->cx_time, frames_in));
+                       usec_to_fps(stream->cx_time, seen_frames));
                     );
 
     if (global.show_psnr)
       FOREACH_STREAM(show_psnr(stream));
 
     FOREACH_STREAM(vpx_codec_destroy(&stream->encoder));
 
-    if (global.test_decode) {
+    if (global.test_decode != TEST_DECODE_OFF) {
       FOREACH_STREAM(vpx_codec_destroy(&stream->decoder));
       FOREACH_STREAM(vpx_img_free(&stream->ref_enc.img));
       FOREACH_STREAM(vpx_img_free(&stream->ref_dec.img));
     }
 
     close_input_file(&input);
 
+    if (global.test_decode == TEST_DECODE_FATAL) {
+      FOREACH_STREAM(res |= stream->mismatch_seen);
+    }
     FOREACH_STREAM(close_output_file(stream, global.codec->fourcc));
 
     FOREACH_STREAM(stats_close(&stream->stats, global.passes - 1));
 
     if (global.pass)
       break;
   }
 
   if (global.show_q_hist_buckets)
     FOREACH_STREAM(show_q_histogram(stream->counts,
@@ skipping 17 matching lines @@
     } else {
       fprintf(f, "No mismatch detected in recon buffers\n");
     }
     fclose(f);
   });
 #endif
 
   vpx_img_free(&raw);
   free(argv);
   free(streams);
-  return EXIT_SUCCESS;
+  return res ? EXIT_FAILURE : EXIT_SUCCESS;
 }