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       : encoder_(encoder.Pass()),
  32         recorder_task_runner_(recorder_task_runner),
  33         recorder_(recorder),
  34         enable_recording_(false),
  35         weak_factory_(this) {
  36     DCHECK(encoder_);
  37     DCHECK(recorder_task_runner_.get());
  38   }
  39
  40   base::WeakPtr<RecordingVideoEncoder> AsWeakPtr() {
  41     return weak_factory_.GetWeakPtr();
  42   }
  43
  44   void SetEnableRecording(bool enable_recording) {
  45     DCHECK(!encoder_task_runner_.get() ||
  46            encoder_task_runner_->BelongsToCurrentThread());
  47     enable_recording_ = enable_recording;
  48   }
  49
  50   // remoting::VideoEncoder interface.
  51   virtual void SetLosslessEncode(bool want_lossless) OVERRIDE {
  52     encoder_->SetLosslessEncode(want_lossless);
  53   }
  54   virtual void SetLosslessColor(bool want_lossless) OVERRIDE {
  55     encoder_->SetLosslessColor(want_lossless);
  56   }
  57   virtual scoped_ptr<VideoPacket> Encode(
  58       const webrtc::DesktopFrame& frame) OVERRIDE {
  59     // If this is the first Encode() then store the TaskRunner and inform the
  60     // VideoFrameRecorder so it can post SetEnableRecording() on it.
  61     if (!encoder_task_runner_.get()) {
  62       encoder_task_runner_ = base::ThreadTaskRunnerHandle::Get();
  63       recorder_task_runner_->PostTask(FROM_HERE,
  64           base::Bind(&VideoFrameRecorder::SetEncoderTaskRunner,
  65                      recorder_,
  66                      encoder_task_runner_));
  67     }
  68
  69     DCHECK(encoder_task_runner_->BelongsToCurrentThread());
  70
  71     if (enable_recording_) {
  72       // Copy the frame and post it to the VideoFrameRecorder to store.
  73       scoped_ptr<webrtc::DesktopFrame> frame_copy(
  74           new webrtc::BasicDesktopFrame(frame.size()));
  75       *frame_copy->mutable_updated_region() = frame.updated_region();
  76       frame_copy->set_dpi(frame.dpi());
  77       frame_copy->CopyPixelsFrom(frame.data(),
  78                                  frame.stride(),
  79                                  webrtc::DesktopRect::MakeSize(frame.size()));
  80       recorder_task_runner_->PostTask(FROM_HERE,
  81           base::Bind(&VideoFrameRecorder::RecordFrame,
  82                      recorder_,
  83                      base::Passed(&frame_copy)));
  84     }
  85
  86     return encoder_->Encode(frame);
  87   }
  88
  89  private:
  90   scoped_ptr<VideoEncoder> encoder_;
  91   scoped_refptr<base::TaskRunner> recorder_task_runner_;
  92   base::WeakPtr<VideoFrameRecorder> recorder_;
  93
  94   bool enable_recording_;
  95   scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner_;
  96
  97   base::WeakPtrFactory<RecordingVideoEncoder> weak_factory_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(RecordingVideoEncoder);
 100 };
 101
 102 VideoFrameRecorder::VideoFrameRecorder()
 103     : content_bytes_(0),
 104       max_content_bytes_(0),
 105       enable_recording_(false),
 106       weak_factory_(this) {
 107 }
 108
 109 VideoFrameRecorder::~VideoFrameRecorder() {
 110   DetachVideoEncoderWrapper();
 111 }
 112
 113 scoped_ptr<VideoEncoder> VideoFrameRecorder::WrapVideoEncoder(
 114     scoped_ptr<VideoEncoder> encoder) {
 115   DCHECK(!encoder_task_runner_.get());
 116   DCHECK(!caller_task_runner_.get());
 117   caller_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 118
 119   scoped_ptr<RecordingVideoEncoder> recording_encoder(
 120       new RecordingVideoEncoder(encoder.Pass(),
 121                                 caller_task_runner_,
 122                                 weak_factory_.GetWeakPtr()));
 123   recording_encoder_ = recording_encoder->AsWeakPtr();
 124
 125   return recording_encoder.PassAs<VideoEncoder>();
 126 }
 127
 128 void VideoFrameRecorder::DetachVideoEncoderWrapper() {
 129   DCHECK(!caller_task_runner_.get() ||
 130          caller_task_runner_->BelongsToCurrentThread());
 131
 132   // Immediately detach the wrapper from this recorder.
 133   weak_factory_.InvalidateWeakPtrs();
 134
 135   // Clean up any pending recorded frames.
 136   STLDeleteElements(&recorded_frames_);
 137   content_bytes_ = 0;
 138
 139   // Tell the wrapper to stop recording and posting frames to us.
 140   if (encoder_task_runner_.get()) {
 141     encoder_task_runner_->PostTask(FROM_HERE,
 142         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
 143                    recording_encoder_, false));
 144   }
 145
 146   // Detach this recorder from the calling and encode threads.
 147   caller_task_runner_ = NULL;
 148   encoder_task_runner_ = NULL;
 149 }
 150
 151 void VideoFrameRecorder::SetEnableRecording(bool enable_recording) {
 152   DCHECK(!caller_task_runner_.get() ||
 153          caller_task_runner_->BelongsToCurrentThread());
 154
 155   if (enable_recording_ == enable_recording) {
 156     return;
 157   }
 158   enable_recording_ = enable_recording;
 159
 160   if (encoder_task_runner_.get()) {
 161     encoder_task_runner_->PostTask(FROM_HERE,
 162         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
 163                    recording_encoder_,
 164                    enable_recording_));
 165   }
 166 }
 167
 168 void VideoFrameRecorder::SetMaxContentBytes(int64_t max_content_bytes) {
 169   DCHECK(!caller_task_runner_.get() ||
 170          caller_task_runner_->BelongsToCurrentThread());
 171   DCHECK_GE(max_content_bytes, 0);
 172
 173   max_content_bytes_ = max_content_bytes;
 174 }
 175
 176 scoped_ptr<webrtc::DesktopFrame> VideoFrameRecorder::NextFrame() {
 177   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 178
 179   scoped_ptr<webrtc::DesktopFrame> frame;
 180   if (!recorded_frames_.empty()) {
 181     frame.reset(recorded_frames_.front());
 182     recorded_frames_.pop_front();
 183     content_bytes_ -= FrameContentSize(frame.get());
 184     DCHECK_GE(content_bytes_, 0);
 185   }
 186
 187   return frame.Pass();
 188 }
 189
 190 void VideoFrameRecorder::SetEncoderTaskRunner(
 191     scoped_refptr<base::TaskRunner> task_runner) {
 192   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 193   DCHECK(!encoder_task_runner_.get());
 194   DCHECK(task_runner.get());
 195
 196   encoder_task_runner_ = task_runner;
 197
 198   // If the caller already enabled recording, inform the recording encoder.
 199   if (enable_recording_ && encoder_task_runner_.get()) {
 200     encoder_task_runner_->PostTask(FROM_HERE,
 201         base::Bind(&RecordingVideoEncoder::SetEnableRecording,
 202                    recording_encoder_,
 203                    enable_recording_));
 204   }
 205 }
 206
 207 void VideoFrameRecorder::RecordFrame(scoped_ptr<webrtc::DesktopFrame> frame) {
 208   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 209
 210   int64_t frame_bytes = FrameContentSize(frame.get());
 211   DCHECK_GE(frame_bytes, 0);
 212
 213   // Purge existing frames until there is space for the new one.
 214   while (content_bytes_ + frame_bytes > max_content_bytes_ &&
 215          !recorded_frames_.empty()) {
 216     scoped_ptr<webrtc::DesktopFrame> drop_frame(recorded_frames_.front());
 217     recorded_frames_.pop_front();
 218     content_bytes_ -= FrameContentSize(drop_frame.get());
 219     DCHECK_GE(content_bytes_, 0);
 220   }
 221
 222   // If the frame is still too big, ignore it.
 223   if (content_bytes_ + frame_bytes > max_content_bytes_) {
 224     return;
 225   }
 226
 227   // Store the frame and update the content byte count.
 228   recorded_frames_.push_back(frame.release());
 229   content_bytes_ += frame_bytes;
 230 }
 231
 232 }  // namespace remoting