// Copyright (c) 2012 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 "remoting/client/plugin/pepper_view.h"
#include <functional>
#include "base/message_loop/message_loop.h"
#include "base/strings/string_util.h"
#include "base/synchronization/waitable_event.h"
#include "base/time/time.h"
#include "ppapi/cpp/completion_callback.h"
#include "ppapi/cpp/image_data.h"
#include "ppapi/cpp/point.h"
#include "ppapi/cpp/rect.h"
#include "ppapi/cpp/size.h"
#include "remoting/base/util.h"
#include "remoting/client/chromoting_stats.h"
#include "remoting/client/client_context.h"
#include "remoting/client/frame_producer.h"
#include "remoting/client/plugin/chromoting_instance.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
using base::Passed;
namespace {
// DesktopFrame that wraps a supplied pp::ImageData
class PepperDesktopFrame : public webrtc::DesktopFrame {
public:
// Wraps the supplied ImageData.
explicit PepperDesktopFrame(const pp::ImageData& buffer);
// Access to underlying pepper representation.
const pp::ImageData& buffer() const {
return buffer_;
}
private:
pp::ImageData buffer_;
};
PepperDesktopFrame::PepperDesktopFrame(const pp::ImageData& buffer)
: DesktopFrame(webrtc::DesktopSize(buffer.size().width(),
buffer.size().height()),
buffer.stride(),
reinterpret_cast<uint8_t*>(buffer.data()),
NULL),
buffer_(buffer) {}
} // namespace
namespace remoting {
namespace {
// The maximum number of image buffers to be allocated at any point of time.
const size_t kMaxPendingBuffersCount = 2;
} // namespace
PepperView::PepperView(ChromotingInstance* instance,
ClientContext* context)
: instance_(instance),
context_(context),
producer_(NULL),
merge_buffer_(NULL),
dips_to_device_scale_(1.0f),
dips_to_view_scale_(1.0f),
flush_pending_(false),
is_initialized_(false),
frame_received_(false),
callback_factory_(this) {
}
PepperView::~PepperView() {
// The producer should now return any pending buffers. At this point, however,
// ReturnBuffer() tasks scheduled by the producer will not be delivered,
// so we free all the buffers once the producer's queue is empty.
base::WaitableEvent done_event(true, false);
producer_->RequestReturnBuffers(
base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done_event)));
done_event.Wait();
merge_buffer_ = NULL;
while (!buffers_.empty()) {
FreeBuffer(buffers_.front());
}
}
void PepperView::Initialize(FrameProducer* producer) {
producer_ = producer;
webrtc::DesktopFrame* buffer = AllocateBuffer();
while (buffer) {
producer_->DrawBuffer(buffer);
buffer = AllocateBuffer();
}
}
void PepperView::SetView(const pp::View& view) {
bool view_changed = false;
pp::Rect pp_size = view.GetRect();
webrtc::DesktopSize new_dips_size(pp_size.width(), pp_size.height());
float new_dips_to_device_scale = view.GetDeviceScale();
if (!dips_size_.equals(new_dips_size) ||
dips_to_device_scale_ != new_dips_to_device_scale) {
view_changed = true;
dips_to_device_scale_ = new_dips_to_device_scale;
dips_size_ = new_dips_size;
// If |dips_to_device_scale_| is > 1.0 then the device is high-DPI, and
// there are actually |view_device_scale_| physical pixels for every one
// Density Independent Pixel (DIP). If we specify a scale of 1.0 to
// Graphics2D then we can render at DIP resolution and let PPAPI up-scale
// for high-DPI devices.
dips_to_view_scale_ = 1.0f;
view_size_ = dips_size_;
// If the view's DIP dimensions don't match the source then let the frame
// producer do the scaling, and render at device resolution.
if (!dips_size_.equals(source_size_)) {
dips_to_view_scale_ = dips_to_device_scale_;
view_size_.set(ceilf(dips_size_.width() * dips_to_view_scale_),
ceilf(dips_size_.height() * dips_to_view_scale_));
}
// Create a 2D rendering context at the chosen frame dimensions.
pp::Size pp_size = pp::Size(view_size_.width(), view_size_.height());
graphics2d_ = pp::Graphics2D(instance_, pp_size, false);
// Specify the scale from our coordinates to DIPs.
graphics2d_.SetScale(1.0f / dips_to_view_scale_);
bool result = instance_->BindGraphics(graphics2d_);
// There is no good way to handle this error currently.
DCHECK(result) << "Couldn't bind the device context.";
}
pp::Rect pp_clip = view.GetClipRect();
webrtc::DesktopRect new_clip = webrtc::DesktopRect::MakeLTRB(
floorf(pp_clip.x() * dips_to_view_scale_),
floorf(pp_clip.y() * dips_to_view_scale_),
ceilf(pp_clip.right() * dips_to_view_scale_),
ceilf(pp_clip.bottom() * dips_to_view_scale_));
if (!clip_area_.equals(new_clip)) {
view_changed = true;
// YUV to RGB conversion may require even X and Y coordinates for
// the top left corner of the clipping area.
clip_area_ = AlignRect(new_clip);
clip_area_.IntersectWith(webrtc::DesktopRect::MakeSize(view_size_));
}
if (view_changed) {
producer_->SetOutputSizeAndClip(view_size_, clip_area_);
Initialize(producer_);
}
}
void PepperView::ApplyBuffer(const webrtc::DesktopSize& view_size,
const webrtc::DesktopRect& clip_area,
webrtc::DesktopFrame* buffer,
const webrtc::DesktopRegion& region) {
DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
if (!frame_received_) {
instance_->OnFirstFrameReceived();
frame_received_ = true;
}
// We cannot use the data in the buffer if its dimensions don't match the
// current view size.
// TODO(alexeypa): We could rescale and draw it (or even draw it without
// rescaling) to reduce the perceived lag while we are waiting for
// the properly scaled data.
if (!view_size_.equals(view_size)) {
FreeBuffer(buffer);
Initialize(producer_);
} else {
FlushBuffer(clip_area, buffer, region);
}
}
void PepperView::ReturnBuffer(webrtc::DesktopFrame* buffer) {
DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
// Reuse the buffer if it is large enough, otherwise drop it on the floor
// and allocate a new one.
if (buffer->size().width() >= clip_area_.width() &&
buffer->size().height() >= clip_area_.height()) {
producer_->DrawBuffer(buffer);
} else {
FreeBuffer(buffer);
Initialize(producer_);
}
}
void PepperView::SetSourceSize(const webrtc::DesktopSize& source_size,
const webrtc::DesktopVector& source_dpi) {
DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
if (source_size_.equals(source_size) && source_dpi_.equals(source_dpi))
return;
source_size_ = source_size;
source_dpi_ = source_dpi;
// Notify JavaScript of the change in source size.
instance_->SetDesktopSize(source_size, source_dpi);
}
FrameConsumer::PixelFormat PepperView::GetPixelFormat() {
return FORMAT_BGRA;
}
webrtc::DesktopFrame* PepperView::AllocateBuffer() {
if (buffers_.size() >= kMaxPendingBuffersCount)
return NULL;
if (clip_area_.width()==0 || clip_area_.height()==0)
return NULL;
// Create an image buffer of the required size, but don't zero it.
pp::ImageData buffer_data(instance_,
PP_IMAGEDATAFORMAT_BGRA_PREMUL,
pp::Size(clip_area_.width(),
clip_area_.height()),
false);
if (buffer_data.is_null()) {
LOG(WARNING) << "Not enough memory for frame buffers.";
return NULL;
}
webrtc::DesktopFrame* buffer = new PepperDesktopFrame(buffer_data);
buffers_.push_back(buffer);
return buffer;
}
void PepperView::FreeBuffer(webrtc::DesktopFrame* buffer) {
DCHECK(std::find(buffers_.begin(), buffers_.end(), buffer) != buffers_.end());
buffers_.remove(buffer);
delete buffer;
}
void PepperView::FlushBuffer(const webrtc::DesktopRect& clip_area,
webrtc::DesktopFrame* buffer,
const webrtc::DesktopRegion& region) {
// Defer drawing if the flush is already in progress.
if (flush_pending_) {
// |merge_buffer_| is guaranteed to be free here because we allocate only
// two buffers simultaneously. If more buffers are allowed this code should
// apply all pending changes to the screen.
DCHECK(merge_buffer_ == NULL);
merge_clip_area_ = clip_area;
merge_buffer_ = buffer;
merge_region_ = region;
return;
}
// Notify Pepper API about the updated areas and flush pixels to the screen.
base::Time start_time = base::Time::Now();
for (webrtc::DesktopRegion::Iterator i(region); !i.IsAtEnd(); i.Advance()) {
webrtc::DesktopRect rect = i.rect();
// Re-clip |region| with the current clipping area |clip_area_| because
// the latter could change from the time the buffer was drawn.
rect.IntersectWith(clip_area_);
if (rect.is_empty())
continue;
// Specify the rectangle coordinates relative to the clipping area.
rect.Translate(-clip_area.left(), -clip_area.top());
// Pepper Graphics 2D has a strange and badly documented API that the
// point here is the offset from the source rect. Why?
graphics2d_.PaintImageData(
static_cast<PepperDesktopFrame*>(buffer)->buffer(),
pp::Point(clip_area.left(), clip_area.top()),
pp::Rect(rect.left(), rect.top(), rect.width(), rect.height()));
}
// Notify the producer that some parts of the region weren't painted because
// the clipping area has changed already.
if (!clip_area.equals(clip_area_)) {
webrtc::DesktopRegion not_painted = region;
not_painted.Subtract(clip_area_);
if (!not_painted.is_empty()) {
producer_->InvalidateRegion(not_painted);
}
}
// Flush the updated areas to the screen.
pp::CompletionCallback callback =
callback_factory_.NewCallback(&PepperView::OnFlushDone,
start_time,
buffer);
int error = graphics2d_.Flush(callback);
CHECK(error == PP_OK_COMPLETIONPENDING);
flush_pending_ = true;
// If the buffer we just rendered has a shape then pass that to JavaScript.
const webrtc::DesktopRegion* buffer_shape = producer_->GetBufferShape();
if (buffer_shape)
instance_->SetDesktopShape(*buffer_shape);
}
void PepperView::OnFlushDone(int result,
const base::Time& paint_start,
webrtc::DesktopFrame* buffer) {
DCHECK(context_->main_task_runner()->BelongsToCurrentThread());
DCHECK(flush_pending_);
instance_->GetStats()->video_paint_ms()->Record(
(base::Time::Now() - paint_start).InMilliseconds());
flush_pending_ = false;
ReturnBuffer(buffer);
// If there is a buffer queued for rendering then render it now.
if (merge_buffer_ != NULL) {
buffer = merge_buffer_;
merge_buffer_ = NULL;
FlushBuffer(merge_clip_area_, buffer, merge_region_);
}
}
} // namespace remoting