Fix the validation of the keyframe requests.

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 34 matching lines @@
 namespace {
 
 const media::VideoFrame::Format kInputFormat = media::VideoFrame::I420;
 
 // Arbitrarily chosen to add some depth to the pipeline.
 const unsigned int kNumOutputBuffers = 4;
 const unsigned int kNumExtraInputFrames = 4;
 // Maximum delay between requesting a keyframe and receiving one, in frames.
 // Arbitrarily chosen as a reasonable requirement.
 const unsigned int kMaxKeyframeDelay = 4;
-// Value to use as max frame number for keyframe detection.
-const unsigned int kMaxFrameNum =
-    std::numeric_limits<unsigned int>::max() - kMaxKeyframeDelay;
 // Default initial bitrate.
 const uint32 kDefaultBitrate = 2000000;
 // Default ratio of requested_subsequent_bitrate to initial_bitrate
 // (see test parameters below) if one is not provided.
 const double kDefaultSubsequentBitrateRatio = 2.0;
 // Default initial framerate.
 const uint32 kDefaultFramerate = 30;
 // Default ratio of requested_subsequent_framerate to initial_framerate
 // (see test parameters below) if one is not provided.
 const double kDefaultSubsequentFramerateRatio = 0.1;
@@ skipping 226 matching lines @@
   ASSERT_EQ(
       reinterpret_cast<off_t>(test_stream->mapped_aligned_in_file.data()) & 63,
       0)
       << "File should be mapped at a 64 byte boundary";
 
   CHECK_EQ(test_stream->mapped_aligned_in_file.length() %
                test_stream->aligned_buffer_size,
            0U)
       << "Stream byte size is not a product of calculated frame byte size";
   CHECK_GT(test_stream->num_frames, 0UL);
-  CHECK_LE(test_stream->num_frames, kMaxFrameNum);
 }
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
 static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
                                        ScopedVector<TestStream>* test_streams) {
   // Split the string to individual test stream data.
   std::vector<base::FilePath::StringType> test_streams_data;
   base::SplitString(data, ';', &test_streams_data);
   CHECK_GE(test_streams_data.size(), 1U) << data;
@@ skipping 387 matching lines @@
       pos_in_input_stream_(0),
       num_required_input_buffers_(0),
       output_buffer_size_(0),
       num_frames_to_encode_(0),
       num_encoded_frames_(0),
       num_frames_since_last_check_(0),
       seen_keyframe_in_this_buffer_(false),
       save_to_file_(save_to_file),
       keyframe_period_(keyframe_period),
       num_keyframes_requested_(0),
-      next_keyframe_at_(kMaxFrameNum),
+      next_keyframe_at_(0),
       force_bitrate_(force_bitrate),
       current_requested_bitrate_(0),
       current_framerate_(0),
       encoded_stream_size_since_last_check_(0),
       test_perf_(test_perf),
       requested_bitrate_(0),
       requested_framerate_(0),
       requested_subsequent_bitrate_(0),
       requested_subsequent_framerate_(0),
       run_at_fps_(run_at_fps) {
@@ skipping 371 matching lines @@
   // Because the keyframe behavior requirements are loose, we give
   // the encoder more freedom here. It could either deliver a keyframe
   // immediately after we requested it, which could be for a frame number
   // before the one we requested it for (if the keyframe request
   // is asynchronous, i.e. not bound to any concrete frame, and because
   // the pipeline can be deeper than one frame), at that frame, or after.
   // So the only constraints we put here is that we get a keyframe not
   // earlier than we requested one (in time), and not later than
   // kMaxKeyframeDelay frames after the frame, for which we requested
   // it, comes back encoded.
-  EXPECT_LE(num_encoded_frames_, next_keyframe_at_ + kMaxKeyframeDelay);
-
   if (keyframe) {
-    if (num_keyframes_requested_ > 0)
+    if (num_keyframes_requested_ > 0 &&
+        num_encoded_frames_ > next_keyframe_at_) {
       --num_keyframes_requested_;
-    next_keyframe_at_ += keyframe_period_;
+      next_keyframe_at_ += keyframe_period_;
+    }
     seen_keyframe_in_this_buffer_ = true;
   }
 
+  if (num_keyframes_requested_ > 0)
+    EXPECT_LE(num_encoded_frames_, next_keyframe_at_ + kMaxKeyframeDelay);
+
   if (num_encoded_frames_ == num_frames_to_encode_ / 2) {
     VerifyStreamProperties();
     if (requested_subsequent_bitrate_ != current_requested_bitrate_ ||
         requested_subsequent_framerate_ != current_framerate_) {
       SetStreamParameters(requested_subsequent_bitrate_,
                           requested_subsequent_framerate_);
       if (run_at_fps_ && input_timer_)
         input_timer_->Start(
             FROM_HERE, base::TimeDelta::FromSeconds(1) / current_framerate_,
             base::Bind(&VEAClient::OnInputTimer, base::Unretained(this)));
@@ skipping 285 matching lines @@
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass(), run_at_fps)));
 
   return RUN_ALL_TESTS();
 }