Encode frame number in pixel data for pose sync

chrome/browser/android/vr_shell/vr_shell.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell.h"
 
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
 #include "chrome/browser/android/vr_shell/vr_controller.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
@@ skipping 138 matching lines @@
   float screen_height = kScreenHeightRatio * desktop_height_;
   std::unique_ptr<ContentRectangle> rect(new ContentRectangle());
   rect->id = kBrowserUiElementId;
   rect->size = {screen_width, screen_height, 1.0f};
   rect->translation = kDesktopPositionDefault;
   scene_.AddUiElement(rect);
 
   desktop_plane_ = scene_.GetUiElementById(kBrowserUiElementId);
 
   LoadUIContent();
+
+  gvr::Mat4f identity;
+  SetIdentityM(identity);
+  webvr_head_pose_.resize(kPoseRingBufferSize, identity);
 }
 
 void VrShell::UpdateCompositorLayers(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj) {
   content_compositor_->SetLayer(content_cvc_);
   ui_compositor_->SetLayer(ui_cvc_);
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
@@ skipping 170 matching lines @@
 
   if (original_type == WebInputEvent::GestureTap || touch_pending_) {
     touch_pending_ = false;
     gesture->type = WebInputEvent::GestureTap;
     gesture->details.buttons.pos.x = pixel_x;
     gesture->details.buttons.pos.y = pixel_y;
     current_input_target_->ProcessUpdatedGesture(*gesture.get());
   }
 }
 
+void VrShell::SetGvrPoseForWebVr(const gvr::Mat4f& pose, uint32_t pose_num) {
+  webvr_head_pose_[pose_num % kPoseRingBufferSize] = pose;
+}
+
+uint32_t GetPixelEncodedPoseIndex() {
+  // Read the pose index encoded in a bottom left pixel as color values.
+  // See also third_party/WebKit/Source/modules/vr/VRDisplay.cpp which
+  // encodes the pose index, and device/vr/android/gvr/gvr_device.cc
+  // which tracks poses.
+  uint8_t pixels[4];
+  // Assume we're reading from the frambebuffer we just wrote to.
+  // That's true currently, we may need to use glReadBuffer(GL_BACK)
+  // or equivalent if the rendering setup changes in the future.
+  glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+  return pixels[0] | (pixels[1] << 8) | (pixels[2] << 16);
+}
+
 void VrShell::DrawFrame(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   buffer_viewport_list_->SetToRecommendedBufferViewports();
 
   gvr::Frame frame = swap_chain_->AcquireFrame();
   gvr::ClockTimePoint target_time = gvr::GvrApi::GetTimePointNow();
   target_time.monotonic_system_time_nanos += kPredictionTimeWithoutVsyncNanos;
 
   gvr::Mat4f head_pose =
       gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
 
   gvr::Vec3f position = GetTranslation(head_pose);
   if (position.x == 0.0f && position.y == 0.0f && position.z == 0.0f) {
     // This appears to be a 3DOF pose without a neck model. Add one.
     // The head pose has redundant data. Assume we're only using the
     // object_from_reference_matrix, we're not updating position_external.
     // TODO: Not sure what object_from_reference_matrix is. The new api removed
     // it. For now, removing it seems working fine.
     gvr_api_->ApplyNeckModel(head_pose, 1.0f);
   }
 
   // Bind back to the default framebuffer.
   frame.BindBuffer(0);
 
   if (webvr_mode_) {
     DrawWebVr();
     if (!webvr_secure_origin_) {
       DrawWebVrOverlay(target_time.monotonic_system_time_nanos);
     }
+
+    // When using async reprojection, we need to know which pose was used in
+    // the WebVR app for drawing this frame. Due to unknown amounts of
+    // buffering in the compositor and SurfaceTexture, we read the pose number
+    // from a corner pixel. There's no point in doing this for legacy
+    // distortion rendering since that doesn't need a pose, and reading back
+    // pixels is an expensive operation. TODO(klausw): stop doing this once we
+    // have working no-compositor rendering for WebVR.
+    if (gvr_api_->GetAsyncReprojectionEnabled()) {
+      uint32_t webvr_pose_frame = GetPixelEncodedPoseIndex();
+      head_pose = webvr_head_pose_[webvr_pose_frame % kPoseRingBufferSize];
+    }
   } else {
     DrawVrShell(head_pose);
   }
 
   frame.Unbind();
   frame.Submit(*buffer_viewport_list_, head_pose);
 }
 
 void VrShell::DrawVrShell(const gvr::Mat4f& head_pose) {
   float screen_tilt = desktop_screen_tilt_ * M_PI / 180.0f;
@@ skipping 405 matching lines @@
       content::WebContents::FromJavaWebContents(content_web_contents));
   content::ContentViewCore* ui_core = content::ContentViewCore::FromWebContents(
       content::WebContents::FromJavaWebContents(ui_web_contents));
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, c_core,
       reinterpret_cast<ui::WindowAndroid*>(content_window_android), ui_core,
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android)));
 }
 
 }  // namespace vr_shell