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

content/renderer/media/rtc_video_encoder.cc

 // Copyright 2013 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.
 
 #include "content/renderer/media/rtc_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 57 matching lines @@
   void UseOutputBitstreamBufferId(int32 bitstream_buffer_id);
 
   // Request encoding parameter change for the underlying encoder.
   void RequestEncodingParametersChange(uint32 bitrate, uint32 framerate);
 
   // Destroy this Impl's encoder.  The destructor is not explicitly called, as
   // Impl is a base::RefCountedThreadSafe.
   void Destroy();
 
   // media::VideoEncodeAccelerator::Client implementation.
-  virtual void NotifyInitializeDone() OVERRIDE;
   virtual void RequireBitstreamBuffers(unsigned int input_count,
                                        const gfx::Size& input_coded_size,
                                        size_t output_buffer_size) OVERRIDE;
   virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
                                     size_t payload_size,
                                     bool key_frame) OVERRIDE;
   virtual void NotifyError(media::VideoEncodeAccelerator::Error error) OVERRIDE;
 
  private:
   friend class base::RefCountedThreadSafe<Impl>;
@@ skipping 96 matching lines @@
     NOTIFY_ERROR(media::VideoEncodeAccelerator::kInvalidArgumentError);
     return;
   }
 
   video_encoder_ = gpu_factories_->CreateVideoEncodeAccelerator().Pass();
   if (!video_encoder_) {
     NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   input_visible_size_ = input_visible_size;
-  video_encoder_->Initialize(media::VideoFrame::I420,
-                             input_visible_size_,
-                             profile,
-                             bitrate * 1000,
-                             this);
+  if (!video_encoder_->Initialize(media::VideoFrame::I420,
+                                  input_visible_size_,
+                                  profile,
+                                  bitrate * 1000,
+                                  this)) {
+    NOTIFY_ERROR(media::VideoEncodeAccelerator::kInvalidArgumentError);
+    return;
+  }
 }
 
 void RTCVideoEncoder::Impl::Enqueue(const webrtc::I420VideoFrame* input_frame,
                                     bool force_keyframe,
                                     base::WaitableEvent* async_waiter,
                                     int32_t* async_retval) {
   DVLOG(3) << "Impl::Enqueue()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!input_next_frame_);
 
   RegisterAsyncWaiter(async_waiter, async_retval);
   // If there are no free input and output buffers, drop the frame to avoid a

[Ami GONE FROM CHROMIUM, 2014/03/18 23:53:19]

Didn't a brilliant (and handsome!) man once tell you not to rebase while there
are outstanding comments?  Pretty sure that happened...

[sheu, 2014/03/19 20:38:24]

:-(

Forgot about my Monday morning sync/rebase.

   // deadlock. If there is a free input buffer, EncodeOneFrame will run and
   // unblock Encode(). If there are no free input buffers but there is a free
   // output buffer, EncodeFrameFinished will be called later to unblock
   // Encode().
   //
   // The caller of Encode() holds a webrtc lock. The deadlock happens when:
   // (1) Encode() is waiting for the frame to be encoded in EncodeOneFrame().
   // (2) There are no free input buffers and they cannot be freed because
   //     the encoder has no output buffers.
   // (3) Output buffers cannot be freed because ReturnEncodedImage is queued
@@ skipping 46 matching lines @@
     video_encoder_->RequestEncodingParametersChange(bitrate * 1000, framerate);
 }
 
 void RTCVideoEncoder::Impl::Destroy() {
   DVLOG(3) << "Impl::Destroy()";
   DCHECK(thread_checker_.CalledOnValidThread());
   if (video_encoder_)
     video_encoder_.release()->Destroy();
 }
 
-void RTCVideoEncoder::Impl::NotifyInitializeDone() {
-  DVLOG(3) << "Impl::NotifyInitializeDone()";
-  DCHECK(thread_checker_.CalledOnValidThread());
-}
-
 void RTCVideoEncoder::Impl::RequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_buffer_size) {
   DVLOG(3) << "Impl::RequireBitstreamBuffers(): input_count=" << input_count
            << ", input_coded_size=" << input_coded_size.ToString()
            << ", output_buffer_size=" << output_buffer_size;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!video_encoder_)
@@ skipping 397 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
                         init_retval == WEBRTC_VIDEO_CODEC_OK);
   if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
     UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
                               video_codec_profile_,
                               media::VIDEO_CODEC_PROFILE_MAX + 1);
   }
 }
 
 }  // namespace content