remoting/host/video_frame_recorder.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/video_frame_recorder.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/stl_util.h"
  11 #include "base/thread_task_runner_handle.h"
  12 #include "remoting/codec/video_encoder.h"
  13 #include "remoting/proto/video.pb.h"
  14 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
  15 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
  16 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
  17
  18 namespace remoting {
  19
  20 static int64_t FrameContentSize(const webrtc::DesktopFrame* frame) {
  21   DCHECK_GT(frame->stride(), 0);
  22   return frame->stride() * frame->size().height();
  23 }
  24
  25 // VideoEncoder wrapper used to intercept frames passed to a real VideoEncoder.
  26 class VideoFrameRecorder::RecordingVideoEncoder : public VideoEncoder {
  27  public:
  28   RecordingVideoEncoder(scoped_ptr<VideoEncoder> encoder,
  29                         scoped_refptr<base::TaskRunner> recorder_task_runner,
  30                         base::WeakPtr<VideoFrameRecorder> recorder);
  31
  32   base::WeakPtr<RecordingVideoEncoder> AsWeakPtr();
  33
  34   void set_enable_recording(bool enable_recording) {
  35     DCHECK(!encoder_task_runner_.get() ||
  36            encoder_task_runner_->BelongsToCurrentThread());
  37     enable_recording_ = enable_recording;
  38   }
  39
  40   // remoting::VideoEncoder interface.
  41   void SetLosslessEncode(bool want_lossless) override;
  42   void SetLosslessColor(bool want_lossless) override;
  43   scoped_ptr<VideoPacket> Encode(const webrtc::DesktopFrame& frame) override;
  44
  45  private:
  46   scoped_ptr<VideoEncoder> encoder_;
  47   scoped_refptr<base::TaskRunner> recorder_task_runner_;
  48   base::WeakPtr<VideoFrameRecorder> recorder_;
  49
  50   bool enable_recording_;
  51   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
  52
  53   base::WeakPtrFactory<RecordingVideoEncoder> weak_factory_;
  54
  55   DISALLOW_COPY_AND_ASSIGN(RecordingVideoEncoder);
  56 };
  57
  58 VideoFrameRecorder::RecordingVideoEncoder::RecordingVideoEncoder(
  59     scoped_ptr<VideoEncoder> encoder,
  60     scoped_refptr<base::TaskRunner> recorder_task_runner,
  61     base::WeakPtr<VideoFrameRecorder> recorder)
  62     : encoder_(encoder.Pass()),
  63       recorder_task_runner_(recorder_task_runner),
  64       recorder_(recorder),
  65       enable_recording_(false),
  66       weak_factory_(this) {
  67   DCHECK(encoder_);
  68   DCHECK(recorder_task_runner_.get());
  69 }
  70
  71 base::WeakPtr<VideoFrameRecorder::RecordingVideoEncoder>
  72 VideoFrameRecorder::RecordingVideoEncoder::AsWeakPtr() {
  73   return weak_factory_.GetWeakPtr();
  74 }
  75
  76 void VideoFrameRecorder::RecordingVideoEncoder::SetLosslessEncode(
  77     bool want_lossless) {
  78   encoder_->SetLosslessEncode(want_lossless);
  79 }
  80
  81 void VideoFrameRecorder::RecordingVideoEncoder::SetLosslessColor(
  82     bool want_lossless) {
  83   encoder_->SetLosslessColor(want_lossless);
  84 }
  85
  86 scoped_ptr<VideoPacket> VideoFrameRecorder::RecordingVideoEncoder::Encode(
  87     const webrtc::DesktopFrame& frame) {
  88   // If this is the first Encode() then store the TaskRunner and inform the
  89   // VideoFrameRecorder so it can post set_enable_recording() on it.
  90   if (!encoder_task_runner_.get()) {
  91     encoder_task_runner_ = base::ThreadTaskRunnerHandle::Get();
  92     recorder_task_runner_->PostTask(FROM_HERE,
  93         base::Bind(&VideoFrameRecorder::SetEncoderTaskRunner,
  94                    recorder_,
  95                    encoder_task_runner_));
  96   }
  97
  98   DCHECK(encoder_task_runner_->BelongsToCurrentThread());
  99
 100   if (enable_recording_) {
 101     // Copy the frame and post it to the VideoFrameRecorder to store.
 102     scoped_ptr<webrtc::DesktopFrame> frame_copy(
 103         new webrtc::BasicDesktopFrame(frame.size()));
 104     *frame_copy->mutable_updated_region() = frame.updated_region();
 105     frame_copy->set_dpi(frame.dpi());
 106     frame_copy->CopyPixelsFrom(frame.data(),
 107                                frame.stride(),
 108                                webrtc::DesktopRect::MakeSize(frame.size()));
 109     recorder_task_runner_->PostTask(FROM_HERE,
 110         base::Bind(&VideoFrameRecorder::RecordFrame,
 111                    recorder_,
 112                    base::Passed(&frame_copy)));
 113   }
 114
 115   return encoder_->Encode(frame);
 116 }
 117
 118 VideoFrameRecorder::VideoFrameRecorder()
 119     : content_bytes_(0),
 120       max_content_bytes_(0),
 121       enable_recording_(false),
 122       weak_factory_(this) {
 123 }
 124
 125 VideoFrameRecorder::~VideoFrameRecorder() {
 126   DetachVideoEncoderWrapper();
 127 }
 128
 129 scoped_ptr<VideoEncoder> VideoFrameRecorder::WrapVideoEncoder(
 130     scoped_ptr<VideoEncoder> encoder) {
 131   DCHECK(!encoder_task_runner_.get());
 132   DCHECK(!caller_task_runner_.get());
 133   caller_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 134
 135   scoped_ptr<RecordingVideoEncoder> recording_encoder(
 136       new RecordingVideoEncoder(encoder.Pass(),
 137                                 caller_task_runner_,
 138                                 weak_factory_.GetWeakPtr()));
 139   recording_encoder_ = recording_encoder->AsWeakPtr();
 140
 141   return recording_encoder.Pass();
 142 }
 143
 144 void VideoFrameRecorder::DetachVideoEncoderWrapper() {
 145   DCHECK(!caller_task_runner_.get() ||
 146          caller_task_runner_->BelongsToCurrentThread());
 147
 148   // Immediately detach the wrapper from this recorder.
 149   weak_factory_.InvalidateWeakPtrs();
 150
 151   // Clean up any pending recorded frames.
 152   STLDeleteElements(&recorded_frames_);
 153   content_bytes_ = 0;
 154
 155   // Tell the wrapper to stop recording and posting frames to us.
 156   if (encoder_task_runner_.get()) {
 157     encoder_task_runner_->PostTask(FROM_HERE,
 158         base::Bind(&RecordingVideoEncoder::set_enable_recording,
 159                    recording_encoder_, false));
 160   }
 161
 162   // Detach this recorder from the calling and encode threads.
 163   caller_task_runner_ = nullptr;
 164   encoder_task_runner_ = nullptr;
 165 }
 166
 167 void VideoFrameRecorder::SetEnableRecording(bool enable_recording) {
 168   DCHECK(!caller_task_runner_.get() ||
 169          caller_task_runner_->BelongsToCurrentThread());
 170
 171   if (enable_recording_ == enable_recording) {
 172     return;
 173   }
 174   enable_recording_ = enable_recording;
 175
 176   if (encoder_task_runner_.get()) {
 177     encoder_task_runner_->PostTask(FROM_HERE,
 178         base::Bind(&RecordingVideoEncoder::set_enable_recording,
 179                    recording_encoder_,
 180                    enable_recording_));
 181   }
 182 }
 183
 184 void VideoFrameRecorder::SetMaxContentBytes(int64_t max_content_bytes) {
 185   DCHECK(!caller_task_runner_.get() ||
 186          caller_task_runner_->BelongsToCurrentThread());
 187   DCHECK_GE(max_content_bytes, 0);
 188
 189   max_content_bytes_ = max_content_bytes;
 190 }
 191
 192 scoped_ptr<webrtc::DesktopFrame> VideoFrameRecorder::NextFrame() {
 193   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 194
 195   scoped_ptr<webrtc::DesktopFrame> frame;
 196   if (!recorded_frames_.empty()) {
 197     frame.reset(recorded_frames_.front());
 198     recorded_frames_.pop_front();
 199     content_bytes_ -= FrameContentSize(frame.get());
 200     DCHECK_GE(content_bytes_, 0);
 201   }
 202
 203   return frame.Pass();
 204 }
 205
 206 void VideoFrameRecorder::SetEncoderTaskRunner(
 207     scoped_refptr<base::TaskRunner> task_runner) {
 208   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 209   DCHECK(!encoder_task_runner_.get());
 210   DCHECK(task_runner.get());
 211
 212   encoder_task_runner_ = task_runner;
 213
 214   // If the caller already enabled recording, inform the recording encoder.
 215   if (enable_recording_ && encoder_task_runner_.get()) {
 216     encoder_task_runner_->PostTask(FROM_HERE,
 217         base::Bind(&RecordingVideoEncoder::set_enable_recording,
 218                    recording_encoder_,
 219                    enable_recording_));
 220   }
 221 }
 222
 223 void VideoFrameRecorder::RecordFrame(scoped_ptr<webrtc::DesktopFrame> frame) {
 224   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 225
 226   int64_t frame_bytes = FrameContentSize(frame.get());
 227   DCHECK_GE(frame_bytes, 0);
 228
 229   // Purge existing frames until there is space for the new one.
 230   while (content_bytes_ + frame_bytes > max_content_bytes_ &&
 231          !recorded_frames_.empty()) {
 232     scoped_ptr<webrtc::DesktopFrame> drop_frame(recorded_frames_.front());
 233     recorded_frames_.pop_front();
 234     content_bytes_ -= FrameContentSize(drop_frame.get());
 235     DCHECK_GE(content_bytes_, 0);
 236   }
 237
 238   // If the frame is still too big, ignore it.
 239   if (content_bytes_ + frame_bytes > max_content_bytes_) {
 240     return;
 241   }
 242
 243   // Store the frame and update the content byte count.
 244   recorded_frames_.push_back(frame.release());
 245   content_bytes_ += frame_bytes;
 246 }
 247
 248 }  // namespace remoting