VEA Test: revert timestamp test

media/gpu/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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 941 matching lines @@
   unsigned int requested_framerate_;
 
   // Bitrate to switch to in the middle of the stream.
   unsigned int requested_subsequent_bitrate_;
 
   // Framerate to switch to in the middle of the stream.
   unsigned int requested_subsequent_framerate_;
 
   // The timer used to feed the encoder with the input frames.
   std::unique_ptr<base::RepeatingTimer> input_timer_;
-
-  // The timestamps for each frame in the order of CreateFrame() invocation.
-  std::queue<base::TimeDelta> frame_timestamps_;
 };
 
 VEAClient::VEAClient(TestStream* test_stream,
                      ClientStateNotification<ClientState>* note,
                      bool save_to_file,
                      unsigned int keyframe_period,
                      bool force_bitrate,
                      bool test_perf,
                      bool mid_stream_bitrate_switch,
                      bool mid_stream_framerate_switch,
@@ skipping 254 matching lines @@
   ASSERT_LE(payload_size, output_buffer_size_);
 
   IdToSHM::iterator it = output_buffers_at_client_.find(bitstream_buffer_id);
   ASSERT_NE(it, output_buffers_at_client_.end());
   base::SharedMemory* shm = it->second;
   output_buffers_at_client_.erase(it);
 
   if (state_ == CS_FINISHED || state_ == CS_VALIDATED)
     return;
 
-  ASSERT_FALSE(frame_timestamps_.empty());
-  ASSERT_EQ(timestamp, frame_timestamps_.front());

[wuchengli, 2016/06/15 08:59:21]

Use EXPECT so the rest of this function can be run. We need to run the rest when
the timestamp is wrong.

EXPECT_FALSE(frame_timestamps_.empty());
if (!frame_timestamps_.empty()) {
  EXPECT_EQ(timestamp, frame_timestamps_.front());
  frame_timestamps_.pop();
}

-  frame_timestamps_.pop();

[wuchengli, 2016/06/15 08:59:21]

One input buffer can generate more than one output buffers.

Say there are three input buffers -- 0, 0.033ms, 0.066ms. It generates four
output buffers. Both cases should pass: (1) 0, 0, 0.033, 0.066 and (2) 0, 0.033,
0.033, 0.066. But 0, 0.066, 0.033, 0.066 should fail.

-
   encoded_stream_size_since_last_check_ += payload_size;
 
   const uint8_t* stream_ptr = static_cast<const uint8_t*>(shm->memory());
   if (payload_size > 0) {
     if (stream_validator_) {
       stream_validator_->ProcessStreamBuffer(stream_ptr, payload_size);
     } else {
       HandleEncodedFrame(key_frame);
     }
 
@@ skipping 64 matching lines @@
   CHECK_GT(current_framerate_, 0U);
 
   scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::WrapExternalYuvData(
           kInputFormat, input_coded_size_,
           gfx::Rect(test_stream_->visible_size), test_stream_->visible_size,
           input_coded_size_.width(), input_coded_size_.width() / 2,
           input_coded_size_.width() / 2, frame_data_y, frame_data_u,
           frame_data_v,
           base::TimeDelta().FromMilliseconds(
               next_input_id_ * base::Time::kMillisecondsPerSecond /

[wuchengli, 2016/06/15 08:59:21]

Better to use (next_input_id_ + 1) so the timestamp is not 0. By default,
timestamp is 0 and we won't catch if the first timestamp is wrong.

               current_framerate_));
   EXPECT_NE(nullptr, video_frame.get());
   return video_frame;
 }
 
 scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(
     off_t position,
     int32_t* input_id) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
            test_stream_->aligned_in_file_data.size());
@@ skipping 34 matching lines @@
     // we require for bitrate tests.
     pos_in_input_stream_ = 0;
   }
 
   if (quality_validator_)
     quality_validator_->AddOriginalFrame(CreateFrame(pos_in_input_stream_));
 
   int32_t input_id;
   scoped_refptr<media::VideoFrame> video_frame =
       PrepareInputFrame(pos_in_input_stream_, &input_id);
-  frame_timestamps_.push(video_frame->timestamp());
   pos_in_input_stream_ += test_stream_->aligned_buffer_size;
 
   bool force_keyframe = false;
   if (keyframe_period_ && input_id % keyframe_period_ == 0) {
     force_keyframe = true;
     ++num_keyframes_requested_;
   }
 
   if (input_id == 0) {
     first_frame_start_time_ = base::TimeTicks::Now();
@@ skipping 403 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }