Enable fire-and-forget Destroy of HW video decoder, and misc other improvements.

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 182 matching lines @@
   CHECK(eglChooseConfig(egl_display_, rgba8888, &egl_config, 1, &num_configs))
       << eglGetError();
   CHECK_GE(num_configs, 1);
   static EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
   egl_context_ = eglCreateContext(
       egl_display_, egl_config, EGL_NO_CONTEXT, context_attribs);
   CHECK_NE(egl_context_, EGL_NO_CONTEXT) << eglGetError();
 
   // Per-window/surface X11 & EGL initialization.
   for (int i = 0; i < num_windows; ++i) {
-    // Arrange X windows side by side whimsically.
-    int top_left_x = (width + 50) * i;
-    int top_left_y = 100 + (i % 2) * 250;
+    // Arrange X windows whimsically, with some padding.
+    int top_left_x = (width + 20) * (i % 4);
+    int top_left_y = (height + 12) * (i % 3);
     Window x_window = XCreateWindow(
       x_display_, DefaultRootWindow(x_display_),
       top_left_x, top_left_y, width_, height_,
       0 /* border width */,
       depth, CopyFromParent /* class */, CopyFromParent /* visual */,
       (CWBackPixel | CWOverrideRedirect), &window_attributes);
     x_windows_.push_back(x_window);
     XStoreName(x_display_, x_window, "OmxVideoDecodeAcceleratorTest");
     XSelectInput(x_display_, x_window, ExposureMask);
     XMapWindow(x_display_, x_window);
@@ skipping 198 matching lines @@
       const gfx::Size& dimensions,
       VideoDecodeAccelerator::MemoryType type);
   virtual void DismissPictureBuffer(int32 picture_buffer_id);
   virtual void PictureReady(const media::Picture& picture);
   // Simple state changes.
   virtual void NotifyInitializeDone();
   virtual void NotifyEndOfStream();
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id);
   virtual void NotifyFlushDone();
   virtual void NotifyResetDone();
-  virtual void NotifyDestroyDone();
   virtual void NotifyError(VideoDecodeAccelerator::Error error);
 
   // Simple getters for inspecting the state of the Client.
   ClientState state() { return state_; }
   VideoDecodeAccelerator::Error error() { return error_; }
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_decoded_frames() { return num_decoded_frames_; }
   EGLDisplay egl_display() { return rendering_helper_->egl_display(); }
   EGLContext egl_context() { return rendering_helper_->egl_context(); }
   double frames_per_second();
-  bool decoder_deleted() { return !decoder_.get(); }
+  bool decoder_deleted() { return !decoder_; }
 
  private:
   typedef std::map<int, media::GLESBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
   // Compute & return in |*end_pos| the end position for the next batch of NALUs
   // 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_;
   const 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_ptr<OmxVideoDecodeAccelerator> decoder_;
+  scoped_refptr<OmxVideoDecodeAccelerator> decoder_;
   int delete_decoder_state_;
   ClientState state_;
   VideoDecodeAccelerator::Error error_;
   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,
                                              std::string* encoded_data,
                                              int num_NALUs_per_decode,
                                              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),
       state_(CS_CREATED),
       error_(VideoDecodeAccelerator::VIDEODECODERERROR_NONE),
       num_decoded_frames_(0), num_done_bitstream_buffers_(0) {
   CHECK_GT(num_NALUs_per_decode, 0);
 }
 
 EglRenderingVDAClient::~EglRenderingVDAClient() {
-  CHECK(!decoder_.get());
+  DeleteDecoder();  // Clean up in case of expected error.
+  CHECK(decoder_deleted());
   STLDeleteValues(&picture_buffers_by_id_);
   SetState(CS_DESTROYED);
 }
 
 void EglRenderingVDAClient::CreateDecoder() {
-  CHECK(!decoder_.get());
-  decoder_.reset(new OmxVideoDecodeAccelerator(this));
+  CHECK(decoder_deleted());
+  decoder_ = new OmxVideoDecodeAccelerator(this);
   decoder_->SetEglState(egl_display(), egl_context());
   SetState(CS_DECODER_SET);
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
 
   // Configure the decoder.
   int32 config_array[] = {
     media::VIDEOATTRIBUTEKEY_BITSTREAMFORMAT_FOURCC,
     media::VIDEOCODECFOURCC_H264,
     media::VIDEOATTRIBUTEKEY_VIDEOCOLORFORMAT, media::VIDEOCOLORFORMAT_RGBA,
   };
   std::vector<uint32> config(
       config_array, config_array + arraysize(config_array));
   CHECK(decoder_->Initialize(config));
 }
 
 
 void EglRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     VideoDecodeAccelerator::MemoryType type) {
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   CHECK_EQ(type, VideoDecodeAccelerator::PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
   std::vector<media::GLESBuffer> buffers;
   CHECK_EQ(dimensions.width(), kFrameWidth);
   CHECK_EQ(dimensions.height(), kFrameHeight);
 
   for (uint32 i = 0; i < requested_num_of_buffers; ++i) {
     uint32 id = picture_buffers_by_id_.size();
     GLuint texture_id;
     base::WaitableEvent done(false, false);
@@ skipping 15 matching lines @@
   DCHECK(it != picture_buffers_by_id_.end());
   rendering_helper_->DeleteTexture(it->second->texture_id());
   delete it->second;
   picture_buffers_by_id_.erase(it);
 }
 
 void EglRenderingVDAClient::PictureReady(const media::Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   DCHECK_LT(state_, CS_RESET);
 
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   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_;
@@ skipping 16 matching lines @@
   SetState(CS_DONE);
 }
 
 void EglRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   ++num_done_bitstream_buffers_;
   DecodeNextNALUs();
 }
 
 void EglRenderingVDAClient::NotifyFlushDone() {
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   SetState(CS_FLUSHED);
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   decoder_->Reset();
 }
 
 void EglRenderingVDAClient::NotifyResetDone() {
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   SetState(CS_RESET);
-  if (!decoder_.get())
-    return;
-  decoder_->Destroy();
-}
-
-void EglRenderingVDAClient::NotifyDestroyDone() {
-  SetState(CS_DESTROYED);
+  if (!decoder_deleted())
+    DeleteDecoder();
 }
 
 void EglRenderingVDAClient::NotifyError(VideoDecodeAccelerator::Error error) {
   SetState(CS_ERROR);
   error_ = error;
 }
 
 static bool LookingAtNAL(const std::string& encoded, size_t pos) {
   return pos + 3 < encoded.size() &&
       encoded[pos] == 0 && encoded[pos + 1] == 0 &&
       encoded[pos + 2] == 0 && encoded[pos + 3] == 1;
 }
 
 void EglRenderingVDAClient::SetState(ClientState new_state) {
   note_->Notify(new_state);
   state_ = new_state;
-  if (new_state == delete_decoder_state_)
+  if (new_state == delete_decoder_state_) {
+    CHECK(!decoder_deleted());
     DeleteDecoder();
+  }
 }
 
 void EglRenderingVDAClient::DeleteDecoder() {
-  decoder_.reset();
+  if (decoder_deleted())
+    return;
+  decoder_->Destroy();
+  decoder_ = NULL;
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
 void EglRenderingVDAClient::GetRangeForNextNALUs(
     size_t start_pos, size_t* end_pos) {
   *end_pos = start_pos;
   CHECK(LookingAtNAL(*encoded_data_, start_pos));
   for (int i = 0; i < num_NALUs_per_decode_; ++i) {
     *end_pos += 4;
     while (*end_pos + 3 < encoded_data_->size() &&
            !LookingAtNAL(*encoded_data_, *end_pos)) {
       ++*end_pos;
     }
     if (*end_pos + 3 >= encoded_data_->size()) {
       *end_pos = encoded_data_->size();
       return;
     }
   }
 }
 
 void EglRenderingVDAClient::DecodeNextNALUs() {
-  if (!decoder_.get())
+  if (decoder_deleted())
     return;
   if (encoded_data_next_pos_to_decode_ == encoded_data_->size()) {
     decoder_->Flush();
     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);
   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_;
-  CHECK_GT(delta.InSecondsF(), 0);
+  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.
 class OmxVideoDecodeAcceleratorTest
     : public ::testing::TestWithParam<Tuple3<int, int, 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;
@@ skipping 38 matching lines @@
     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.
+  bool saw_init_failure = false;
   for (size_t i = 0; i < num_concurrent_decoders; ++i) {
     ClientStateNotification* note = notes[i];
-    ASSERT_EQ(note->Wait(), CS_INITIALIZED);
+    ClientState state = note->Wait();
+    if (state != CS_INITIALIZED) {
+      saw_init_failure = true;
+      // We expect initialization to fail only when more than the supported
+      // number of decoders is instantiated.  Assert here that something else
+      // didn't trigger failure.
+      ASSERT_GT(num_concurrent_decoders, kMaxSupportedNumConcurrentDecoders);
+      continue;
+    }
+    ASSERT_EQ(state, CS_INITIALIZED);
     // InitializeDone kicks off decoding inside the client, so we just need to
     // wait for Flush.
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_FLUSHED));
     // FlushDone requests Reset().
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_RESET));
     // ResetDone requests Destroy().
     ASSERT_NO_FATAL_FAILURE(
         AssertWaitForStateOrDeleted(note, clients[i], CS_DESTROYED));
   }
+  ASSERT_EQ(saw_init_failure,
+            num_concurrent_decoders > kMaxSupportedNumConcurrentDecoders)
+      << num_concurrent_decoders;
   // Finally assert that decoding went as expected.
-  for (size_t i = 0; i < num_concurrent_decoders; ++i) {
+  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];
     EXPECT_EQ(client->num_decoded_frames(), 25 /* fps */ * 10 /* seconds */);
     // Hard-coded the number of NALUs in the stream.  Icky.
     EXPECT_EQ(client->num_done_bitstream_buffers(),
               ceil(258.0 / num_NALUs_per_decode));
     // These numbers are pulled out of a hat, but seem to be safe with current
@@ skipping 14 matching lines @@
                  &notes));
   rendering_thread.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&RenderingHelper::UnInitialize,
                  base::Unretained(&rendering_helper),
                  &done));
   done.Wait();
   rendering_thread.Stop();
 };
 
-// TODO(fischman): Remove DISABLED_ prefix when ~OVDA can tear down OMX
-// synchronously (http://crosbug.com/p/4869).
 INSTANTIATE_TEST_CASE_P(
-    DISABLED_TearDownTiming, OmxVideoDecodeAcceleratorTest,
+    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))));
 
-// TODO(fischman): using 2nd param of 16 and higher below breaks decode - visual
+// 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.
 INSTANTIATE_TEST_CASE_P(
     DecodeVariations, OmxVideoDecodeAcceleratorTest,
     ::testing::Values(
-        MakeTuple(1, 1, CS_DESTROYED), MakeTuple(1, 3, CS_DESTROYED),
-        MakeTuple(2, 1, CS_DESTROYED), MakeTuple(3, 1, CS_DESTROYED),
-        MakeTuple(5, 1, CS_DESTROYED), MakeTuple(8, 1, CS_DESTROYED),
-        MakeTuple(15, 1, CS_DESTROYED)));
+        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)));
+
+// 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)));
 
 // 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