Change VideoTrackRecorder to operate on a given task runner

content/renderer/media/video_track_recorder.cc

 // Copyright 2015 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/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 28 matching lines @@
 // Base class to describe a generic Encoder, encapsulating all actual encoder
 // (re)configurations, encoding and delivery of received frames. This class is
 // ref-counted to allow the MediaStreamVideoTrack to hold a reference to it (via
 // the callback that MediaStreamVideoSink passes along) and to jump back and
 // forth to an internal encoder thread. Moreover, this class:
 // - is created and destroyed on its parent's thread (usually the main Render
 // thread), |main_task_runner_|.
 // - receives VideoFrames on |origin_task_runner_| and runs OnEncodedVideoCB on
 // that thread as well. This task runner is cached on first frame arrival, and
 // is supposed to be the render IO thread (but this is not enforced);
-// - uses an internal |encoding_thread_| for actual encoder interactions, namely
-// configuration, encoding (which might take some time) and destruction.
+// - uses an internal |encoding_task_runner_| for actual encoder interactions,
+// namely configuration, encoding (which might take some time) and destruction.
+// This task runner can be passed on the creation. If nothing is passed, a new
+// encoding thread is created and used.
 class VideoTrackRecorder::Encoder : public base::RefCountedThreadSafe<Encoder> {
  public:
   Encoder(const OnEncodedVideoCB& on_encoded_video_callback,
-          int32_t bits_per_second)
+          int32_t bits_per_second,
+          scoped_refptr<base::SingleThreadTaskRunner> encoding_task_runner =
+              nullptr)
       : main_task_runner_(base::MessageLoop::current()->task_runner()),
-        encoding_thread_(new base::Thread("EncodingThread")),
+        encoding_task_runner_(encoding_task_runner),
         paused_(false),
         on_encoded_video_callback_(on_encoded_video_callback),
         bits_per_second_(bits_per_second) {
     DCHECK(!on_encoded_video_callback_.is_null());
+    if (!encoding_thread_) {

[mcasas, 2016/05/14 01:31:08]

if (encoding_task_runner_)
  return;

?

[emircan, 2016/05/16 19:45:27]

Done.

+      encoding_thread_.reset(new base::Thread("EncodingThread"));
+      encoding_thread_->Start();
+      encoding_task_runner_ = encoding_thread_->task_runner();
+    }
   }
 
   // Start encoding |frame|, returning via |on_encoded_video_callback_|. This
-  // call will also trigger a ConfigureEncoderOnEncodingThread() upon first
-  // frame arrival or parameter change, and an EncodeOnEncodingThread() to
+  // call will also trigger a ConfigureEncoderOnEncodingTaskRunner() upon first
+  // frame arrival or parameter change, and an EncodeOnEncodingTaskRunner() to
   // actually encode the frame.
   void StartFrameEncode(const scoped_refptr<VideoFrame>& frame,
                         base::TimeTicks capture_timestamp);
 
   void SetPaused(bool paused);
 
  protected:
   friend class base::RefCountedThreadSafe<Encoder>;
   virtual ~Encoder() {}
 
-  virtual void EncodeOnEncodingThread(const scoped_refptr<VideoFrame>& frame,
-                                      base::TimeTicks capture_timestamp) = 0;
-  virtual void ConfigureEncoderOnEncodingThread(const gfx::Size& size) = 0;
+  virtual void EncodeOnEncodingTaskRunner(
+      const scoped_refptr<VideoFrame>& frame,
+      base::TimeTicks capture_timestamp) = 0;
+  virtual void ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) = 0;
 
   // Used to shutdown properly on the same thread we were created.
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   // Task runner where frames to encode and reply callbacks must happen.
   scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
 
-  // Thread for encoding. Active for the lifetime of VpxEncoder.
+  // Task runner where encoding interactions happen.
+  scoped_refptr<base::SingleThreadTaskRunner> encoding_task_runner_;
+
+  // Optional thread for encoding. Active for the lifetime of VpxEncoder.
   std::unique_ptr<base::Thread> encoding_thread_;
 
   // While |paused_|, frames are not encoded. Used only from |encoding_thread_|.
   bool paused_;
 
   // This callback should be exercised on IO thread.
   const OnEncodedVideoCB on_encoded_video_callback_;
 
   // Target bitrate for video encoding. If 0, a standard bitrate is used.
   const int32_t bits_per_second_;
@@ skipping 15 matching lines @@
         video_frame->format() == media::PIXEL_FORMAT_YV12 ||
         video_frame->format() == media::PIXEL_FORMAT_YV12A)) {
     NOTREACHED();
     return;
   }
   scoped_refptr<media::VideoFrame> frame = video_frame;
   // Drop alpha channel since we do not support it yet.
   if (frame->format() == media::PIXEL_FORMAT_YV12A)
     frame = media::WrapAsI420VideoFrame(video_frame);
 
-  encoding_thread_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&Encoder::EncodeOnEncodingThread,
-                            this, frame, capture_timestamp));
+  encoding_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Encoder::EncodeOnEncodingTaskRunner, this, frame,
+                            capture_timestamp));
 }
 
 void VideoTrackRecorder::Encoder::SetPaused(bool paused) {
-  if (!encoding_thread_->task_runner()->BelongsToCurrentThread()) {
-    encoding_thread_->task_runner()->PostTask(
+  if (!encoding_task_runner_->BelongsToCurrentThread()) {
+    encoding_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Encoder::SetPaused, this, paused));
     return;
   }
   paused_ = paused;
 }
 
 namespace {
 
 // Originally from remoting/codec/scoped_vpx_codec.h.
 // TODO(mcasas): Refactor into a common location.
@@ skipping 33 matching lines @@
                               ScopedVpxCodecCtxPtr encoder);
 
   VpxEncoder(
       bool use_vp9,
       const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
       int32_t bits_per_second);
 
  private:
   // VideoTrackRecorder::Encoder
   ~VpxEncoder() override;
-  void EncodeOnEncodingThread(const scoped_refptr<VideoFrame>& frame,
+  void EncodeOnEncodingTaskRunner(const scoped_refptr<VideoFrame>& frame,
                               base::TimeTicks capture_timestamp) override;
-  void ConfigureEncoderOnEncodingThread(const gfx::Size& size) override;
+  void ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) override;
 
   // Returns true if |codec_config_| has been filled in at least once.
   bool IsInitialized() const;
 
   // Estimate the frame duration from |frame| and |last_frame_timestamp_|.
   base::TimeDelta EstimateFrameDuration(const scoped_refptr<VideoFrame>& frame);
 
   // Force usage of VP9 for encoding, instead of VP8 which is the default.
   const bool use_vp9_;
 
@@ skipping 29 matching lines @@
   static void ShutdownEncoder(std::unique_ptr<base::Thread> encoding_thread,
                               ScopedISVCEncoderPtr encoder);
 
   H264Encoder(
       const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
       int32_t bits_per_second);
 
  private:
   // VideoTrackRecorder::Encoder
   ~H264Encoder() override;
-  void EncodeOnEncodingThread(const scoped_refptr<VideoFrame>& frame,
+  void EncodeOnEncodingTaskRunner(const scoped_refptr<VideoFrame>& frame,
                               base::TimeTicks capture_timestamp) override;
-  void ConfigureEncoderOnEncodingThread(const gfx::Size& size) override;
+  void ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) override;
 
   // |openh264_encoder_| is a special scoped pointer to guarantee proper
   // destruction, also when reconfiguring due to parameters change. Only used on
   // |encoding_thread_|.
   gfx::Size configured_size_;
   ScopedISVCEncoderPtr openh264_encoder_;
 
   // The |VideoFrame::timestamp()| of the first received frame. Only used on
   // |encoding_thread_|.
   base::TimeTicks first_frame_timestamp_;
@@ skipping 11 matching lines @@
   // Both |encoding_thread| and |encoder| will be destroyed at end-of-scope.
 }
 
 VpxEncoder::VpxEncoder(
     bool use_vp9,
     const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second)
     : Encoder(on_encoded_video_callback, bits_per_second),
       use_vp9_(use_vp9) {
   codec_config_.g_timebase.den = 0;  // Not initialized.
-
-  DCHECK(!encoding_thread_->IsRunning());
-  encoding_thread_->Start();
+  DCHECK(encoding_thread_->IsRunning());
 }
 
 VpxEncoder::~VpxEncoder() {
   main_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&VpxEncoder::ShutdownEncoder,
                                          base::Passed(&encoding_thread_),
                                          base::Passed(&encoder_)));
 }
 
-void VpxEncoder::EncodeOnEncodingThread(const scoped_refptr<VideoFrame>& frame,
-                                        base::TimeTicks capture_timestamp) {
-  TRACE_EVENT0("video", "VpxEncoder::EncodeOnEncodingThread");
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+void VpxEncoder::EncodeOnEncodingTaskRunner(
+    const scoped_refptr<VideoFrame>& frame,
+    base::TimeTicks capture_timestamp) {
+  TRACE_EVENT0("video", "VpxEncoder::EncodeOnEncodingTaskRunner");
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   const gfx::Size frame_size = frame->visible_rect().size();
   if (!IsInitialized() ||
       gfx::Size(codec_config_.g_w, codec_config_.g_h) != frame_size) {
-    ConfigureEncoderOnEncodingThread(frame_size);
+    ConfigureEncoderOnEncodingTaskRunner(frame_size);
   }
 
   vpx_image_t vpx_image;
   vpx_image_t* const result = vpx_img_wrap(&vpx_image,
                                            VPX_IMG_FMT_I420,
                                            frame_size.width(),
                                            frame_size.height(),
                                            1  /* align */,
                                            frame->data(VideoFrame::kYPlane));
   DCHECK_EQ(result, &vpx_image);
@@ skipping 31 matching lines @@
   }
   origin_task_runner_->PostTask(FROM_HERE,
       base::Bind(OnFrameEncodeCompleted,
                  on_encoded_video_callback_,
                  frame,
                  base::Passed(&data),
                  capture_timestamp,
                  keyframe));
 }
 
-void VpxEncoder::ConfigureEncoderOnEncodingThread(const gfx::Size& size) {
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+void VpxEncoder::ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) {
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   if (IsInitialized()) {
     // TODO(mcasas) VP8 quirk/optimisation: If the new |size| is strictly less-
     // than-or-equal than the old size, in terms of area, the existing encoder
     // instance could be reused after changing |codec_config_.{g_w,g_h}|.
     DVLOG(1) << "Destroying/Re-Creating encoder for new frame size: "
              << gfx::Size(codec_config_.g_w, codec_config_.g_h).ToString()
              << " --> " << size.ToString() << (use_vp9_ ? " vp9" : " vp8");
     encoder_.reset();
   }
 
@@ skipping 68 matching lines @@
     // target time spent encoding the frame. Go from 8 to 5 (values for real
     // time encoding) depending on the amount of cores available in the system.
     const int kCpuUsed =
         std::max(5, 8 - base::SysInfo::NumberOfProcessors() / 2);
     result = vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, kCpuUsed);
     DLOG_IF(WARNING, VPX_CODEC_OK != result) << "VP8E_SET_CPUUSED failed";
   }
 }
 
 bool VpxEncoder::IsInitialized() const {
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   return codec_config_.g_timebase.den != 0;
 }
 
 base::TimeDelta VpxEncoder::EstimateFrameDuration(
     const scoped_refptr<VideoFrame>& frame) {
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   using base::TimeDelta;
   TimeDelta predicted_frame_duration;
   if (!frame->metadata()->GetTimeDelta(VideoFrameMetadata::FRAME_DURATION,
                                        &predicted_frame_duration) ||
       predicted_frame_duration <= TimeDelta()) {
     // The source of the video frame did not provide the frame duration.  Use
     // the actual amount of time between the current and previous frame as a
     // prediction for the next frame's duration.
     // TODO(mcasas): This duration estimation could lead to artifacts if the
@@ skipping 16 matching lines @@
                                   ScopedISVCEncoderPtr encoder) {
   DCHECK(encoding_thread->IsRunning());
   encoding_thread->Stop();
   // Both |encoding_thread| and |encoder| will be destroyed at end-of-scope.
 }
 
 H264Encoder::H264Encoder(
     const VideoTrackRecorder::OnEncodedVideoCB& on_encoded_video_callback,
     int32_t bits_per_second)
     : Encoder(on_encoded_video_callback, bits_per_second) {
-  DCHECK(!encoding_thread_->IsRunning());
-  encoding_thread_->Start();
+  DCHECK(encoding_thread_->IsRunning());
 }
 
 H264Encoder::~H264Encoder() {
   main_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&H264Encoder::ShutdownEncoder,
                                          base::Passed(&encoding_thread_),
                                          base::Passed(&openh264_encoder_)));
 }
 
-void H264Encoder::EncodeOnEncodingThread(const scoped_refptr<VideoFrame>& frame,
-                                         base::TimeTicks capture_timestamp) {
-  TRACE_EVENT0("video", "H264Encoder::EncodeOnEncodingThread");
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+void H264Encoder::EncodeOnEncodingTaskRunner(
+    const scoped_refptr<VideoFrame>& frame,
+    base::TimeTicks capture_timestamp) {
+  TRACE_EVENT0("video", "H264Encoder::EncodeOnEncodingTaskRunner");
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
   const gfx::Size frame_size = frame->visible_rect().size();
   if (!openh264_encoder_ || configured_size_ != frame_size) {
-    ConfigureEncoderOnEncodingThread(frame_size);
+    ConfigureEncoderOnEncodingTaskRunner(frame_size);
     first_frame_timestamp_ = capture_timestamp;
   }
 
   SSourcePicture picture = {};
   picture.iPicWidth = frame_size.width();
   picture.iPicHeight = frame_size.height();
   picture.iColorFormat = EVideoFormatType::videoFormatI420;
   picture.uiTimeStamp =
       (capture_timestamp - first_frame_timestamp_).InMilliseconds();
   picture.iStride[0] = frame->stride(VideoFrame::kYPlane);
@@ skipping 29 matching lines @@
     data->append(reinterpret_cast<char*>(layerInfo.pBsBuf), layer_len);
   }
 
   const bool is_key_frame = info.eFrameType == videoFrameTypeIDR;
   origin_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(OnFrameEncodeCompleted, on_encoded_video_callback_, frame,
                  base::Passed(&data), capture_timestamp, is_key_frame));
 }
 
-void H264Encoder::ConfigureEncoderOnEncodingThread(const gfx::Size& size) {
-  DCHECK(encoding_thread_->task_runner()->BelongsToCurrentThread());
+void H264Encoder::ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) {
+  DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   ISVCEncoder* temp_encoder = nullptr;
   if (WelsCreateSVCEncoder(&temp_encoder) != 0) {
     NOTREACHED() << "Failed to create OpenH264 encoder";
     return;
   }
   openh264_encoder_.reset(temp_encoder);
   configured_size_ = size;
 
 #if DCHECK_IS_ON()
   int trace_level = WELS_LOG_INFO;
@@ skipping 100 matching lines @@
   encoder_->SetPaused(false);
 }
 
 void VideoTrackRecorder::OnVideoFrameForTesting(
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   encoder_->StartFrameEncode(frame, timestamp);
 }
 
 }  // namespace content