Added support for Decode() calls during Reset().

content/common/gpu/media/omx_video_decode_accelerator_unittest.cc

 // Copyright (c) 2011 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11, EGL, and GLES2.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
@@ skipping 418 matching lines @@
 
 ClientState ClientStateNotification::Wait() {
   base::AutoLock auto_lock(lock_);
   while (pending_states_for_notification_.empty())
     cv_.Wait();
   ClientState ret = pending_states_for_notification_.front();
   pending_states_for_notification_.pop();
   return ret;
 }
 
+// Magic constants for differentiating the reasons for NotifyResetDone being
+// called.
+enum ResetPoint {
+  MID_STREAM_RESET = -2,
+  END_OF_STREAM_RESET = -1
+};
+
 // Client that can accept callbacks from a VideoDecodeAccelerator and is used by
 // the TESTs below.
 class EglRenderingVDAClient : public VideoDecodeAccelerator::Client {
  public:
-  // Doesn't take ownership of |note| or |encoded_data|, which must outlive
+  // Doesn't take ownership of |rendering_helper| or |note|, which must outlive
   // |*this|.
+  // |reset_after_frame_num| can be a frame number >=0 indicating a mid-stream
+  // Reset() should be done after that frame number is delivered, or
+  // END_OF_STREAM_RESET to indicate no mid-stream Reset().
+  // |delete_decoder_state| indicates when the underlying decoder should be
+  // Destroy()'d and deleted and can take values: N<0: delete after -N Decode()
+  // calls have been made, N>=0 means interpret as ClientState.
   EglRenderingVDAClient(RenderingHelper* rendering_helper,
                         int rendering_window_id,
                         ClientStateNotification* note,
                         const std::string& encoded_data,
                         int num_NALUs_per_decode,
+                        int reset_after_frame_num,
                         int delete_decoder_state);
   virtual ~EglRenderingVDAClient();
   void CreateDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(
       uint32 requested_num_of_buffers,
       const gfx::Size& dimensions);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
@@ skipping 32 matching lines @@
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_NALUs_per_decode_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification* note_;
   scoped_refptr<OmxVideoDecodeAccelerator> decoder_;
   std::set<int> outstanding_texture_ids_;
+  int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   base::TimeTicks last_frame_delivered_ticks_;
 };
 
-EglRenderingVDAClient::EglRenderingVDAClient(RenderingHelper* rendering_helper,
-                                             int rendering_window_id,
-                                             ClientStateNotification* note,
-                                             const std::string& encoded_data,
-                                             int num_NALUs_per_decode,
-                                             int delete_decoder_state)
+EglRenderingVDAClient::EglRenderingVDAClient(
+    RenderingHelper* rendering_helper,
+    int rendering_window_id,
+    ClientStateNotification* note,
+    const std::string& encoded_data,
+    int num_NALUs_per_decode,
+    int reset_after_frame_num,
+    int delete_decoder_state)
     : rendering_helper_(rendering_helper),
       rendering_window_id_(rendering_window_id),
       encoded_data_(encoded_data), num_NALUs_per_decode_(num_NALUs_per_decode),
       encoded_data_next_pos_to_decode_(0), next_bitstream_buffer_id_(0),
-      note_(note), delete_decoder_state_(delete_decoder_state),
+      note_(note), reset_after_frame_num_(reset_after_frame_num),
+      delete_decoder_state_(delete_decoder_state),
       state_(CS_CREATED),
       num_decoded_frames_(0), num_done_bitstream_buffers_(0) {
   CHECK_GT(num_NALUs_per_decode, 0);
 }
 
 EglRenderingVDAClient::~EglRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
@@ skipping 61 matching lines @@
   last_frame_delivered_ticks_ = base::TimeTicks::Now();
 
   // Because we feed the decoder a limited number of NALUs at a time, we can be
   // sure that the bitstream buffer from which a frame comes has a limited
   // range.  Assert that.
   CHECK_GE((picture.bitstream_buffer_id() + 1) * num_NALUs_per_decode_,
            num_decoded_frames_);
   CHECK_LE(picture.bitstream_buffer_id(), next_bitstream_buffer_id_);
   ++num_decoded_frames_;
 
+  if (reset_after_frame_num_ == num_decoded_frames_) {
+    reset_after_frame_num_ = MID_STREAM_RESET;
+    decoder_->Reset();
+    // Re-start decoding from the beginning of the stream to avoid needing to
+    // know how to find I-frames and so on in this test.
+    encoded_data_next_pos_to_decode_ = 0;
+  }
+
   media::PictureBuffer* picture_buffer =
       picture_buffers_by_id_[picture.picture_buffer_id()];
   CHECK(picture_buffer);
   rendering_helper_->RenderTexture(picture_buffer->texture_id());
 
   decoder_->ReusePictureBuffer(picture.picture_buffer_id());
 }
 
 void EglRenderingVDAClient::NotifyInitializeDone() {
   SetState(CS_INITIALIZED);
@@ skipping 16 matching lines @@
     return;
   SetState(CS_FLUSHED);
   if (decoder_deleted())
     return;
   decoder_->Reset();
 }
 
 void EglRenderingVDAClient::NotifyResetDone() {
   if (decoder_deleted())
     return;
+  if (reset_after_frame_num_ == MID_STREAM_RESET) {
+    reset_after_frame_num_ = END_OF_STREAM_RESET;
+    return;
+  }
   SetState(CS_RESET);
   if (!decoder_deleted())
     DeleteDecoder();
 }
 
 void EglRenderingVDAClient::NotifyError(VideoDecodeAccelerator::Error error) {
   SetState(CS_ERROR);
 }
 
 static bool LookingAtNAL(const std::string& encoded, size_t pos) {
@@ skipping 75 matching lines @@
 double EglRenderingVDAClient::frames_per_second() {
   base::TimeDelta delta = last_frame_delivered_ticks_ - initialize_done_ticks_;
   if (delta.InSecondsF() == 0)
     return 0;
   return num_decoded_frames_ / delta.InSecondsF();
 }
 
 // Test parameters:
 // - Number of NALUs per Decode() call.
 // - Number of concurrent decoders.
-// - When to delete the decoder.  N<0 means after -N Decode() calls have been
-//   made, N>=0 means interpret as ClientState.
+// - reset_after_frame_num: see EglRenderingVDAClient ctor.
+// - delete_decoder_phase: see EglRenderingVDAClient ctor.
 class OmxVideoDecodeAcceleratorTest
-    : public ::testing::TestWithParam<Tuple3<int, int, ClientState> > {
+    : public ::testing::TestWithParam<
+        Tuple4<int, int, ResetPoint, ClientState> > {
 };
 
 // Wait for |note| to report a state and if it's not |expected_state| then
 // assert |client| has deleted its decoder.
 static void AssertWaitForStateOrDeleted(ClientStateNotification* note,
                                         EglRenderingVDAClient* client,
                                         ClientState expected_state) {
   ClientState state = note->Wait();
   if (state == expected_state) return;
   ASSERT_TRUE(client->decoder_deleted())
       << "Decoder not deleted but Wait() returned " << state
       << ", instead of " << expected_state;
 }
 
 // We assert the exact number of concurrent decoders we expect to succeed and
 // that one more than that fails initialization.
 enum { kMaxSupportedNumConcurrentDecoders = 5 };
 
 // Test the most straightforward case possible: data is decoded from a single
 // chunk and rendered to the screen.
 TEST_P(OmxVideoDecodeAcceleratorTest, TestSimpleDecode) {
   // Can be useful for debugging VLOGs from OVDA.
   // logging::SetMinLogLevel(-1);
 
   // Required for Thread to work.  Not used otherwise.
   base::ShadowingAtExitManager at_exit_manager;
 
   const int num_NALUs_per_decode = GetParam().a;
   const size_t num_concurrent_decoders = GetParam().b;
-  const int delete_decoder_state = GetParam().c;
+  const int reset_after_frame_num = GetParam().c;
+  const int delete_decoder_state = GetParam().d;
 
   std::string test_video_file;
   int frame_width, frame_height;
   int num_frames, num_NALUs, min_fps_render, min_fps_no_render;
   ParseTestVideoData(test_video_data, &test_video_file, &frame_width,
                      &frame_height, &num_frames, &num_NALUs,
                      &min_fps_render, &min_fps_no_render);
   min_fps_render /= num_concurrent_decoders;
   min_fps_no_render /= num_concurrent_decoders;
 
+  // If we reset mid-stream and start playback over, account for frames that are
+  // decoded twice in our expectations.
+  if (num_frames > 0 && reset_after_frame_num >= 0)
+    num_frames += reset_after_frame_num;
+
   // Suppress EGL surface swapping in all but a few tests, to cut down overall
   // test runtime.
   const bool suppress_swap_to_display = num_NALUs_per_decode > 1;
 
   std::vector<ClientStateNotification*> notes(num_concurrent_decoders, NULL);
   std::vector<EglRenderingVDAClient*> clients(num_concurrent_decoders, NULL);
 
   // Read in the video data.
   std::string data_str;
   CHECK(file_util::ReadFileToString(FilePath(test_video_file), &data_str));
@@ skipping 12 matching lines @@
                  frame_width, frame_height, &done));
   done.Wait();
 
   // First kick off all the decoders.
   for (size_t index = 0; index < num_concurrent_decoders; ++index) {
     ClientStateNotification* note = new ClientStateNotification();
     notes[index] = note;
     EglRenderingVDAClient* client = new EglRenderingVDAClient(
         &rendering_helper, index,
         note, data_str, num_NALUs_per_decode,
-        delete_decoder_state);
+        reset_after_frame_num, delete_decoder_state);
     clients[index] = client;
 
     rendering_thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&EglRenderingVDAClient::CreateDecoder,
                    base::Unretained(client)));
 
     ASSERT_EQ(note->Wait(), CS_DECODER_SET);
   }
   // Then wait for all the decodes to finish.
@@ skipping 26 matching lines @@
       << num_concurrent_decoders;
   // Finally assert that decoding went as expected.
   for (size_t i = 0; i < num_concurrent_decoders && !saw_init_failure; ++i) {
     // We can only make performance/correctness assertions if the decoder was
     // allowed to finish.
     if (delete_decoder_state < CS_FLUSHED)
       continue;
     EglRenderingVDAClient* client = clients[i];
     if (num_frames > 0)
       EXPECT_EQ(client->num_decoded_frames(), num_frames);
-    if (num_NALUs > 0) {
+    if (num_NALUs > 0 && reset_after_frame_num < 0) {
       EXPECT_EQ(client->num_done_bitstream_buffers(),
                 ceil(static_cast<double>(num_NALUs) / num_NALUs_per_decode));
     }
     LOG(INFO) << "Decoder " << i << " fps: " << client->frames_per_second();
     int min_fps = suppress_swap_to_display ? min_fps_no_render : min_fps_render;
     if (min_fps > 0)
       EXPECT_GT(client->frames_per_second(), min_fps);
   }
 
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<std::vector<EglRenderingVDAClient*> >,
                  &clients));
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&STLDeleteElements<std::vector<ClientStateNotification*> >,
                  &notes));
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&RenderingHelper::UnInitialize,
                  base::Unretained(&rendering_helper),
                  &done));
   done.Wait();
   rendering_thread.Stop();
 };
 
+// Test that Reset() mid-stream works fine and doesn't affect decoding even when
+// Decode() calls are made during the reset.
+INSTANTIATE_TEST_CASE_P(
+    MidStreamReset, OmxVideoDecodeAcceleratorTest,
+    ::testing::Values(
+        MakeTuple(1, 1, static_cast<ResetPoint>(100), CS_RESET)));
+
+// Test that Destroy() mid-stream works fine (primarily this is testing that no
+// crashes occur).
 INSTANTIATE_TEST_CASE_P(
     TearDownTiming, OmxVideoDecodeAcceleratorTest,
     ::testing::Values(
-        MakeTuple(1, 1, CS_DECODER_SET), MakeTuple(1, 1, CS_INITIALIZED),
-        MakeTuple(1, 1, CS_FLUSHED), MakeTuple(1, 1, CS_RESET),
-        MakeTuple(1, 1, static_cast<ClientState>(-1)),
-        MakeTuple(1, 1, static_cast<ClientState>(-10)),
-        MakeTuple(1, 1, static_cast<ClientState>(-100))));
+        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_DECODER_SET),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_INITIALIZED),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_FLUSHED),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-1)),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-10)),
+        MakeTuple(1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-100))));
 
-// TODO(fischman): using 1st param of 16 and higher below breaks decode - visual
-// artifacts are introduced as well as spurious frames are delivered (more
-// pictures are returned than NALUs are fed to the decoder).  Increase the "15"
-// below when http://code.google.com/p/chrome-os-partner/issues/detail?id=4378
-// is fixed.
+// Test that decoding various variation works: multiple concurrent decoders and
+// multiple NALUs per Decode() call.
 INSTANTIATE_TEST_CASE_P(
     DecodeVariations, OmxVideoDecodeAcceleratorTest,
     ::testing::Values(
-        MakeTuple(1, 1, CS_RESET), MakeTuple(1, 3, CS_RESET),
-        MakeTuple(2, 1, CS_RESET), MakeTuple(3, 1, CS_RESET),
-        MakeTuple(5, 1, CS_RESET), MakeTuple(8, 1, CS_RESET),
-        MakeTuple(15, 1, CS_RESET)));
+        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, 3, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(2, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(3, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(5, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(8, 1, END_OF_STREAM_RESET, CS_RESET),
+        // TODO(fischman): decoding more than 15 NALUs at once breaks decode -
+        // visual artifacts are introduced as well as spurious frames are
+        // delivered (more pictures are returned than NALUs are fed to the
+        // decoder).  Increase the "15" below when
+        // http://code.google.com/p/chrome-os-partner/issues/detail?id=4378 is
+        // fixed.
+        MakeTuple(15, 1, END_OF_STREAM_RESET, CS_RESET)));
 
 // Find out how many concurrent decoders can go before we exhaust system
 // resources.
 INSTANTIATE_TEST_CASE_P(
     ResourceExhaustion, OmxVideoDecodeAcceleratorTest,
     ::testing::Values(
         // +0 hack below to promote enum to int.
-        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 0, CS_RESET),
-        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1, CS_RESET)));
+        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 0,
+                  END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1,
+                  END_OF_STREAM_RESET, CS_RESET)));
 
 // TODO(fischman, vrk): add more tests!  In particular:
 // - Test life-cycle: Seek/Stop/Pause/Play/RePlay for a single decoder.
 // - Test alternate configurations
 // - Test failure conditions.
 // - Test frame size changes mid-stream
 
 }  // namespace
 
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);  // Removes gtest-specific args.
   CommandLine cmd_line(argc, argv);  // Must run after InitGoogleTest.
   CommandLine::SwitchMap switches = cmd_line.GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_video_data") {
       test_video_data = it->second.c_str();
       continue;
     }
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   return RUN_ALL_TESTS();
 }