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 403 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());
+  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
@@ skipping 141 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
 // 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)));
 
 // 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