vea_unittest: Calculate per-frame encode latency

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 <algorithm>
+
 #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"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 51 matching lines @@
 // Tolerance factor for how encoded bitrate can differ from requested bitrate.
 const double kBitrateTolerance = 0.1;
 // Minimum required FPS throughput for the basic performance test.
 const uint32 kMinPerfFPS = 30;
 // Minimum (arbitrary) number of frames required to enforce bitrate requirements
 // over. Streams shorter than this may be too short to realistically require
 // an encoder to be able to converge to the requested bitrate over.
 // The input stream will be looped as many times as needed in bitrate tests
 // to reach at least this number of frames before calculating final bitrate.
 const unsigned int kMinFramesForBitrateTests = 300;
+// The percentages of the percentiles to measure for encode latency.
+static int32 kLoggedLatencyPercentages[] = {50, 75, 95};

[Owen Lin, 2015/05/07 09:53:45]

Please change it back to using float. We have the issue because of data
presentation.

But
1. We should not change the code just because of the data presentation.
2. We don't need those "round" and "cast" things anymore. See below.

[Justin Chuang, 2015/05/07 10:13:18]

Interesting. I'd prefer to keep the current code because
1. The array is added in this CL. So no harm to change its data format before
commit. 
2. Float => int conversion is not very comfortable although we have good helpers
and modern compiler/lib support is good. int to float is more straightforward.
Thoughts?

[Pawel Osciak, 2015/05/07 11:31:50]

s/Percentages/Percentiles/

Do we need to use int32 in particular? Just unsigned int should work? Also, as a
side note, intXX are deprecated in favor of intXX_t.

[Justin Chuang, 2015/05/08 03:57:52]

Done. also changed to uint32_t. Thx
There are other occurrences of int32 in this file. Leave it for another CL.

[Owen Lin, 2015/05/08 05:59:52]

I am OK with the code it is now. But my point is the number should be float in
its nature. It makes sense for asking for a 0.1% percentile.

We don't need float => int conversion at all. What we need is to show a float
number and that is what printf does.

[Pawel Osciak, 2015/05/11 03:43:56]

Thanks, but my point was we didn't explicitly need a 32-bit value. Just unsigned
int should be fine.

Where we use int32 here is for the input ids, because the VDA interface still
uses int32 there.

[Justin Chuang, 2015/05/11 11:24:54]

Got it. Changed. I thought we're using LP64 in arm64 and x86_64, and there is no
difference between int32_t and int. But I'm fine w/ both if Chromium coding
style doesn't prefer explicit sized types.

 
 // The syntax of multiple test streams is:
 //  test-stream1;test-stream2;test-stream3
 // The syntax of each test stream is:
 // "in_filename:width:height:out_filename:requested_bitrate:requested_framerate
 //  :requested_subsequent_bitrate:requested_subsequent_framerate"
 // - |in_filename| must be an I420 (YUV planar) raw stream
 //   (see http://www.fourcc.org/yuv.php#IYUV).
 // - |width| and |height| are in pixels.
 // - |profile| to encode into (values of media::VideoCodecProfile).
@@ skipping 292 matching lines @@
     ParseAndReadTestStreamData(*test_stream_data_, &test_streams_);
   }
 
   virtual void TearDown() {
     for (size_t i = 0; i < test_streams_.size(); i++) {
       base::DeleteFile(test_streams_[i]->aligned_in_file, false);
     }
     log_file_.reset();
   }
 
-  // Log one entry of machine-readable data to file.
+  // Log one entry of machine-readable data to file and LOG(INFO).
   // The log has one data entry per line in the format of "<key>: <value>".
+  // Note that Chrome OS Autotest is parsing the output key and value pairs. Be

[wuchengli, 2015/05/07 09:22:17]

s/is parsing/parses/

[Justin Chuang, 2015/05/07 10:01:16]

Done.

+  // sure to keep the Autotest in sync.
   void LogToFile(const std::string& key, const std::string& value) {
+    std::string s = base::StringPrintf("%s: %s\n", key.c_str(), value.c_str());
+    LOG(INFO) << s;

[Pawel Osciak, 2015/05/07 11:31:51]

Is this to make it convenient for humans running the test manually or to make
this visible in logs on bots as well?

[Justin Chuang, 2015/05/08 03:57:52]

for human running the test manually. (even when --output_log is not used)
Prior to this CL, another metric using LogToFile() is also output to INFO(LOG).

     if (log_file_) {
-      std::string s =
-          base::StringPrintf("%s: %s\n", key.c_str(), value.c_str());
       log_file_->WriteAtCurrentPos(s.data(), s.length());
     }
   }
 
   ScopedVector<TestStream> test_streams_;
   bool run_at_fps_;
 
  private:
   scoped_ptr<base::FilePath::StringType> test_stream_data_;
   base::FilePath log_path_;
@@ skipping 157 matching lines @@
             unsigned int keyframe_period,
             bool force_bitrate,
             bool test_perf,
             bool mid_stream_bitrate_switch,
             bool mid_stream_framerate_switch,
             bool run_at_fps);
   ~VEAClient() override;
   void CreateEncoder();
   void DestroyEncoder();
 
-  // Return the number of encoded frames per second.
-  double frames_per_second();
-
   // VideoDecodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32 bitstream_buffer_id,
                             size_t payload_size,
                             bool key_frame) override;
   void NotifyError(VideoEncodeAccelerator::Error error) override;
 
  private:
   bool has_encoder() { return encoder_.get(); }
 
+  // Return the number of encoded frames per second.
+  double frames_per_second();
+
+  // Return the percentile from a sorted array.
+  static base::TimeDelta percentile(
+      const std::vector<base::TimeDelta>& sorted_values,
+      float percentage);
+
   scoped_ptr<media::VideoEncodeAccelerator> CreateFakeVEA();
   scoped_ptr<media::VideoEncodeAccelerator> CreateV4L2VEA();
   scoped_ptr<media::VideoEncodeAccelerator> CreateVaapiVEA();
 
   void SetState(ClientState new_state);
 
   // Set current stream parameters to given |bitrate| at |framerate|.
   void SetStreamParameters(unsigned int bitrate, unsigned int framerate);
 
   // Called when encoder is done with a VideoFrame.
   void InputNoLongerNeededCallback(int32 input_id);
 
   // Feed the encoder with one input frame.
   void FeedEncoderWithOneInput();
 
   // Provide the encoder with a new output buffer.
   void FeedEncoderWithOutput(base::SharedMemory* shm);
 
   // Called on finding a complete frame (with |keyframe| set to true for
   // keyframes) in the stream, to perform codec-independent, per-frame checks
   // and accounting. Returns false once we have collected all frames we needed.
   bool HandleEncodedFrame(bool keyframe);
 
   // Verify that stream bitrate has been close to current_requested_bitrate_,
   // assuming current_framerate_ since the last time VerifyStreamProperties()
   // was called. Fail the test if |force_bitrate_| is true and the bitrate
   // is not within kBitrateTolerance.
   void VerifyStreamProperties();
 
-  // Test codec performance, failing the test if we are currently running
-  // the performance test.
-  void VerifyPerf();
+  // Log the performance data.
+  void LogPerf();
 
   // Write IVF file header to test_stream_->out_filename.
   void WriteIvfFileHeader();
 
   // Write an IVF frame header to test_stream_->out_filename.
   void WriteIvfFrameHeader(int frame_index, size_t frame_size);
 
-  // Prepare and return a frame wrapping the data at |position| bytes in
-  // the input stream, ready to be sent to encoder.
-  scoped_refptr<media::VideoFrame> PrepareInputFrame(off_t position);
+  // Prepare and return a frame wrapping the data at |position| bytes in the
+  // input stream, ready to be sent to encoder.
+  // The input frame id is returned in |input_id|.
+  scoped_refptr<media::VideoFrame> PrepareInputFrame(off_t position,
+                                                     int32* input_id);
 
   // Update the parameters according to |mid_stream_bitrate_switch| and
   // |mid_stream_framerate_switch|.
   void UpdateTestStreamData(bool mid_stream_bitrate_switch,
                             bool mid_stream_framerate_switch);
 
   // Callback function of the |input_timer_|.
   void OnInputTimer();
 
   ClientState state_;
   scoped_ptr<VideoEncodeAccelerator> encoder_;
 
   TestStream* test_stream_;
 
   // Used to notify another thread about the state. VEAClient does not own this.
   ClientStateNotification<ClientState>* note_;
 
-  // Ids assigned to VideoFrames (start at 1 for easy comparison with
-  // num_encoded_frames_).
+  // Ids assigned to VideoFrames.
   std::set<int32> inputs_at_client_;
   int32 next_input_id_;
 
+  typedef std::map<int32, base::TimeTicks> IdToTicks;

[Pawel Osciak, 2015/05/07 11:31:50]

s/Id/InputId/

[Justin Chuang, 2015/05/08 03:57:52]

Removed this typedef after changing data structure.

+  // A map from input frame id to the encode start time of the frame.
+  IdToTicks frame_encode_start_ticks_;

[wuchengli, 2015/05/07 09:22:17]

Hmm. The name is not consistent with |encode_start_time_|, whose type is also
TimeTicks. I still prefer |frame_encode_start_times_|.

As we discussed, remove |frame_encode_start_ticks_| and make
|encode_start_time_| a vector. There's no need to erase the element of
|frame_encode_start_ticks_| in HandleEncodedFrame().

I'm not a fan of ticks in the name. "start time" is common and easier to
understand for a name. There's no need to put the type into the name.

[Justin Chuang, 2015/05/07 10:01:16]

Done. Thanks. The code looks simpler.

[Pawel Osciak, 2015/05/07 11:31:50]

Since we use input ids starting from 0 and incrementing by 1, a vector would be
enough? You could access input_id frame via vector[input_id]?

[Justin Chuang, 2015/05/08 03:57:52]

Yes, already changed in patchset 6. 

+  // The encode latencies of all encoded frames.

[Pawel Osciak, 2015/05/07 11:31:51]

We should describe how we define latency. Maybe ", i.e. time delta between
calling VEA::Encode() on a frame and receiving it encoded via 
VEA::BitstreamBufferReady()" ?

[Justin Chuang, 2015/05/08 03:57:52]

Yes, it's in commit message. Copied over here. 

[Pawel Osciak, 2015/05/11 03:43:56]

Thanks. Better to have it here for people reading the code in the future.

+  std::vector<base::TimeDelta> encode_latencies_;
+
   // Ids for output BitstreamBuffers.
   typedef std::map<int32, base::SharedMemory*> IdToSHM;
   ScopedVector<base::SharedMemory> output_shms_;
   IdToSHM output_buffers_at_client_;
   int32 next_output_buffer_id_;
 
   // Current offset into input stream.
   off_t pos_in_input_stream_;
   gfx::Size input_coded_size_;
   // Requested by encoder.
@@ skipping 31 matching lines @@
   // Current requested bitrate.
   unsigned int current_requested_bitrate_;
 
   // Current expected framerate.
   unsigned int current_framerate_;
 
   // Byte size of the encoded stream (for bitrate calculation) since last
   // time we checked bitrate.
   size_t encoded_stream_size_since_last_check_;
 
   // If true, verify performance at the end of the test.

[Pawel Osciak, 2015/05/07 11:31:51]

We should probably call this something like ensure_min_fps_, since this is the
only thing that it governs now.

[Pawel Osciak, 2015/05/11 03:43:56]

Could we do this please?

   bool test_perf_;
 
   scoped_ptr<StreamValidator> validator_;
 
   // The time when the encoding started.
   base::TimeTicks encode_start_time_;
 
   // The time when the last encoded frame is ready.
   base::TimeTicks last_frame_ready_time_;
 
@@ skipping 48 matching lines @@
       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) {

[Pawel Osciak, 2015/05/07 11:31:51]

We should have a CHECK here that verifies that if run_at_fps_ is true,
test_perf_ (or actually ensure_min_fps_) is not true.

   if (keyframe_period_)
     CHECK_LT(kMaxKeyframeDelay, keyframe_period_);
 
   // Fake encoder produces an invalid stream, so skip validating it.
   if (!g_fake_encoder) {
     validator_ = StreamValidator::Create(
         test_stream_->requested_profile,
         base::Bind(&VEAClient::HandleEncodedFrame, base::Unretained(this)));
     CHECK(validator_);
   }
@@ skipping 127 matching lines @@
   }
   if (requested_subsequent_framerate_ == 0)
     requested_subsequent_framerate_ = 1;
 }
 
 double VEAClient::frames_per_second() {
   base::TimeDelta duration = last_frame_ready_time_ - encode_start_time_;
   return num_encoded_frames_ / duration.InSecondsF();
 }
 
+base::TimeDelta VEAClient::percentile(

[Pawel Osciak, 2015/05/07 11:31:51]

I think this doesn't have to be a member method?

[Justin Chuang, 2015/05/08 03:57:52]

It's class static private method. Shall I move to global anonymous namespace?

[Pawel Osciak, 2015/05/11 03:43:56]

Yes please.

[Justin Chuang, 2015/05/11 11:24:54]

Done. BTW, I see many static functions in this file. We don't need those
'static' keyword if they are already in anonymous namespace, right?

+    const std::vector<base::TimeDelta>& sorted_values,
+    float percentage) {
+  size_t size = sorted_values.size();
+  CHECK_NE(0, size);

[Pawel Osciak, 2015/05/07 11:31:51]

CHECK_GT(size, 0) ?

[Justin Chuang, 2015/05/08 03:57:52]

Done.

+  CHECK_GE(percentage, 0.0f);
+  CHECK_LE(percentage, 1.0f);
+  // Use Nearest Rank method.
+  size_t index =
+      std::min(base::checked_cast<size_t>(percentage * size), size - 1);

[Pawel Osciak, 2015/05/07 11:31:51]

Is this to guard ourselves from getting a percentage > 1 as an argument to this
function? Would it be more explicit to say if (percentage >= 1) return
sorted_values.back() ?

[Justin Chuang, 2015/05/08 03:57:52]

Can't change to that. It overflows even when percentage is slightly smaller than
1.0f. 

My first version is index = (size - 1) * ratio, which doesn't have overflow
issue, but is different than the official formula.

The official formula is index = max(ceil(size * ratio) - 1, 0)

The current code uses index = min(floor(size * ratio), size - 1),  which is the
same as the official formula except for marginal cases. It's still ok, I think.

Discussed with Owen, I'll change to the same as official formula to reduce
confusions for future readers.

+  return sorted_values[index];
+}
+
 void VEAClient::RequireBitstreamBuffers(unsigned int input_count,
                                         const gfx::Size& input_coded_size,
                                         size_t output_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ASSERT_EQ(state_, CS_INITIALIZED);
   SetState(CS_ENCODING);
 
   CreateAlignedInputStreamFile(input_coded_size, test_stream_);
 
   num_frames_to_encode_ = test_stream_->num_frames;
@@ skipping 103 matching lines @@
 }
 
 void VEAClient::InputNoLongerNeededCallback(int32 input_id) {
   std::set<int32>::iterator it = inputs_at_client_.find(input_id);
   ASSERT_NE(it, inputs_at_client_.end());
   inputs_at_client_.erase(it);
   if (!run_at_fps_)
     FeedEncoderWithOneInput();
 }
 
-scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(off_t position) {
+scoped_refptr<media::VideoFrame> VEAClient::PrepareInputFrame(off_t position,
+                                                              int32* input_id) {
   CHECK_LE(position + test_stream_->aligned_buffer_size,
            test_stream_->mapped_aligned_in_file.length());
 
   uint8* frame_data_y = const_cast<uint8*>(
       test_stream_->mapped_aligned_in_file.data() + position);
   uint8* frame_data_u = frame_data_y + test_stream_->aligned_plane_size[0];
   uint8* frame_data_v = frame_data_u + test_stream_->aligned_plane_size[1];
 
   CHECK_GT(current_framerate_, 0U);
   scoped_refptr<media::VideoFrame> frame =
@@ skipping 10 matching lines @@
           frame_data_v,
           base::TimeDelta().FromMilliseconds(
               next_input_id_ * base::Time::kMillisecondsPerSecond /
               current_framerate_),
           media::BindToCurrentLoop(
               base::Bind(&VEAClient::InputNoLongerNeededCallback,
                          base::Unretained(this),
                          next_input_id_)));
 
   CHECK(inputs_at_client_.insert(next_input_id_).second);
-  ++next_input_id_;
 
+  *input_id = next_input_id_++;
   return frame;
 }
 
 void VEAClient::OnInputTimer() {
   if (!has_encoder() || state_ != CS_ENCODING)
     input_timer_.reset();
   else if (inputs_at_client_.size() <
            num_required_input_buffers_ + kNumExtraInputFrames)
     FeedEncoderWithOneInput();
   else
     DVLOG(1) << "Dropping input frame";
 }
 
 void VEAClient::FeedEncoderWithOneInput() {
   if (!has_encoder() || state_ != CS_ENCODING)
     return;
 
   size_t bytes_left =
       test_stream_->mapped_aligned_in_file.length() - pos_in_input_stream_;
   if (bytes_left < test_stream_->aligned_buffer_size) {
     DCHECK_EQ(bytes_left, 0UL);
     // Rewind if at the end of stream and we are still encoding.
     // This is to flush the encoder with additional frames from the beginning
     // of the stream, or if the stream is shorter that the number of frames
     // we require for bitrate tests.
     pos_in_input_stream_ = 0;
   }
 
+  int32 input_id;
+  scoped_refptr<media::VideoFrame> video_frame =
+      PrepareInputFrame(pos_in_input_stream_, &input_id);
+  pos_in_input_stream_ += test_stream_->aligned_buffer_size;
+
   bool force_keyframe = false;
-  if (keyframe_period_ && next_input_id_ % keyframe_period_ == 0) {
+  if (keyframe_period_ && input_id % keyframe_period_ == 0) {
     force_keyframe = true;
     ++num_keyframes_requested_;
   }
 
-  scoped_refptr<media::VideoFrame> video_frame =
-      PrepareInputFrame(pos_in_input_stream_);
-  pos_in_input_stream_ += test_stream_->aligned_buffer_size;
-
+  CHECK(frame_encode_start_ticks_.insert(
+      std::make_pair(input_id, base::TimeTicks::Now())).second);
   encoder_->Encode(video_frame, force_keyframe);
 }
 
 void VEAClient::FeedEncoderWithOutput(base::SharedMemory* shm) {
   if (!has_encoder())
     return;
 
   if (state_ != CS_ENCODING)
     return;
 
   base::SharedMemoryHandle dup_handle;
   CHECK(shm->ShareToProcess(base::GetCurrentProcessHandle(), &dup_handle));
 
   media::BitstreamBuffer bitstream_buffer(
       next_output_buffer_id_++, dup_handle, output_buffer_size_);
   CHECK(output_buffers_at_client_.insert(std::make_pair(bitstream_buffer.id(),
                                                         shm)).second);
   encoder_->UseOutputBitstreamBuffer(bitstream_buffer);
 }
 
 bool VEAClient::HandleEncodedFrame(bool keyframe) {
   // This would be a bug in the test, which should not ignore false
   // return value from this method.
   CHECK_LE(num_encoded_frames_, num_frames_to_encode_);
 
+  last_frame_ready_time_ = base::TimeTicks::Now();
+
+  // Record encode latency of this frame.

[Pawel Osciak, 2015/05/07 11:31:51]

We should CHECK that run_at_fps is true if we are going to measure encode
latency. Otherwise we get skewed results, since we may queue many frames at once
with the same encode start time.

[Justin Chuang, 2015/05/08 03:57:52]

You're right! This value is used in autotest only when run_at_fps is enabled.
But I cannot CHECK() it. I can only skip the related code when run_at_fps is
false. 
Please check if the next PatchSet meets your expectation (I added a helper
method to decide that).

[Pawel Osciak, 2015/05/11 03:43:56]

Why can't we CHECK it?

[Justin Chuang, 2015/05/11 11:24:54]

Please see below.

+  IdToTicks::iterator it = frame_encode_start_ticks_.find(num_encoded_frames_);
+  CHECK_NE(it, frame_encode_start_ticks_.end());
+  encode_latencies_.push_back(last_frame_ready_time_ - it->second);
+  frame_encode_start_ticks_.erase(it);
+
   ++num_encoded_frames_;
   ++num_frames_since_last_check_;
 
-  last_frame_ready_time_ = base::TimeTicks::Now();
-
   // 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.
@@ skipping 14 matching lines @@
     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)));
     }
   } else if (num_encoded_frames_ == num_frames_to_encode_) {
-    VerifyPerf();
+    LogPerf();
     VerifyStreamProperties();
+    if (test_perf_)

[Justin Chuang, 2015/05/08 03:57:52]

Added VerifyMinFPS() method

+      EXPECT_GE(frames_per_second(), kMinPerfFPS);
     SetState(CS_FINISHED);
     return false;
   }
 
   return true;
 }
 
-void VEAClient::VerifyPerf() {
-  double measured_fps = frames_per_second();
-  LOG(INFO) << "Measured encoder FPS: " << measured_fps;
+void VEAClient::LogPerf() {
+  // Log measured FPS.
   g_env->LogToFile("Measured encoder FPS",
-                   base::StringPrintf("%.3f", measured_fps));
-  if (test_perf_)
-    EXPECT_GE(measured_fps, kMinPerfFPS);
+                   base::StringPrintf("%.3f", frames_per_second()));
+
+  // Log encode latencies.
+  std::sort(encode_latencies_.begin(), encode_latencies_.end());
+  for (size_t i = 0; i < arraysize(kLoggedLatencyPercentages); i++) {
+    int32 percentage = kLoggedLatencyPercentages[i];

[Pawel Osciak, 2015/05/07 11:31:51]

percentiles, also, no need for int32 specifically?

[Justin Chuang, 2015/05/08 03:57:52]

Changed to p. percentile is method name.

+    base::TimeDelta latency = percentile(encode_latencies_, 0.01f * percentage);
+    g_env->LogToFile(
+        base::StringPrintf("Encode latency at %d%%", percentage),

[Owen Lin, 2015/05/07 09:53:45]

We can just use 

base::StringPrintf("Encode latency at %.0f%%", percentage * 100),

[Pawel Osciak, 2015/05/07 11:31:50]

Encode latency for %dth percentile:

[Justin Chuang, 2015/05/08 03:57:52]

Done. Added 'the' since it's full sentence.

+        base::StringPrintf("%" PRId64 " us", latency.InMicroseconds()));
+  }
 }
 
 void VEAClient::VerifyStreamProperties() {
   CHECK_GT(num_frames_since_last_check_, 0UL);
   CHECK_GT(encoded_stream_size_since_last_check_, 0UL);
   unsigned int bitrate = encoded_stream_size_since_last_check_ * 8 *
                          current_framerate_ / num_frames_since_last_check_;
   DVLOG(1) << "Current chunk's bitrate: " << bitrate
            << " (expected: " << current_requested_bitrate_
            << " @ " << current_framerate_ << " FPS,"
@@ skipping 239 matching lines @@
   }
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
                   test_stream_data.Pass(), log_path, run_at_fps)));
 
   return RUN_ALL_TESTS();
 }