Jenny/gfx release ww24

common/compositor/gl/egloffscreencontext.cpp

@@ -87,23 +87,27 @@ bool EGLOffScreenContext::MakeCurrent() {
   return true;
 }
 
-EGLint EGLOffScreenContext::GetSyncFD() {
+EGLint EGLOffScreenContext::GetSyncFD(bool onScreen) {
   EGLint sync_fd = -1;
 
-  EGLSyncKHR egl_sync =
-      eglCreateSyncKHR(egl_display_, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
-  if (egl_sync == EGL_NO_SYNC_KHR) {
-    ETRACE("Failed to make sync object.");
-    return -1;
-  }
+  if (onScreen)
+    glFlush();
+  else {
+    EGLSyncKHR egl_sync =
+        eglCreateSyncKHR(egl_display_, EGL_SYNC_NATIVE_FENCE_ANDROID, NULL);
+    if (egl_sync == EGL_NO_SYNC_KHR) {
+      ETRACE("Failed to make sync object.");
+      return -1;
+    }
 
-  sync_fd = eglDupNativeFenceFDANDROID(egl_display_, egl_sync);
-  if (sync_fd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
-    ETRACE("Failed to duplicate native fence object.");
-    sync_fd = -1;
-  }
+    sync_fd = eglDupNativeFenceFDANDROID(egl_display_, egl_sync);
+    if (sync_fd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
+      ETRACE("Failed to duplicate native fence object.");
+      sync_fd = -1;
+    }
 
-  eglDestroySyncKHR(egl_display_, egl_sync);
+    eglDestroySyncKHR(egl_display_, egl_sync);
+  }
 
   return sync_fd;
 }

common/compositor/gl/egloffscreencontext.h

@@ -28,7 +28,7 @@ class EGLOffScreenContext {
 
   bool Init();
 
-  EGLint GetSyncFD();
+  EGLint GetSyncFD(bool onScreen);
 
   EGLDisplay GetDisplay() const {
     return egl_display_;

common/compositor/gl/glrenderer.cpp

@@ -64,9 +64,11 @@ bool GLRenderer::Init() {
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
   glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STATIC_DRAW);
 
-  std::unique_ptr<GLProgram> program(new GLProgram());
-  if (program->Init(1)) {
-    programs_.emplace_back(std::move(program));
+  for (int i = 1; i < 5; i++) {
+    std::unique_ptr<GLProgram> program(new GLProgram());
+    if (program->Init(i)) {
+      programs_.emplace_back(std::move(program));
+    }
   }
 
   glEnableVertexAttribArray(0);
@@ -173,7 +175,7 @@ bool GLRenderer::Draw(const std::vector<RenderState> &render_states,
   glDisable(GL_SCISSOR_TEST);
 
   if (!disable_explicit_sync_)
-    surface->SetNativeFence(context_.GetSyncFD());
+    surface->SetNativeFence(context_.GetSyncFD(surface->IsOnScreen()));
 
   surface->ResetDamage();
 #ifdef COMPOSITOR_TRACING

common/core/gpudevice.cpp

@@ -130,6 +130,15 @@ bool GpuDevice::EnableDRMCommit(bool enable, uint32_t display_id) {
   return ret;
 }
 
+void GpuDevice::MarkDisplayForFirstCommit() {
+  size_t size = total_displays_.size();
+  for (size_t i = 0; i < size; i++) {
+    if (total_displays_.at(i)->IsConnected()) {
+      total_displays_.at(i)->MarkFirstCommit();
+    }
+  }
+}
+
 bool GpuDevice::ResetDrmMaster(bool drop_master) {
   bool ret = true;
   if (drop_master) {
@@ -149,6 +158,7 @@ bool GpuDevice::ResetDrmMaster(bool drop_master) {
   // In case of setDrmMaster or the lock file is not exist.
   // Re-set DRM Master true.
   display_manager_->setDrmMaster(false);
+  MarkDisplayForFirstCommit();
   ResetAllDisplayCommit(true);
   DisableWatch();
 
@@ -390,6 +400,8 @@ void GpuDevice::ParseLogicalDisplaySetting(
       logical_split_str.find_first_not_of("0123456789") != std::string::npos)
     return;
   uint32_t physical_index = atoi(physical_index_str.c_str());
+  if (physical_index < 0)
+    return;
   uint32_t logical_split_num = atoi(logical_split_str.c_str());
   if (logical_split_num <= 1)
     return;

common/core/hwclayer.cpp

@@ -106,21 +106,20 @@ void HwcLayer::SetDisplayFrame(const HwcRect<int>& display_frame,
 void HwcLayer::SetSurfaceDamage(const HwcRegion& surface_damage) {
   uint32_t rects = surface_damage.size();
   state_ |= kLayerContentChanged;
+  state_ |= kSurfaceDamageChanged;
   HwcRect<int> rect;
   ResetRectToRegion(surface_damage, rect);
   if (rects == 1) {
     if ((rect.top == 0) && (rect.bottom == 0) && (rect.left == 0) &&
         (rect.right == 0)) {
       state_ &= ~kLayerContentChanged;
-      state_ &= ~kSurfaceDamageChanged;
       UpdateRenderingDamage(rect, rect, true);
       surface_damage_.reset();
       return;
-    } else {
-      state_ |= kSurfaceDamageChanged;
     }
   } else if (rects == 0) {
     rect = display_frame_;
+    // damage is assigned with display_frame, no need to transform
     state_ &= ~kSurfaceDamageChanged;
   }
 
@@ -265,58 +264,21 @@ void HwcLayer::SufaceDamageTransfrom() {
     translated_damage.top = translated_damage.top * ratioh + 0.5;
     translated_damage.bottom = translated_damage.bottom * ratioh + 0.5;
 
-    if (transform_ == hwcomposer::HWCTransform::kTransform270) {
-      ox = display_frame_.left;
-      oy = display_frame_.bottom;
-      current_rendering_damage_.left = ox + translated_damage.top;
-      current_rendering_damage_.top = oy - translated_damage.right;
-      current_rendering_damage_.right = ox + translated_damage.bottom;
-      current_rendering_damage_.bottom = oy - translated_damage.left;
-    } else if (transform_ == hwcomposer::HWCTransform::kTransform180) {
-      ox = display_frame_.right;
-      oy = display_frame_.bottom;
-      current_rendering_damage_.left = ox - translated_damage.right;
-      current_rendering_damage_.top = oy - translated_damage.bottom;
-      current_rendering_damage_.right = ox - translated_damage.left;
-      current_rendering_damage_.bottom = oy - translated_damage.top;
-    } else if (transform_ & hwcomposer::HWCTransform::kTransform90) {
-      if (transform_ & hwcomposer::HWCTransform::kReflectX) {
-        ox = display_frame_.left;
-        oy = display_frame_.top;
-        current_rendering_damage_.left = ox + translated_damage.top;
-        current_rendering_damage_.top = oy + translated_damage.left;
-        current_rendering_damage_.right = ox + translated_damage.bottom;
-        current_rendering_damage_.bottom = oy + translated_damage.right;
-      } else if (transform_ & hwcomposer::HWCTransform::kReflectY) {
-        ox = display_frame_.right;
-        oy = display_frame_.bottom;
-        current_rendering_damage_.left = ox - translated_damage.bottom;
-        current_rendering_damage_.top = oy - translated_damage.right;
-        current_rendering_damage_.right = ox - translated_damage.top;
-        current_rendering_damage_.bottom = oy - translated_damage.left;
-      } else {
-        ox = display_frame_.right;
-        oy = display_frame_.top;
-        current_rendering_damage_.left = ox - translated_damage.bottom;
-        current_rendering_damage_.top = oy + translated_damage.left;
-        current_rendering_damage_.right = ox - translated_damage.top;
-        current_rendering_damage_.bottom = oy + translated_damage.right;
-      }
-    } else if (transform_ == 0) {
-      ox = display_frame_.left;
-      oy = display_frame_.top;
-      current_rendering_damage_.left = ox + translated_damage.left;
-      current_rendering_damage_.top = oy + translated_damage.top;
-      current_rendering_damage_.right = ox + translated_damage.right;
-      current_rendering_damage_.bottom = oy + translated_damage.bottom;
-    }
+    ox = display_frame_.left;
+    oy = display_frame_.top;
+    current_rendering_damage_.left = ox + translated_damage.left;
+    current_rendering_damage_.top = oy + translated_damage.top;
+    current_rendering_damage_.right = ox + translated_damage.right;
+    current_rendering_damage_.bottom = oy + translated_damage.bottom;
 #ifdef RECT_DAMAGE_TRACING
     IRECTDAMAGETRACE(
         "Re-calucated current_rendering_damage_ (LTWH): %d, %d, %d, %d",
         current_rendering_damage_.left, current_rendering_damage_.top,
         (current_rendering_damage_.right - current_rendering_damage_.left),
         (current_rendering_damage_.bottom - current_rendering_damage_.top));
 #endif
+  } else {
+    current_rendering_damage_ = translated_damage;
   }
 }
 

common/core/overlaylayer.cpp

@@ -138,8 +138,8 @@ void OverlayLayer::SetDisplayFrame(const HwcRect<int>& display_frame) {
 }
 
 void OverlayLayer::SetTransform(uint32_t transform) {
-  plane_transform_ = transform;
   transform_ = transform;
+  merged_transform_ = transform;
 }
 
 void OverlayLayer::ValidateTransform(uint32_t transform,
@@ -173,29 +173,112 @@ void OverlayLayer::ValidateTransform(uint32_t transform,
   // The elements {0, 1, 2, 3} form a circulant matrix under mod 4 arithmetic
   mtransform = (mtransform + mdisplay_transform) % 4;
   mtransform = inv_tmap[mtransform];
-  plane_transform_ = mtransform;
+  merged_transform_ = mtransform;
 
-  if (plane_transform_ & kTransform90) {
+  if (merged_transform_ & kTransform90) {
     if (transform & kReflectX)
-      plane_transform_ |= kReflectX;
+      merged_transform_ |= kReflectX;
 
     if (transform & kReflectY)
-      plane_transform_ |= kReflectY;
+      merged_transform_ |= kReflectY;
   }
 }
 
+void OverlayLayer::TransformDamage(HwcLayer* layer, uint32_t max_height,
+                                   uint32_t max_width) {
+  const HwcRect<int>& surface_damage = layer->GetLayerDamage();
+  if (surface_damage.empty() || !layer->HasSurfaceDamageRegionChanged()) {
+    surface_damage_ = surface_damage;
+    return;
+  }
+  HwcRect<int> translated_damage = TranslateRect(surface_damage, 0, 0);
+#ifdef RECT_DAMAGE_TRACING
+  IRECTDAMAGETRACE("Calculating Overlaylayer Damage for layer[%d]", z_order_);
+  IRECTDAMAGETRACE("max_width: %d, max_height:%d", max_width, max_height);
+  IRECTDAMAGETRACE("Original Surface_damage (LTWH): %d, %d, %d, %d",
+                   surface_damage.left, surface_damage.top,
+                   (surface_damage.right - surface_damage.left),
+                   (surface_damage.bottom - surface_damage.top));
+  IRECTDAMAGETRACE("translated_damage (LTWH): %d, %d, %d, %d",
+                   translated_damage.left, translated_damage.top,
+                   (translated_damage.right - translated_damage.left),
+                   (translated_damage.bottom - translated_damage.top));
+  IRECTDAMAGETRACE("source_crop_ (LTWH): %f, %f, %f, %f", source_crop_.left,
+                   source_crop_.top, (source_crop_.right - source_crop_.left),
+                   (source_crop_.bottom - source_crop_.top));
+  IRECTDAMAGETRACE("display_frame_ (LTWH): %d, %d, %d, %d", display_frame_.left,
+                   display_frame_.top,
+                   (display_frame_.right - display_frame_.left),
+                   (display_frame_.bottom - display_frame_.top));
+#endif
+  float ratio_w_h = max_width * 1.0 / max_height;
+  float ratio_h_w = max_height * 1.0 / max_width;
+
+  int ox = 0, oy = 0;
+
+  if (merged_transform_ == kTransform270) {
+    oy = max_height;
+    surface_damage_.left = translated_damage.top * ratio_w_h + 0.5;
+    surface_damage_.top = oy - translated_damage.right * ratio_h_w + 0.5;
+    surface_damage_.right = translated_damage.bottom * ratio_w_h + 0.5;
+    surface_damage_.bottom = oy - translated_damage.left * ratio_h_w + 0.5;
+  } else if (merged_transform_ == kTransform180) {
+    ox = max_width;
+    oy = max_height;
+    surface_damage_.left = ox - translated_damage.right;
+    surface_damage_.top = oy - translated_damage.bottom;
+    surface_damage_.right = ox - translated_damage.left;
+    surface_damage_.bottom = oy - translated_damage.top;
+  } else if (merged_transform_ & hwcomposer::HWCTransform::kTransform90) {
+    if (merged_transform_ & kReflectX) {
+      surface_damage_.left = translated_damage.top * ratio_w_h + 0.5;
+      surface_damage_.top = translated_damage.left * ratio_h_w + 0.5;
+      surface_damage_.right = translated_damage.bottom * ratio_w_h + 0.5;
+      surface_damage_.bottom = translated_damage.right * ratio_h_w + 0.5;
+    } else if (merged_transform_ & kReflectY) {
+      ox = max_width;
+      oy = max_height;
+      surface_damage_.left = ox - (translated_damage.bottom * ratio_w_h + 0.5);
+      surface_damage_.top = oy - (translated_damage.right * ratio_h_w + 0.5);
+      surface_damage_.right = ox - (translated_damage.top * ratio_w_h + 0.5);
+      surface_damage_.bottom = oy - (translated_damage.left * ratio_h_w + 0.5);
+    } else {
+      ox = max_width;
+      surface_damage_.left = ox - translated_damage.bottom * ratio_w_h + 0.5;
+      surface_damage_.top = translated_damage.left * ratio_h_w + 0.5;
+      surface_damage_.right = ox - translated_damage.top * ratio_w_h + 0.5;
+      surface_damage_.bottom = translated_damage.right * ratio_h_w + 0.5;
+    }
+  } else if (merged_transform_ == 0) {
+    surface_damage_.left = translated_damage.left;
+    surface_damage_.top = translated_damage.top;
+    surface_damage_.right = translated_damage.right;
+    surface_damage_.bottom = translated_damage.bottom;
+  }
+#ifdef RECT_DAMAGE_TRACING
+  IRECTDAMAGETRACE("Surface_damage (LTWH): %d, %d, %d, %d",
+                   surface_damage_.left, surface_damage_.top,
+                   (surface_damage_.right - surface_damage_.left),
+                   (surface_damage_.bottom - surface_damage_.top));
+#endif
+}
+
 void OverlayLayer::InitializeState(HwcLayer* layer,
                                    ResourceManager* resource_manager,
                                    OverlayLayer* previous_layer,
                                    uint32_t z_order, uint32_t layer_index,
-                                   uint32_t max_height, uint32_t rotation,
-                                   bool handle_constraints) {
+                                   uint32_t max_height, uint32_t max_width,
+                                   uint32_t rotation, bool handle_constraints) {
   transform_ = layer->GetTransform();
+  plane_transform_ = rotation;
   if (rotation != kRotateNone) {
     ValidateTransform(layer->GetTransform(), rotation);
   } else {
-    plane_transform_ = transform_;
+    merged_transform_ = transform_;
   }
+#ifdef RECT_DAMAGE_TRACING
+  IRECTDAMAGETRACE("validated plane_transform_: %d", plane_transform_);
+#endif
 
   alpha_ = layer->GetAlpha();
   layer_index_ = layer_index;
@@ -205,9 +288,8 @@ void OverlayLayer::InitializeState(HwcLayer* layer,
   source_crop_ = layer->GetSourceCrop();
   dataspace_ = layer->GetDataSpace();
   blending_ = layer->GetBlending();
-  surface_damage_ = layer->GetLayerDamage();
-
   solid_color_ = layer->GetSolidColor();
+  TransformDamage(layer, max_height, max_width);
 
   if (previous_layer && layer->HasZorderChanged()) {
     if (previous_layer->actual_composition_ == kGpu) {
@@ -257,6 +339,12 @@ void OverlayLayer::InitializeState(HwcLayer* layer,
     if (previous_layer) {
       ValidatePreviousFrameState(previous_layer, layer);
     }
+#ifdef RECT_DAMAGE_TRACING
+    IRECTDAMAGETRACE("Surface_damage after init (LTWH): %d, %d, %d, %d",
+                     surface_damage_.left, surface_damage_.top,
+                     (surface_damage_.right - surface_damage_.left),
+                     (surface_damage_.bottom - surface_damage_.top));
+#endif
     return;
   }
 
@@ -376,22 +464,23 @@ void OverlayLayer::InitializeState(HwcLayer* layer,
 void OverlayLayer::InitializeFromHwcLayer(
     HwcLayer* layer, ResourceManager* resource_manager,
     OverlayLayer* previous_layer, uint32_t z_order, uint32_t layer_index,
-    uint32_t max_height, uint32_t rotation, bool handle_constraints) {
+    uint32_t max_height, uint32_t max_width, uint32_t rotation,
+    bool handle_constraints) {
   display_frame_width_ = layer->GetDisplayFrameWidth();
   display_frame_height_ = layer->GetDisplayFrameHeight();
   display_frame_ = layer->GetDisplayFrame();
   InitializeState(layer, resource_manager, previous_layer, z_order, layer_index,
-                  max_height, rotation, handle_constraints);
+                  max_height, max_width, rotation, handle_constraints);
 }
 
 void OverlayLayer::InitializeFromScaledHwcLayer(
     HwcLayer* layer, ResourceManager* resource_manager,
     OverlayLayer* previous_layer, uint32_t z_order, uint32_t layer_index,
-    const HwcRect<int>& display_frame, uint32_t max_height, uint32_t rotation,
-    bool handle_constraints) {
+    const HwcRect<int>& display_frame, uint32_t max_height, uint32_t max_width,
+    uint32_t rotation, bool handle_constraints) {
   SetDisplayFrame(display_frame);
   InitializeState(layer, resource_manager, previous_layer, z_order, layer_index,
-                  max_height, rotation, handle_constraints);
+                  max_height, max_width, rotation, handle_constraints);
 }
 
 void OverlayLayer::ValidatePreviousFrameState(OverlayLayer* rhs,
@@ -482,7 +571,7 @@ void OverlayLayer::ValidatePreviousFrameState(OverlayLayer* rhs,
 
   if (!layer->HasVisibleRegionChanged() && !content_changed &&
       surface_damage_.empty() && !layer->HasLayerContentChanged() &&
-      !(state_ & kNeedsReValidation)) {
+      !(state_ & kNeedsReValidation) && !force_content_changed_) {
     state_ &= ~kLayerContentChanged;
   }
 }
@@ -512,6 +601,7 @@ void OverlayLayer::CloneLayer(const OverlayLayer* layer,
   surface_damage_ = layer->GetSurfaceDamage();
   transform_ = layer->transform_;
   plane_transform_ = layer->plane_transform_;
+  merged_transform_ = layer->merged_transform_;
   alpha_ = layer->alpha_;
   layer_index_ = z_order;
   z_order_ = z_order;