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

remoting/client/plugin/pepper_video_renderer_3d.cc

 // Copyright 2014 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_video_renderer_3d.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "ppapi/c/pp_codecs.h"
-#include "ppapi/c/ppb_opengles2.h"
 #include "ppapi/c/ppb_video_decoder.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/lib/gl/include/GLES2/gl2.h"
 #include "ppapi/lib/gl/include/GLES2/gl2ext.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/performance_tracker.h"
 #include "remoting/protocol/session_config.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
 
@@ skipping 60 matching lines @@
   if (shader_program_)
     gles2_if_->DeleteProgram(graphics_.pp_resource(), shader_program_);
 }
 
 void PepperVideoRenderer3D::SetPepperContext(
     pp::Instance* instance,
     EventHandler* event_handler) {
   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));
   graphics_.ResizeBuffers(view_size_.width(), view_size_.height());
 
   force_repaint_ = true;
   PaintIfNeeded();
 }
 
 void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
+  fallback_renderer_.EnableDebugDirtyRegion(enable);
   debug_dirty_region_ = enable;
 }
 
 bool PepperVideoRenderer3D::Initialize(
     const ClientContext& context,
     protocol::FrameStatsConsumer* stats_consumer) {
+  fallback_renderer_usable_ =
+      fallback_renderer_.Initialize(context, stats_consumer);
+
   stats_consumer_ = stats_consumer;
 
   const int32_t context_attributes[] = {
       PP_GRAPHICS3DATTRIB_ALPHA_SIZE,     8,
       PP_GRAPHICS3DATTRIB_BLUE_SIZE,      8,
       PP_GRAPHICS3DATTRIB_GREEN_SIZE,     8,
       PP_GRAPHICS3DATTRIB_RED_SIZE,       8,
       PP_GRAPHICS3DATTRIB_DEPTH_SIZE,     0,
       PP_GRAPHICS3DATTRIB_STENCIL_SIZE,   0,
       PP_GRAPHICS3DATTRIB_SAMPLES,        0,
@@ skipping 34 matching lines @@
   static const float kVertices[] = {
       -1, -1, -1, 1, 1, -1, 1, 1,  // Position coordinates.
       0,  1,  0,  0, 1, 1,  1, 0,  // Texture coordinates.
   };
 
   GLuint buffer;
   gles2_if_->GenBuffers(graphics_3d, 1, &buffer);
   gles2_if_->BindBuffer(graphics_3d, GL_ARRAY_BUFFER, buffer);
   gles2_if_->BufferData(graphics_3d, GL_ARRAY_BUFFER, sizeof(kVertices),
                         kVertices, GL_STATIC_DRAW);
+  gles2_if_->GetIntegerv(
+      graphics_3d, GL_MAX_TEXTURE_SIZE, &gl_max_texture_size_);
 
   CheckGLError();
 
   return true;
 }
 
 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:
       video_profile = PP_VIDEOPROFILE_VP8_ANY;
       break;
     case protocol::ChannelConfig::CODEC_VP9:
       video_profile = PP_VIDEOPROFILE_VP9_ANY;
       break;
     default:
       NOTREACHED();
@@ skipping 18 matching lines @@
   return nullptr;
 }
 
 protocol::FrameStatsConsumer* PepperVideoRenderer3D::GetFrameStatsConsumer() {
   return stats_consumer_;
 }
 
 void PepperVideoRenderer3D::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
+  if (!use_fallback_renderer_ && fallback_renderer_usable_) {
+    use_fallback_renderer_ =

[Sergey Ulanov, 2016/07/14 17:45:28]

Once we start using the fallback renderer I think we want to keep using it.
Switching back and forth between them when resolution changes may not be safe.

Also I think we need to free all old pending frames and all resources used by
the 3D renderer before the fallback happens. Freeing all FrameTracker objects is
especially important as they will call Done callback.

  current_picture_frames_.clear();
  current_picture_.reset()
  next_picture_frames_.clear();
  next_picture_.reset();
  decoded_frames_.clear();
  pending_frames_.clear();

  // Reset Pepper resources, freeing the old ones.
  graphics_ = pp::Graphics3D();  
  video_renderer_ = pp::VideoDecoder();

[Hzj_jie, 2016/07/15 02:30:50]

No, if use_fallback_renderer_ is true, it won't fallback.
Others are added.

+        gl_max_texture_size_ < packet->format().screen_width() ||

[Sergey Ulanov, 2016/07/14 17:45:28]

nit: would be more readable if this condition was in the opposite order:
 packet->format().screen_width() >  gl_max_texture_size_

[Sergey Ulanov, 2016/07/14 17:45:28]

screen_width() and screen_height() are set only when size changes. Code below
uses .has_screen_width()

[Hzj_jie, 2016/07/15 02:30:50]

I believe in protobuf, an unset integer field is always zero. And
gl_max_texture_size_ won't be less than zero.

[Hzj_jie, 2016/07/15 02:30:50]

Done.

[Sergey Ulanov, 2016/07/15 23:33:18]

It's true, but in general it's usually better to check pretense of the fields
explicitly, if only to make it clear in the code that this case was considered.
In this particular case it makes difference when only one of the two fields is
set: that's incorrect packet and we don't want to initiate fallback in that
scenario.

[Hzj_jie, 2016/07/16 01:19:21]

Done.

+        gl_max_texture_size_ < packet->format().screen_height();
+  }
+
+  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));
 
   // Don't need to do anything if the packet is empty. Host sends empty video
   // packets when the screen is not changing.
   if (packet_ptr->data().empty())
     return;
 
   if (!frame_received_) {
@@ skipping 305 matching lines @@
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
   CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
 }
 
 }  // namespace remoting