[Chromoting] Fallback to use software renderer if desktop image size is larger than GPU limitaiton

remoting/client/plugin/pepper_video_renderer_3d.cc

Index: remoting/client/plugin/pepper_video_renderer_3d.cc
diff --git a/remoting/client/plugin/pepper_video_renderer_3d.cc b/remoting/client/plugin/pepper_video_renderer_3d.cc
index b60f9bd72bb9e99d3745093ef73a7b674226b289..cc32ffebb0632527b8bd3961b03f2433b8bbbc44 100644
--- a/remoting/client/plugin/pepper_video_renderer_3d.cc
+++ b/remoting/client/plugin/pepper_video_renderer_3d.cc
@@ -91,14 +91,22 @@ void PepperVideoRenderer3D::SetPepperContext(
   DCHECK(event_handler);
   DCHECK(!event_handler_);
 
+  fallback_renderer_.SetPepperContext(instance, event_handler);
+
   event_handler_ = event_handler;
   pp_instance_ = instance;
 }
 
 void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
+  fallback_renderer_.OnViewChanged(view);
+
   pp::Size size = view.GetRect().size();
   float scale = view.GetDeviceScale();
-  view_size_.set(ceilf(size.width() * scale), ceilf(size.height() * scale));
+  DCHECK(scale > 0);

[Sergey Ulanov, 2016/10/17 20:02:44]

nit: DCHECK_GT(scale, 0.0);

[Hzj_jie, 2016/10/17 22:55:42]

Done.

+  view_size_.set(std::min<float>(ceilf(size.width() * scale),

[Sergey Ulanov, 2016/10/17 20:02:44]

I think it's better to use std::min<int> here and cast ceilf() result to int.

[Hzj_jie, 2016/10/17 22:55:43]

Done.

+                                 gl_limits_.viewport_size[0]),
+                 std::min<float>(ceilf(size.height() * scale),
+                                 gl_limits_.viewport_size[1]));
   graphics_.ResizeBuffers(view_size_.width(), view_size_.height());
 
   force_repaint_ = true;
@@ -106,12 +114,17 @@ void PepperVideoRenderer3D::OnViewChanged(const pp::View& view) {
 }
 
 void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
+  fallback_renderer_.EnableDebugDirtyRegion(enable);
   debug_dirty_region_ = enable;
 }
 
 bool PepperVideoRenderer3D::Initialize(
     const ClientContext& context,
     protocol::FrameStatsConsumer* stats_consumer) {
+  if (!fallback_renderer_.Initialize(context, stats_consumer)) {
+    LOG(FATAL) << "Failed to initialize fallback_renderer_";
+  }
+
   stats_consumer_ = stats_consumer;
 
   const int32_t context_attributes[] = {
@@ -167,6 +180,11 @@ bool PepperVideoRenderer3D::Initialize(
   gles2_if_->BufferData(graphics_3d, GL_ARRAY_BUFFER, sizeof(kVertices),
                         kVertices, GL_STATIC_DRAW);
 
+  gles2_if_->GetIntegerv(
+      graphics_3d, GL_MAX_TEXTURE_SIZE, &gl_limits_.texture_size);
+  gles2_if_->GetIntegerv(
+      graphics_3d, GL_MAX_VIEWPORT_DIMS, gl_limits_.viewport_size);
+
   CheckGLError();
 
   return true;
@@ -174,6 +192,8 @@ bool PepperVideoRenderer3D::Initialize(
 
 void PepperVideoRenderer3D::OnSessionConfig(
     const protocol::SessionConfig& config) {
+  fallback_renderer_.OnSessionConfig(config);
+
   PP_VideoProfile video_profile = PP_VIDEOPROFILE_VP8_ANY;
   switch (config.video_config().codec) {
     case protocol::ChannelConfig::CODEC_VP8:
@@ -212,6 +232,29 @@ protocol::FrameStatsConsumer* PepperVideoRenderer3D::GetFrameStatsConsumer() {
 void PepperVideoRenderer3D::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
+  if (!use_fallback_renderer_ &&
+      packet->format().has_screen_width() &&
+      packet->format().has_screen_height() &&
+      (packet->format().screen_width() > gl_limits_.texture_size ||
+       packet->format().screen_height() > gl_limits_.texture_size)) {

[Hzj_jie, 2016/10/17 18:49:57]

As we have talked offline, I do not think this fallback is really useful, unless
we use software decoder in fallback renderer.

[Sergey Ulanov, 2016/10/17 20:02:44]

I'm not sure what you mean here. Is your point that viewport size limit is more
likely to be exceeded than the texture size limit?

[Hzj_jie, 2016/10/17 22:55:43]

Sorry, I mean pure software renderer as what we have done on Android before
OpenGL renderer. Pixel Chromebook still cannot render a frame larger than 8192
pixels with PepperVideoRenderer2D.

[Sergey Ulanov, 2016/10/18 03:11:44]

I see. Is it the same on on other client platforms, particularly windows? In
either case think this fallback may still useful in some cases, e.g. when
Graphics2D is not accelerated.

[Hzj_jie, 2016/10/18 19:05:58]

Windows machines usually have a larger hardware limitation (16312 x 16312), so
this issue is not really easy to reproduce on windows client. i.e. we cannot
even encode textures over 16312 pixels.
But on ChromeOS client, we can easily reproduce it by using a screen resolution
larger than 8192 but less than 16312. In this case, both 2D and 3D are not
renderable.

I also agree to keep this logic to ensure any upgrade to PepperVideoRenderer2D
can help to resolve this issue permanently.

+    use_fallback_renderer_ = true;
+    // Clear current instance and use fallback_renderer_.
+    current_picture_frames_.clear();
+    current_picture_.reset();
+    next_picture_frames_.clear();
+    next_picture_.reset();
+    decoded_frames_.clear();
+    pending_frames_.clear();
+    graphics_ = pp::Graphics3D();
+    video_decoder_ = pp::VideoDecoder();
+  }
+
+  if (use_fallback_renderer_) {
+    fallback_renderer_.GetVideoStub()->ProcessVideoPacket(
+        std::move(packet), done);
+    return;
+  }
+
   VideoPacket* packet_ptr = packet.get();
   std::unique_ptr<FrameTracker> frame_tracker(
       new FrameTracker(std::move(packet), stats_consumer_, done));