Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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/GLES2,GLX/GL} or
 //   Win/EGL.
 // - 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
@@ skipping 198 matching lines @@
                       double fps,
                       ReusePictureCB reuse_picture_cb);
   virtual ~ThrottlingVDAClient();
 
   // VideoDecodeAccelerator::Client implementation
   virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
                                      const gfx::Size& dimensions,
                                      uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
-  virtual void NotifyInitializeDone() OVERRIDE;
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
   virtual void NotifyFlushDone() OVERRIDE;
   virtual void NotifyResetDone() OVERRIDE;
   virtual void NotifyError(VideoDecodeAccelerator::Error error) OVERRIDE;
 
   int num_decoded_frames() { return num_decoded_frames_; }
 
  private:
 
   void CallClientPictureReady(int version);
@@ skipping 75 matching lines @@
   if (!pending_pictures_.empty()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ThrottlingVDAClient::CallClientPictureReady,
                    AsWeakPtr(),
                    stream_version_),
         next_frame_delivered_time_ - base::TimeTicks::Now());
   }
 }
 
-void ThrottlingVDAClient::NotifyInitializeDone() {
-  client_->NotifyInitializeDone();
-}
-
 void ThrottlingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   client_->NotifyEndOfBitstreamBuffer(bitstream_buffer_id);
 }
 
 void ThrottlingVDAClient::NotifyFlushDone() {
   if (!pending_pictures_.empty()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ThrottlingVDAClient::NotifyFlushDone,
@@ skipping 61 matching lines @@
   void CreateAndStartDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   virtual void ProvidePictureBuffers(uint32 requested_num_of_buffers,
                                      const gfx::Size& dimensions,
                                      uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   // Simple state changes.
-  virtual void NotifyInitializeDone() OVERRIDE;
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id) OVERRIDE;
   virtual void NotifyFlushDone() OVERRIDE;
   virtual void NotifyResetDone() OVERRIDE;
   virtual void NotifyError(VideoDecodeAccelerator::Error error) OVERRIDE;
 
   void OutputFrameDeliveryTimes(base::File* output);
 
   void NotifyFrameDropped(int32 picture_buffer_id);
 
   // Simple getters for inspecting the state of the Client.
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_skipped_fragments() { return num_skipped_fragments_; }
   int num_queued_fragments() { return num_queued_fragments_; }
   int num_decoded_frames();
   double frames_per_second();
   // Return the median of the decode time in milliseconds.
   int decode_time_median();
   bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
+  void FinishInitialization();
 
   // Delete the associated decoder helper.
   void DeleteDecoder();
 
   // Compute & return the first encoded bytes (including a start frame) to send
   // to the decoder, starting at |start_pos| and returning one fragment. Skips
   // to the first decodable position.
   std::string GetBytesForFirstFragment(size_t start_pos, size_t* end_pos);
   // Compute & return the encoded bytes of next fragment to send to the decoder
   // (based on |start_pos|).
   std::string GetBytesForNextFragment(size_t start_pos, size_t* end_pos);
   // Helpers for GetBytesForNextFragment above.
   void GetBytesForNextNALU(size_t start_pos, size_t* end_pos);  // For h.264.
   std::string GetBytesForNextFrame(
       size_t start_pos, size_t* end_pos);  // For VP8.
 
   // Request decode of the next fragment in the encoded data.
   void DecodeNextFragment();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification<ClientState>* note_;
   scoped_ptr<VideoDecodeAccelerator> decoder_;
+  scoped_ptr<base::WeakPtrFactory<VideoDecodeAccelerator> >
+      weak_decoder_factory_;
   std::set<int> outstanding_texture_ids_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_skipped_fragments_;
   int num_queued_fragments_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
@@ skipping 106 matching lines @@
       device.Pass(),
       base::MessageLoopProxy::current()));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   CHECK_EQ(gfx::kGLImplementationDesktopGL, gfx::GetGLImplementation())
       << "Hardware video decode does not work with OSMesa";
   decoder_.reset(new VaapiVideoDecodeAccelerator(
       static_cast<Display*>(rendering_helper_->GetGLDisplay()),
       base::Bind(&DoNothingReturnTrue)));
 #endif  // OS_WIN
   CHECK(decoder_.get());
+  weak_decoder_factory_.reset(
+      new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
   SetState(CS_DECODER_SET);
   if (decoder_deleted())
     return;
 
   CHECK(decoder_->Initialize(profile_, client));
+  FinishInitialization();
 }
 
 void GLRenderingVDAClient::ProvidePictureBuffers(
     uint32 requested_num_of_buffers,
     const gfx::Size& dimensions,
     uint32 texture_target) {
   if (decoder_deleted())
     return;
   std::vector<media::PictureBuffer> buffers;
 
@@ skipping 59 matching lines @@
   CHECK(picture_buffer);
   if (!suppress_rendering_) {
     rendering_helper_->RenderTexture(texture_target_,
                                      picture_buffer->texture_id());
   }
 
   if (num_decoded_frames() > delay_reuse_after_frame_num_) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&VideoDecodeAccelerator::ReusePictureBuffer,
-                   decoder_->AsWeakPtr(),
+                   weak_decoder_factory_->GetWeakPtr(),
                    picture.picture_buffer_id()),
         kReuseDelay);
   } else {
     decoder_->ReusePictureBuffer(picture.picture_buffer_id());
   }
 }
 
-void GLRenderingVDAClient::NotifyInitializeDone() {
-  SetState(CS_INITIALIZED);
-  initialize_done_ticks_ = base::TimeTicks::Now();
-
-  if (reset_after_frame_num_ == START_OF_STREAM_RESET) {
-    reset_after_frame_num_ = MID_STREAM_RESET;
-    decoder_->Reset();
-    return;
-  }
-
-  for (int i = 0; i < num_in_flight_decodes_; ++i)
-    DecodeNextFragment();
-  DCHECK_EQ(outstanding_decodes_, num_in_flight_decodes_);
-}
-
 void GLRenderingVDAClient::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   // TODO(fischman): this test currently relies on this notification to make
   // forward progress during a Reset().  But the VDA::Reset() API doesn't
   // guarantee this, so stop relying on it (and remove the notifications from
   // VaapiVideoDecodeAccelerator::FinishReset()).
   ++num_done_bitstream_buffers_;
   --outstanding_decodes_;
   if (decode_calls_per_second_ == 0)
     DecodeNextFragment();
@@ skipping 21 matching lines @@
     return;
   } else if (reset_after_frame_num_ == START_OF_STREAM_RESET) {
     reset_after_frame_num_ = END_OF_STREAM_RESET;
     for (int i = 0; i < num_in_flight_decodes_; ++i)
       DecodeNextFragment();
     return;
   }
 
   if (remaining_play_throughs_) {
     encoded_data_next_pos_to_decode_ = 0;
-    NotifyInitializeDone();
+    FinishInitialization();
     return;
   }
 
   SetState(CS_RESET);
   if (!decoder_deleted())
     DeleteDecoder();
 }
 
 void GLRenderingVDAClient::NotifyError(VideoDecodeAccelerator::Error error) {
   SetState(CS_ERROR);
@@ skipping 24 matching lines @@
 
 void GLRenderingVDAClient::SetState(ClientState new_state) {
   note_->Notify(new_state);
   state_ = new_state;
   if (!remaining_play_throughs_ && new_state == delete_decoder_state_) {
     CHECK(!decoder_deleted());
     DeleteDecoder();
   }
 }
 
+void GLRenderingVDAClient::FinishInitialization() {
+  SetState(CS_INITIALIZED);
+  initialize_done_ticks_ = base::TimeTicks::Now();
+
+  if (reset_after_frame_num_ == START_OF_STREAM_RESET) {
+    reset_after_frame_num_ = MID_STREAM_RESET;
+    decoder_->Reset();
+    return;
+  }
+
+  for (int i = 0; i < num_in_flight_decodes_; ++i)
+    DecodeNextFragment();
+  DCHECK_EQ(outstanding_decodes_, num_in_flight_decodes_);
+}
+
 void GLRenderingVDAClient::DeleteDecoder() {
   if (decoder_deleted())
     return;
+  weak_decoder_factory_.reset();
   decoder_.release()->Destroy();
   STLClearObject(&encoded_data_);
   for (std::set<int>::iterator it = outstanding_texture_ids_.begin();
        it != outstanding_texture_ids_.end(); ++it) {
     rendering_helper_->DeleteTexture(*it);
   }
   outstanding_texture_ids_.clear();
   // 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));
@@ skipping 784 matching lines @@
     }
     if (it->first == "v" || it->first == "vmodule")
       continue;
     LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
   }
 
   base::ShadowingAtExitManager at_exit_manager;
 
   return RUN_ALL_TESTS();
 }