Cast: Enable use of VideoEncodeAccelerator for hardware video encoding

media/cast/video_sender/external_video_encoder.cc

 // Copyright 2014 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 "media/cast/video_sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/video/video_encode_accelerator.h"
 
+namespace media {
+namespace cast {
+class LocalVideoEncodeAcceleratorClient;
+}  // namespace cast
+}  // namespace media
+
 namespace {
-// We allocate more input buffers than what is asked for by
-// RequireBitstreamBuffers() due to potential threading timing.
-static const int kInputBufferExtraCount = 1;
 static const int kOutputBufferCount = 3;
 
 void LogFrameEncodedEvent(media::cast::CastEnvironment* const cast_environment,
                           const base::TimeTicks& capture_time) {
   cast_environment->Logging()->InsertFrameEvent(
       cast_environment->Clock()->NowTicks(),
       media::cast::kVideoFrameEncoded,
       media::cast::GetVideoRtpTimestamp(capture_time),
       media::cast::kFrameIdUnknown);
 }
+
+// Proxy this call to ExternalVideoEncoder on the cast main thread.
+void ProxyCreateVideoEncodeAccelerator(
+    const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
+    const base::WeakPtr<media::cast::ExternalVideoEncoder>& weak_ptr,
+    const media::cast::CreateVideoEncodeMemoryCallback&
+        create_video_encode_mem_cb,
+    scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
+    scoped_ptr<media::VideoEncodeAccelerator> vea) {
+  cast_environment->PostTask(
+      media::cast::CastEnvironment::MAIN,
+      FROM_HERE,
+      base::Bind(
+          &media::cast::ExternalVideoEncoder::OnCreateVideoEncodeAccelerator,
+          weak_ptr,
+          create_video_encode_mem_cb,
+          encoder_task_runner,
+          base::Passed(&vea)));
+}
 }  // namespace
 
 namespace media {
 namespace cast {
 
 // Container for the associated data of a video frame being processed.
 struct EncodedFrameReturnData {
   EncodedFrameReturnData(base::TimeTicks c_time,
                          VideoEncoder::FrameEncodedCallback callback) {
     capture_time = c_time;
     frame_encoded_callback = callback;
   }
   base::TimeTicks capture_time;
   VideoEncoder::FrameEncodedCallback frame_encoded_callback;
 };
 
 // The ExternalVideoEncoder class can be deleted directly by cast, while
 // LocalVideoEncodeAcceleratorClient stays around long enough to properly shut
 // down the VideoEncodeAccelerator.
 class LocalVideoEncodeAcceleratorClient
     : public VideoEncodeAccelerator::Client,
       public base::RefCountedThreadSafe<LocalVideoEncodeAcceleratorClient> {
  public:
   LocalVideoEncodeAcceleratorClient(
       scoped_refptr<CastEnvironment> cast_environment,
-      scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
+      scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
+      scoped_ptr<media::VideoEncodeAccelerator> vea,
+      const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
       const base::WeakPtr<ExternalVideoEncoder>& weak_owner)
       : cast_environment_(cast_environment),
-        gpu_factories_(gpu_factories),
-        encoder_task_runner_(gpu_factories->GetTaskRunner()),
+        encoder_task_runner_(encoder_task_runner),
+        video_encode_accelerator_(vea.Pass()),
+        create_video_encode_memory_cb_(create_video_encode_mem_cb),
         weak_owner_(weak_owner),
         last_encoded_frame_id_(kStartFrameId) {
     DCHECK(encoder_task_runner_);
   }
 
   // Initialize the real HW encoder.
   void Initialize(const VideoSenderConfig& video_config) {
-    DCHECK(gpu_factories_);
     DCHECK(encoder_task_runner_);
-
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
-    video_encode_accelerator_ =
-        gpu_factories_->CreateVideoEncodeAccelerator().Pass();
-    if (!video_encode_accelerator_)
-      return;
-
     VideoCodecProfile output_profile = media::VIDEO_CODEC_PROFILE_UNKNOWN;
     switch (video_config.codec) {
       case transport::kVp8:
         output_profile = media::VP8PROFILE_MAIN;
         break;
       case transport::kH264:
         output_profile = media::H264PROFILE_MAIN;
         break;
     }
     codec_ = video_config.codec;
@@ skipping 28 matching lines @@
   }
 
   void EncodeVideoFrame(
       const scoped_refptr<media::VideoFrame>& video_frame,
       const base::TimeTicks& capture_time,
       bool key_frame_requested,
       const VideoEncoder::FrameEncodedCallback& frame_encoded_callback) {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
-    if (input_buffers_free_.empty()) {
-      NOTREACHED();
-      VLOG(2) << "EncodeVideoFrame(): drop frame due to no hw buffers";
-      return;
-    }
-    const int index = input_buffers_free_.back();
-    base::SharedMemory* input_buffer = input_buffers_[index];
-
-    // TODO(pwestin): this allocation and copy can be removed once we don't
-    // pass the video frame through liblingle.
-
-    scoped_refptr<media::VideoFrame> frame =
-        media::VideoFrame::WrapExternalPackedMemory(
-            video_frame->format(),
-            video_frame->coded_size(),
-            video_frame->visible_rect(),
-            video_frame->natural_size(),
-            reinterpret_cast<uint8*>(input_buffer->memory()),
-            input_buffer->mapped_size(),
-            input_buffer->handle(),
-            video_frame->GetTimestamp(),
-            base::Bind(&LocalVideoEncodeAcceleratorClient::FinishedWithInBuffer,
-                       this,
-                       index));
-
-    if (!frame) {
-      VLOG(1) << "EncodeVideoFrame(): failed to create frame";
-      NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
-      return;
-    }
-    // Do a stride copy of the input frame to match the input requirements.
-    media::CopyYPlane(video_frame->data(VideoFrame::kYPlane),
-                      video_frame->stride(VideoFrame::kYPlane),
-                      video_frame->natural_size().height(),
-                      frame.get());
-    media::CopyUPlane(video_frame->data(VideoFrame::kUPlane),
-                      video_frame->stride(VideoFrame::kUPlane),
-                      video_frame->natural_size().height(),
-                      frame.get());
-    media::CopyVPlane(video_frame->data(VideoFrame::kVPlane),
-                      video_frame->stride(VideoFrame::kVPlane),
-                      video_frame->natural_size().height(),
-                      frame.get());
-
     encoded_frame_data_storage_.push_back(
         EncodedFrameReturnData(capture_time, frame_encoded_callback));
 
     // BitstreamBufferReady will be called once the encoder is done.
-    video_encode_accelerator_->Encode(frame, key_frame_requested);
+    video_encode_accelerator_->Encode(video_frame, key_frame_requested);
   }
 
  protected:
   virtual void NotifyInitializeDone() OVERRIDE {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
 
-    cast_environment_->PostTask(
-        CastEnvironment::MAIN,
-        FROM_HERE,
-        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_));
+    // Wait until shared memory is allocated to indicate that encoder is
+    // initialized.
   }
 
   virtual void NotifyError(VideoEncodeAccelerator::Error error) OVERRIDE {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     VLOG(1) << "ExternalVideoEncoder NotifyError: " << error;
 
     if (video_encode_accelerator_) {
       video_encode_accelerator_.release()->Destroy();
     }
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(&ExternalVideoEncoder::EncoderError, weak_owner_));
   }
 
   // Called to allocate the input and output buffers.
   virtual void RequireBitstreamBuffers(unsigned int input_count,
                                        const gfx::Size& input_coded_size,
                                        size_t output_buffer_size) OVERRIDE {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
     DCHECK(video_encode_accelerator_);
 
-    for (unsigned int i = 0; i < input_count + kInputBufferExtraCount; ++i) {
-      base::SharedMemory* shm =
-          gpu_factories_->CreateSharedMemory(media::VideoFrame::AllocationSize(
-              media::VideoFrame::I420, input_coded_size));
-      if (!shm) {
-        VLOG(1) << "RequireBitstreamBuffers(): failed to create input buffer ";
-        return;
-      }
-      input_buffers_.push_back(shm);
-      input_buffers_free_.push_back(i);
-    }
-
     for (int j = 0; j < kOutputBufferCount; ++j) {
-      base::SharedMemory* shm =
-          gpu_factories_->CreateSharedMemory(output_buffer_size);
-      if (!shm) {
-        VLOG(1) << "RequireBitstreamBuffers(): failed to create input buffer ";
-        return;
-      }
-      output_buffers_.push_back(shm);
-    }
-    // Immediately provide all output buffers to the VEA.
-    for (size_t i = 0; i < output_buffers_.size(); ++i) {
-      video_encode_accelerator_->UseOutputBitstreamBuffer(
-          media::BitstreamBuffer(static_cast<int32>(i),
-                                 output_buffers_[i]->handle(),
-                                 output_buffers_[i]->mapped_size()));
+      create_video_encode_memory_cb_.Run(
+          output_buffer_size,
+          base::Bind(&LocalVideoEncodeAcceleratorClient::OnCreateSharedMemory,
+                     this));
     }
   }
 
   // Encoder has encoded a frame and it's available in one of out output
   // buffers.
   virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
                                     size_t payload_size,
                                     bool key_frame) OVERRIDE {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 54 matching lines @@
 
     // We need to re-add the output buffer to the encoder after we are done
     // with it.
     video_encode_accelerator_->UseOutputBitstreamBuffer(media::BitstreamBuffer(
         bitstream_buffer_id,
         output_buffers_[bitstream_buffer_id]->handle(),
         output_buffers_[bitstream_buffer_id]->mapped_size()));
   }
 
  private:
-  // Encoder is done with the provided input buffer.
-  void FinishedWithInBuffer(int input_index) {
+  // Note: This method can be called on any thread.
+  void OnCreateSharedMemory(scoped_ptr<base::SharedMemory> memory) {
+    encoder_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&LocalVideoEncodeAcceleratorClient::ReceivedSharedMemory,
+                   this,
+                   base::Passed(&memory)));
+  }
+
+  void ReceivedSharedMemory(scoped_ptr<base::SharedMemory> memory) {
     DCHECK(encoder_task_runner_);
     DCHECK(encoder_task_runner_->RunsTasksOnCurrentThread());
-    DCHECK_GE(input_index, 0);
-    DCHECK_LT(input_index, static_cast<int>(input_buffers_.size()));
-    VLOG(2) << "EncodeFrameFinished(): index=" << input_index;
-    input_buffers_free_.push_back(input_index);
+
+    output_buffers_.push_back(memory.release());
+
+    // Wait until all requested buffers are received.
+    if (output_buffers_.size() < kOutputBufferCount)
+      return;
+
+    // Immediately provide all output buffers to the VEA.
+    for (size_t i = 0; i < output_buffers_.size(); ++i) {
+      video_encode_accelerator_->UseOutputBitstreamBuffer(
+          media::BitstreamBuffer(static_cast<int32>(i),
+                                 output_buffers_[i]->handle(),
+                                 output_buffers_[i]->mapped_size()));
+    }
+
+    cast_environment_->PostTask(
+        CastEnvironment::MAIN,
+        FROM_HERE,
+        base::Bind(&ExternalVideoEncoder::EncoderInitialized, weak_owner_));
   }
 
   friend class base::RefCountedThreadSafe<LocalVideoEncodeAcceleratorClient>;
 
   virtual ~LocalVideoEncodeAcceleratorClient() {}
 
   const scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories_;
   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
+  scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
+  const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
   const base::WeakPtr<ExternalVideoEncoder> weak_owner_;
-
-  scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   int max_frame_rate_;
   transport::VideoCodec codec_;
   uint32 last_encoded_frame_id_;
 
-  // Shared memory buffers for input/output with the VideoAccelerator.
-  ScopedVector<base::SharedMemory> input_buffers_;
+  // Shared memory buffers for output with the VideoAccelerator.
   ScopedVector<base::SharedMemory> output_buffers_;
 
-  // Input buffers ready to be filled with input from Encode(). As a LIFO since
-  // we don't care about ordering.
-  std::vector<int> input_buffers_free_;
-
   // FIFO list.
   std::list<EncodedFrameReturnData> encoded_frame_data_storage_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalVideoEncodeAcceleratorClient);
 };
 
 ExternalVideoEncoder::ExternalVideoEncoder(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
-    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories)
+    const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
+    const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb)
     : video_config_(video_config),
       cast_environment_(cast_environment),
       encoder_active_(false),
       key_frame_requested_(false),
       skip_next_frame_(false),
       skip_count_(0),
-      encoder_task_runner_(gpu_factories->GetTaskRunner()),
       weak_factory_(this) {
-  DCHECK(gpu_factories);
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
-  video_accelerator_client_ = new LocalVideoEncodeAcceleratorClient(
-      cast_environment, gpu_factories, weak_factory_.GetWeakPtr());
 
-  encoder_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&LocalVideoEncodeAcceleratorClient::Initialize,
-                 video_accelerator_client_,
-                 video_config));
+  create_vea_cb.Run(base::Bind(&ProxyCreateVideoEncodeAccelerator,
+                               cast_environment,
+                               weak_factory_.GetWeakPtr(),
+                               create_video_encode_mem_cb));
 }
 
 ExternalVideoEncoder::~ExternalVideoEncoder() {
   encoder_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalVideoEncodeAcceleratorClient::Destroy,
                  video_accelerator_client_));
 }
 
 void ExternalVideoEncoder::EncoderInitialized() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   encoder_active_ = true;
 }
 
 void ExternalVideoEncoder::EncoderError() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   encoder_active_ = false;
 }
 
+void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
+    const CreateVideoEncodeMemoryCallback& create_video_encode_mem_cb,
+    scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
+    scoped_ptr<media::VideoEncodeAccelerator> vea) {
+  DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
+  encoder_task_runner_ = encoder_task_runner;
+
+  video_accelerator_client_ =
+      new LocalVideoEncodeAcceleratorClient(cast_environment_,
+                                            encoder_task_runner,
+                                            vea.Pass(),
+                                            create_video_encode_mem_cb,
+                                            weak_factory_.GetWeakPtr());
+  encoder_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LocalVideoEncodeAcceleratorClient::Initialize,
+                 video_accelerator_client_,
+                 video_config_));
+}
+
 bool ExternalVideoEncoder::EncodeVideoFrame(
     const scoped_refptr<media::VideoFrame>& video_frame,
     const base::TimeTicks& capture_time,
     const FrameEncodedCallback& frame_encoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   if (!encoder_active_)
     return false;
 
   if (skip_next_frame_) {
@@ skipping 48 matching lines @@
   // Do nothing not supported.
 }
 
 int ExternalVideoEncoder::NumberOfSkippedFrames() const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   return skip_count_;
 }
 
 }  //  namespace cast
 }  //  namespace media