Support queuing input buffers when OMX's buffer list is exhausted.

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 444 matching lines @@
   // 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 num_in_flight_decodes,
                         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);
@@ skipping 28 matching lines @@
   // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
   void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
 
   // Request decode of the next batch of NALUs in the encoded data.
   void DecodeNextNALUs();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_NALUs_per_decode_;
+  const int num_in_flight_decodes_;
+  int outstanding_decodes_;
   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 num_in_flight_decodes,
     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),
+      num_in_flight_decodes_(num_in_flight_decodes), outstanding_decodes_(0),
       encoded_data_next_pos_to_decode_(0), next_bitstream_buffer_id_(0),
       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);
+  CHECK_GT(num_in_flight_decodes, 0);
 }
 
 EglRenderingVDAClient::~EglRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
 }
 
 void EglRenderingVDAClient::CreateDecoder() {
@@ skipping 77 matching lines @@
       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);
   initialize_done_ticks_ = base::TimeTicks::Now();
-  DecodeNextNALUs();
+  for (int i = 0; i < num_in_flight_decodes_; ++i)
+    DecodeNextNALUs();
 }
 
 void EglRenderingVDAClient::NotifyEndOfStream() {
   SetState(CS_DONE);
 }
 
 void EglRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   ++num_done_bitstream_buffers_;
+  --outstanding_decodes_;
   DecodeNextNALUs();
 }
 
 void EglRenderingVDAClient::NotifyFlushDone() {
   if (decoder_deleted())
     return;
   SetState(CS_FLUSHED);
   if (decoder_deleted())
     return;
   decoder_->Reset();
@@ skipping 61 matching lines @@
       *end_pos = encoded_data_.size();
       return;
     }
   }
 }
 
 void EglRenderingVDAClient::DecodeNextNALUs() {
   if (decoder_deleted())
     return;
   if (encoded_data_next_pos_to_decode_ == encoded_data_.size()) {
-    decoder_->Flush();
-    SetState(CS_FLUSHING);
+    if (outstanding_decodes_ == 0) {
+      decoder_->Flush();
+      SetState(CS_FLUSHING);
+    }
     return;
   }
   size_t start_pos = encoded_data_next_pos_to_decode_;
   size_t end_pos;
   GetRangeForNextNALUs(start_pos, &end_pos);
 
   // Populate the shared memory buffer w/ the NALU, duplicate its handle, and
   // hand it off to the decoder.
   base::SharedMemory shm;
   CHECK(shm.CreateAndMapAnonymous(end_pos - start_pos))
       << start_pos << ", " << end_pos;
   memcpy(shm.memory(), encoded_data_.data() + start_pos, end_pos - start_pos);
   base::SharedMemoryHandle dup_handle;
   CHECK(shm.ShareToProcess(base::Process::Current().handle(), &dup_handle));
   media::BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_++, dup_handle, end_pos - start_pos);
   decoder_->Decode(bitstream_buffer);
+  ++outstanding_decodes_;
   encoded_data_next_pos_to_decode_ = end_pos;
 
   if (-delete_decoder_state_ == next_bitstream_buffer_id_)
     DeleteDecoder();
 }
 
 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 in-flight Decode() calls per decoder.

[vrk (LEFT CHROMIUM), 2011/08/12 20:56:59]

nit: order of params is wrong (should be 3rd param)

 // - Number of concurrent decoders.
 // - reset_after_frame_num: see EglRenderingVDAClient ctor.
 // - delete_decoder_phase: see EglRenderingVDAClient ctor.
 class OmxVideoDecodeAcceleratorTest
     : public ::testing::TestWithParam<
-        Tuple4<int, int, ResetPoint, ClientState> > {
+  Tuple5<int, 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 reset_after_frame_num = GetParam().c;
-  const int delete_decoder_state = GetParam().d;
+  const size_t num_in_flight_decodes = GetParam().c;
+  const int reset_after_frame_num = GetParam().d;
+  const int delete_decoder_state = GetParam().e;
 
   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;
 
@@ skipping 27 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,
+        num_in_flight_decodes,
         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);
   }
@@ skipping 63 matching lines @@
                  &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)));
+        MakeTuple(1, 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, END_OF_STREAM_RESET, CS_DECODER_SET),
-        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_INITIALIZED),
-        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_FLUSHING),
-        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_FLUSHED),
-        MakeTuple(1, 1, END_OF_STREAM_RESET, CS_RESETTING),
-        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))));
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_DECODER_SET),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_INITIALIZED),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHING),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_FLUSHED),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESETTING),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-1)),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, static_cast<ClientState>(-10)),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET,
+                  static_cast<ClientState>(-100))));
 
 // 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, 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),
+        MakeTuple(1, 1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, 1, 10, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(1, 1, 15, END_OF_STREAM_RESET, CS_RESET),  // Tests queuing.
+        MakeTuple(1, 3, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(2, 1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(3, 1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(5, 1, 1, END_OF_STREAM_RESET, CS_RESET),
+        MakeTuple(8, 1, 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)));
+        MakeTuple(15, 1, 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,
+        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 0, 1,
                   END_OF_STREAM_RESET, CS_RESET),
-        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1,
+        MakeTuple(1, kMaxSupportedNumConcurrentDecoders + 1, 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();
 }