remoting/client/plugin/pepper_view.cc

   1 // Copyright (c) 2012 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/client/plugin/pepper_view.h"
   6
   7 #include <functional>
   8
   9 #include "base/message_loop.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/synchronization/waitable_event.h"
  12 #include "base/time/time.h"
  13 #include "ppapi/cpp/completion_callback.h"
  14 #include "ppapi/cpp/dev/graphics_2d_dev.h"
  15 #include "ppapi/cpp/dev/view_dev.h"
  16 #include "ppapi/cpp/image_data.h"
  17 #include "ppapi/cpp/point.h"
  18 #include "ppapi/cpp/rect.h"
  19 #include "ppapi/cpp/size.h"
  20 #include "remoting/base/util.h"
  21 #include "remoting/client/chromoting_stats.h"
  22 #include "remoting/client/client_context.h"
  23 #include "remoting/client/frame_producer.h"
  24 #include "remoting/client/plugin/chromoting_instance.h"
  25 #include "remoting/client/plugin/pepper_util.h"
  26
  27 using base::Passed;
  28
  29 namespace remoting {
  30
  31 namespace {
  32
  33 // The maximum number of image buffers to be allocated at any point of time.
  34 const size_t kMaxPendingBuffersCount = 2;
  35
  36 }  // namespace
  37
  38 PepperView::PepperView(ChromotingInstance* instance,
  39                        ClientContext* context,
  40                        FrameProducer* producer)
  41   : instance_(instance),
  42     context_(context),
  43     producer_(producer),
  44     merge_buffer_(NULL),
  45     merge_clip_area_(SkIRect::MakeEmpty()),
  46     dips_size_(SkISize::Make(0, 0)),
  47     dips_to_device_scale_(1.0f),
  48     view_size_(SkISize::Make(0, 0)),
  49     dips_to_view_scale_(1.0f),
  50     clip_area_(SkIRect::MakeEmpty()),
  51     source_size_(SkISize::Make(0, 0)),
  52     source_dpi_(SkIPoint::Make(0, 0)),
  53     flush_pending_(false),
  54     is_initialized_(false),
  55     frame_received_(false) {
  56   InitiateDrawing();
  57 }
  58
  59 PepperView::~PepperView() {
  60   // The producer should now return any pending buffers. At this point, however,
  61   // ReturnBuffer() tasks scheduled by the producer will not be delivered,
  62   // so we free all the buffers once the producer's queue is empty.
  63   base::WaitableEvent done_event(true, false);
  64   producer_->RequestReturnBuffers(
  65       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
  66   done_event.Wait();
  67
  68   merge_buffer_ = NULL;
  69   while (!buffers_.empty()) {
  70     FreeBuffer(buffers_.front());
  71   }
  72 }
  73
  74 void PepperView::SetView(const pp::View& view) {
  75   bool view_changed = false;
  76
  77   pp::Rect pp_size = view.GetRect();
  78   SkISize new_dips_size = SkISize::Make(pp_size.width(), pp_size.height());
  79   pp::ViewDev view_dev(view);
  80   float new_dips_to_device_scale = view_dev.GetDeviceScale();
  81
  82   if (dips_size_ != new_dips_size ||
  83       dips_to_device_scale_ != new_dips_to_device_scale) {
  84     view_changed = true;
  85     dips_to_device_scale_ = new_dips_to_device_scale;
  86     dips_size_ = new_dips_size;
  87
  88     // If |dips_to_device_scale_| is > 1.0 then the device is high-DPI, and
  89     // there are actually |view_device_scale_| physical pixels for every one
  90     // Density Independent Pixel (DIP).  If we specify a scale of 1.0 to
  91     // Graphics2D then we can render at DIP resolution and let PPAPI up-scale
  92     // for high-DPI devices.
  93     dips_to_view_scale_ = 1.0f;
  94     view_size_ = dips_size_;
  95
  96     // If the view's DIP dimensions don't match the source then let the frame
  97     // producer do the scaling, and render at device resolution.
  98     if (dips_size_ != source_size_) {
  99       dips_to_view_scale_ = dips_to_device_scale_;
 100       view_size_ = SkISize::Make(
 101           ceilf(dips_size_.width() * dips_to_view_scale_),
 102           ceilf(dips_size_.height() * dips_to_view_scale_));
 103     }
 104
 105     // Create a 2D rendering context at the chosen frame dimensions.
 106     pp::Size pp_size = pp::Size(view_size_.width(), view_size_.height());
 107     graphics2d_ = pp::Graphics2D(instance_, pp_size, false);
 108
 109     // Specify the scale from our coordinates to DIPs.
 110     pp::Graphics2D_Dev graphics2d_dev(graphics2d_);
 111     graphics2d_dev.SetScale(1.0f / dips_to_view_scale_);
 112
 113     bool result = instance_->BindGraphics(graphics2d_);
 114
 115     // There is no good way to handle this error currently.
 116     DCHECK(result) << "Couldn't bind the device context.";
 117   }
 118
 119   pp::Rect pp_clip = view.GetClipRect();
 120   SkIRect new_clip = SkIRect::MakeLTRB(
 121       floorf(pp_clip.x() * dips_to_view_scale_),
 122       floorf(pp_clip.y() * dips_to_view_scale_),
 123       ceilf(pp_clip.right() * dips_to_view_scale_),
 124       ceilf(pp_clip.bottom() * dips_to_view_scale_));
 125   if (clip_area_ != new_clip) {
 126     view_changed = true;
 127
 128     // YUV to RGB conversion may require even X and Y coordinates for
 129     // the top left corner of the clipping area.
 130     clip_area_ = AlignRect(new_clip);
 131     clip_area_.intersect(SkIRect::MakeSize(view_size_));
 132   }
 133
 134   if (view_changed) {
 135     producer_->SetOutputSizeAndClip(view_size_, clip_area_);
 136     InitiateDrawing();
 137   }
 138 }
 139
 140 void PepperView::ApplyBuffer(const SkISize& view_size,
 141                              const SkIRect& clip_area,
 142                              pp::ImageData* buffer,
 143                              const SkRegion& region) {
 144   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 145
 146   if (!frame_received_) {
 147     instance_->OnFirstFrameReceived();
 148     frame_received_ = true;
 149   }
 150   // We cannot use the data in the buffer if its dimensions don't match the
 151   // current view size.
 152   // TODO(alexeypa): We could rescale and draw it (or even draw it without
 153   // rescaling) to reduce the perceived lag while we are waiting for
 154   // the properly scaled data.
 155   if (view_size_ != view_size) {
 156     FreeBuffer(buffer);
 157     InitiateDrawing();
 158   } else {
 159     FlushBuffer(clip_area, buffer, region);
 160   }
 161 }
 162
 163 void PepperView::ReturnBuffer(pp::ImageData* buffer) {
 164   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 165
 166   // Reuse the buffer if it is large enough, otherwise drop it on the floor
 167   // and allocate a new one.
 168   if (buffer->size().width() >= clip_area_.width() &&
 169       buffer->size().height() >= clip_area_.height()) {
 170     producer_->DrawBuffer(buffer);
 171   } else {
 172     FreeBuffer(buffer);
 173     InitiateDrawing();
 174   }
 175 }
 176
 177 void PepperView::SetSourceSize(const SkISize& source_size,
 178                                const SkIPoint& source_dpi) {
 179   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 180
 181   if (source_size_ == source_size && source_dpi_ == source_dpi)
 182     return;
 183
 184   source_size_ = source_size;
 185   source_dpi_ = source_dpi;
 186
 187   // Notify JavaScript of the change in source size.
 188   instance_->SetDesktopSize(source_size, source_dpi);
 189 }
 190
 191 pp::ImageData* PepperView::AllocateBuffer() {
 192   if (buffers_.size() >= kMaxPendingBuffersCount)
 193     return NULL;
 194
 195   pp::Size pp_size = pp::Size(clip_area_.width(), clip_area_.height());
 196   if (pp_size.IsEmpty())
 197     return NULL;
 198
 199   // Create an image buffer of the required size, but don't zero it.
 200   pp::ImageData* buffer =  new pp::ImageData(
 201       instance_, PP_IMAGEDATAFORMAT_BGRA_PREMUL, pp_size, false);
 202   if (buffer->is_null()) {
 203     LOG(WARNING) << "Not enough memory for frame buffers.";
 204     delete buffer;
 205     return NULL;
 206   }
 207
 208   buffers_.push_back(buffer);
 209   return buffer;
 210 }
 211
 212 void PepperView::FreeBuffer(pp::ImageData* buffer) {
 213   DCHECK(std::find(buffers_.begin(), buffers_.end(), buffer) != buffers_.end());
 214
 215   buffers_.remove(buffer);
 216   delete buffer;
 217 }
 218
 219 void PepperView::InitiateDrawing() {
 220   pp::ImageData* buffer = AllocateBuffer();
 221   while (buffer) {
 222     producer_->DrawBuffer(buffer);
 223     buffer = AllocateBuffer();
 224   }
 225 }
 226
 227 void PepperView::FlushBuffer(const SkIRect& clip_area,
 228                              pp::ImageData* buffer,
 229                              const SkRegion& region) {
 230   // Defer drawing if the flush is already in progress.
 231   if (flush_pending_) {
 232     // |merge_buffer_| is guaranteed to be free here because we allocate only
 233     // two buffers simultaneously. If more buffers are allowed this code should
 234     // apply all pending changes to the screen.
 235     DCHECK(merge_buffer_ == NULL);
 236
 237     merge_clip_area_ = clip_area;
 238     merge_buffer_ = buffer;
 239     merge_region_ = region;
 240     return;
 241   }
 242
 243   // Notify Pepper API about the updated areas and flush pixels to the screen.
 244   base::Time start_time = base::Time::Now();
 245
 246   for (SkRegion::Iterator i(region); !i.done(); i.next()) {
 247     SkIRect rect = i.rect();
 248
 249     // Re-clip |region| with the current clipping area |clip_area_| because
 250     // the latter could change from the time the buffer was drawn.
 251     if (!rect.intersect(clip_area_))
 252       continue;
 253
 254     // Specify the rectangle coordinates relative to the clipping area.
 255     rect.offset(-clip_area.left(), -clip_area.top());
 256
 257     // Pepper Graphics 2D has a strange and badly documented API that the
 258     // point here is the offset from the source rect. Why?
 259     graphics2d_.PaintImageData(
 260         *buffer,
 261         pp::Point(clip_area.left(), clip_area.top()),
 262         pp::Rect(rect.left(), rect.top(), rect.width(), rect.height()));
 263   }
 264
 265   // Notify the producer that some parts of the region weren't painted because
 266   // the clipping area has changed already.
 267   if (clip_area != clip_area_) {
 268     SkRegion not_painted = region;
 269     not_painted.op(clip_area_, SkRegion::kDifference_Op);
 270     if (!not_painted.isEmpty()) {
 271       producer_->InvalidateRegion(not_painted);
 272     }
 273   }
 274
 275   // Flush the updated areas to the screen.
 276   int error = graphics2d_.Flush(
 277       PpCompletionCallback(base::Bind(
 278           &PepperView::OnFlushDone, AsWeakPtr(), start_time, buffer)));
 279   CHECK(error == PP_OK_COMPLETIONPENDING);
 280   flush_pending_ = true;
 281
 282   // If the buffer we just rendered has a shape then pass that to JavaScript.
 283   const SkRegion* buffer_shape = producer_->GetBufferShape();
 284   if (buffer_shape)
 285     instance_->SetDesktopShape(*buffer_shape);
 286 }
 287
 288 void PepperView::OnFlushDone(base::Time paint_start,
 289                              pp::ImageData* buffer,
 290                              int result) {
 291   DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
 292   DCHECK(flush_pending_);
 293
 294   instance_->GetStats()->video_paint_ms()->Record(
 295       (base::Time::Now() - paint_start).InMilliseconds());
 296
 297   flush_pending_ = false;
 298   ReturnBuffer(buffer);
 299
 300   // If there is a buffer queued for rendering then render it now.
 301   if (merge_buffer_ != NULL) {
 302     buffer = merge_buffer_;
 303     merge_buffer_ = NULL;
 304     FlushBuffer(merge_clip_area_, buffer, merge_region_);
 305   }
 306 }
 307
 308 }  // namespace remoting