libvpx: Pull from upstream

source/libvpx/test/error_resilience_test.cc

 /*
  *  Copyright (c) 2013 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 "third_party/googletest/src/include/gtest/gtest.h"
 #include "test/codec_factory.h"
 #include "test/encode_test_driver.h"
 #include "test/i420_video_source.h"
 #include "test/util.h"
 
 namespace {
 
-const int kMaxErrorFrames = 8;
-const int kMaxDroppableFrames = 8;
+const int kMaxErrorFrames = 12;
+const int kMaxDroppableFrames = 12;
 
 class ErrorResilienceTest : public ::libvpx_test::EncoderTest,
     public ::libvpx_test::CodecTestWithParam<libvpx_test::TestMode> {
  protected:
   ErrorResilienceTest() : EncoderTest(GET_PARAM(0)),
                           psnr_(0.0),
                           nframes_(0),
                           mismatch_psnr_(0.0),
                           mismatch_nframes_(0),
                           encoding_mode_(GET_PARAM(1)) {
@@ skipping 137 matching lines @@
   EXPECT_GT(psnr_resilience_on, 25.0);
 
   // Test that turning on error resilient mode hurts by 10% at most.
   if (psnr_resilience_off > 0.0) {
     const double psnr_ratio = psnr_resilience_on / psnr_resilience_off;
     EXPECT_GE(psnr_ratio, 0.9);
     EXPECT_LE(psnr_ratio, 1.1);
   }
 }
 
+// Check for successful decoding and no encoder/decoder mismatch
+// if we lose (i.e., drop before decoding) a set of droppable
+// frames (i.e., frames that don't update any reference buffers).
+// Check both isolated and consecutive loss.
 TEST_P(ErrorResilienceTest, DropFramesWithoutRecovery) {
   const vpx_rational timebase = { 33333333, 1000000000 };
   cfg_.g_timebase = timebase;
   cfg_.rc_target_bitrate = 500;
   // FIXME(debargha): Fix this to work for any lag.
   // Currently this test only works for lag = 0
   cfg_.g_lag_in_frames = 0;
 
   init_flags_ = VPX_CODEC_USE_PSNR;
 
   libvpx_test::I420VideoSource video("hantro_collage_w352h288.yuv", 352, 288,
-                                     timebase.den, timebase.num, 0, 30);
+                                     timebase.den, timebase.num, 0, 40);
 
   // Error resilient mode ON.
   cfg_.g_error_resilient = 1;
+  cfg_.kf_mode = VPX_KF_DISABLED;
 
-  // Set an arbitrary set of error frames same as droppable frames
-  unsigned int num_droppable_frames = 2;
-  unsigned int droppable_frame_list[] = {5, 16};
+  // Set an arbitrary set of error frames same as droppable frames.
+  // In addition to isolated loss/drop, add a long consecutive series
+  // (of size 9) of dropped frames.
+  unsigned int num_droppable_frames = 11;
+  unsigned int droppable_frame_list[] = {5, 16, 22, 23, 24, 25, 26, 27, 28,
+                                         29, 30};
   SetDroppableFrames(num_droppable_frames, droppable_frame_list);
   SetErrorFrames(num_droppable_frames, droppable_frame_list);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
   // Test that no mismatches have been found
   std::cout << "             Mismatch frames: "
             << GetMismatchFrames() << "\n";
   EXPECT_EQ(GetMismatchFrames(), (unsigned int) 0);
 
-  // reset previously set error/droppable frames
+  // Reset previously set of error/droppable frames.
   Reset();
 
 #if 0
   // TODO(jkoleszar): This test is disabled for the time being as too
   // sensitive. It's not clear how to set a reasonable threshold for
   // this behavior.
 
   // Now set an arbitrary set of error frames that are non-droppable
   unsigned int num_error_frames = 3;
   unsigned int error_frame_list[] = {3, 10, 20};
   SetErrorFrames(num_error_frames, error_frame_list);
   ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
 
   // Test that dropping an arbitrary set of inter frames does not hurt too much
   // Note the Average Mismatch PSNR is the average of the PSNR between
   // decoded frame and encoder's version of the same frame for all frames
   // with mismatch.
   const double psnr_resilience_mismatch = GetAverageMismatchPsnr();
   std::cout << "             Mismatch PSNR: "
             << psnr_resilience_mismatch << "\n";
   EXPECT_GT(psnr_resilience_mismatch, 20.0);
 #endif
 }
 
 VP8_INSTANTIATE_TEST_CASE(ErrorResilienceTest, ONE_PASS_TEST_MODES);
 VP9_INSTANTIATE_TEST_CASE(ErrorResilienceTest, ONE_PASS_TEST_MODES);
 
 }  // namespace