Merge tag 'LA.QSSI.12.0.r1-06100-qssi.0' into sugisawasugisawa

"LA.QSSI.12.0.r1-06100-qssi.0"

Change-Id: I8375c5be732ba39cd8b840a5003b82ab2e758503

1 files changed, 182 insertions, 74 deletions

diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 086be820c5..7cea8143d5 100755
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -433,12 +433,9 @@ bool callingThreadHasRotateSurfaceFlingerAccess() {
 
 void SurfaceFlinger::setRefreshRates(
        std::unique_ptr<scheduler::RefreshRateConfigs> &refreshRateConfigs) {
+    // Get Primary Smomo Instance.
     std::vector<float> refreshRates;
 
-    if (mSmoMo == nullptr) {
-        return;
-    }
-
     auto iter = refreshRateConfigs->getAllRefreshRates().cbegin();
     while (iter != refreshRateConfigs->getAllRefreshRates().cend()) {
         if (refreshRateConfigs->isModeAllowed(iter->second->getModeId())) {
@@ -446,7 +443,14 @@ void SurfaceFlinger::setRefreshRates(
         }
         ++iter;
     }
-    mSmoMo->SetDisplayRefreshRates(refreshRates);
+    SmomoIntf *smoMo = nullptr;
+    for (auto &instance: mSmomoInstances) {
+        smoMo = instance.smoMo;
+        if (smoMo == nullptr) {
+            continue;
+        }
+        smoMo->SetDisplayRefreshRates(refreshRates);
+    }
 }
 
 bool LayerExtWrapper::init() {
@@ -1143,9 +1147,6 @@ void SurfaceFlinger::init() {
         ALOGE("Run StartPropertySetThread failed!");
     }
 
-    // Initialize Smomo.
-    InitSmomo();
-
     char layerExtProp[PROPERTY_VALUE_MAX];
     property_get("vendor.display.use_layer_ext", layerExtProp, "0");
     if (atoi(layerExtProp)) {
@@ -1200,26 +1201,66 @@ void SurfaceFlinger::InitComposerExtn() {
     ALOGI("Init: mDisplayExtnIntf: %p", mDisplayExtnIntf);
 }
 
-void SurfaceFlinger::InitSmomo() {
+void SurfaceFlinger::createSmomoInstance(const DisplayDeviceState& state) {
+    if (state.isVirtual() || state.physical->type == ui::DisplayConnectionType::External) {
+        return;
+    }
     char smomoProp[PROPERTY_VALUE_MAX];
     property_get("vendor.display.use_smooth_motion", smomoProp, "0");
     if (!atoi(smomoProp)) {
+        ALOGI("Smomo is disabled through property");
         return;
     }
-    bool ret = mComposerExtnIntf->CreateSmomoExtn(&mSmoMo);
+    SmomoInfo smomoInfo;
+    smomoInfo.displayId = state.physical->hwcDisplayId;
+    smomoInfo.layerStackId = state.layerStack;
+    smomoInfo.active = true;
+    smomo::DisplayInfo displayInfo;
+    displayInfo.display_id = state.physical->hwcDisplayId;
+    displayInfo.is_primary = state.physical->hwcDisplayId == 0;
+    displayInfo.type = smomo::kBuiltin;
+    mComposerExtnIntf = composer::ComposerExtnLib::GetInstance();
+    bool ret = mComposerExtnIntf->CreateSmomoExtn(&smomoInfo.smoMo, displayInfo);
     if (!ret) {
-        ALOGI("Unable to create smomo extension");
+        ALOGI("Unable to create smomo extension for display: %d", displayInfo.display_id);
+        return;
     }
-    if (mSmoMo != nullptr) {
-        mSmoMo->SetChangeRefreshRateCallback(
-            [this](int32_t refreshRate) {
+
+    mSmomoInstances.push_back(smomoInfo);
+    // Set refresh rates for primary display's instance.
+    smomoInfo.smoMo->SetChangeRefreshRateCallback(
+           [this](int32_t refreshRate) {
                 setRefreshRateTo(refreshRate);
-            });
+           });
 
-        setRefreshRates(mRefreshRateConfigs);
+    setRefreshRates(mRefreshRateConfigs);
 
-        ALOGI("SmoMo is enabled");
+    if (mSmomoInstances.size() > 1) {
+        // Disable DRC on all instances.
+        for (auto &instance : mSmomoInstances) {
+            instance.smoMo->SetRefreshRateChangeStatus(false);
+        }
     }
+
+    ALOGI("SmoMo is enabled for display: %d", displayInfo.display_id);
+}
+
+void SurfaceFlinger::destroySmomoInstance(const sp<DisplayDevice>& display) {
+  uint32_t hwcDisplayId = 0;
+  if (!getHwcDisplayId(display, &hwcDisplayId)) {
+      return;
+  }
+
+  mSmomoInstances.erase(std::remove_if(mSmomoInstances.begin(), mSmomoInstances.end(),
+                                       [&](SmomoInfo const &smomoInfo) {
+                                          return smomoInfo.displayId == hwcDisplayId;
+                                       }), mSmomoInstances.end());
+
+  // Enable DRC if only one instance is active.
+  if (mSmomoInstances.size() == 1) {
+      // Disable DRC on all instances.
+      mSmomoInstances.at(0).smoMo->SetRefreshRateChangeStatus(false);
+  }
 }
 
 void SurfaceFlinger::startUnifiedDraw() {
@@ -1468,7 +1509,7 @@ status_t SurfaceFlinger::getDisplayStats(const sp<IBinder>&, DisplayStatInfo* st
 }
 
 bool SurfaceFlinger::isFpsDeferNeeded(const ActiveModeInfo& info) {
-    const auto display = ON_MAIN_THREAD(getDefaultDisplayDeviceLocked());
+    const auto display = getDefaultDisplayDeviceLocked();
     if (!display || !mThermalLevelFps) {
         return false;
     }
@@ -2492,9 +2533,16 @@ void SurfaceFlinger::updateFrameScheduler() NO_THREAD_SAFETY_ANALYSIS {
 void SurfaceFlinger::syncToDisplayHardware() NO_THREAD_SAFETY_ANALYSIS {
     ATRACE_CALL();
 
-    if (mSmoMo) {
+    SmomoIntf *smoMo = nullptr;
+    for (auto &instance: mSmomoInstances) {
+        if (instance.displayId == 0) {
+            smoMo = instance.smoMo;
+            break;
+        }
+    }
+    if (smoMo) {
         nsecs_t timestamp = 0;
-        bool needResync = mSmoMo->SyncToDisplay(previousFrameFence().fence, &timestamp);
+        bool needResync = smoMo->SyncToDisplay(previousFrameFence().fence, &timestamp);
         ALOGV("needResync = %d, timestamp = %" PRId64, needResync, timestamp);
     }
 }
@@ -3136,6 +3184,8 @@ void SurfaceFlinger::postComposition() {
     const size_t appConnections = mScheduler->getEventThreadConnectionCount(mAppConnectionHandle);
     mTimeStats->recordDisplayEventConnectionCount(sfConnections + appConnections);
 
+    UpdateSmomoState();
+
     if (isDisplayConnected && !display->isPoweredOn()) {
         return;
     }
@@ -3180,7 +3230,16 @@ void SurfaceFlinger::postComposition() {
     bool layerExtEnabled = (mSplitLayerExt && mLayerExt);
     bool visibleLayersInfo = false;
 
-    if (mSmoMo || layerExtEnabled) {
+    const uint32_t layerStackId = display->getLayerStack();
+    SmomoIntf *smoMo = nullptr;
+    for (auto &instance: mSmomoInstances) {
+        if (instance.layerStackId == layerStackId) {
+            smoMo = instance.smoMo;
+            break;
+        }
+    }
+
+    if (smoMo || layerExtEnabled) {
         const auto compositionDisplay = display->getCompositionDisplay();
         compositionDisplay->getVisibleLayerInfo(&layerName, &layerSequence);
         visibleLayersInfo = (layerName.size() != 0);
@@ -3190,50 +3249,70 @@ void SurfaceFlinger::postComposition() {
         mLayerExt->UpdateLayerState(layerName, mNumLayers);
     }
 
-    if (mSmoMo && visibleLayersInfo) {
-        ATRACE_NAME("SmoMoUpdateState");
-        Mutex::Autolock lock(mStateLock);
 
-        uint32_t fps = 0;
-        std::vector<smomo::SmomoLayerStats> layers;
+    // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
+    // side-effect of getTotalSize(), so we check that again here
+    if (ATRACE_ENABLED()) {
+        // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
+        ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
+    }
+}
 
-        // Disable SmoMo by passing empty layer stack in multiple display case
-        if (mDisplays.size() == 1) {
-            for (int i = 0; i < layerName.size(); i++) {
-                smomo::SmomoLayerStats layerStats;
-                layerStats.name = layerName.at(i);
-                layerStats.id = layerSequence.at(i);
-                layers.push_back(layerStats);
+void SurfaceFlinger::UpdateSmomoState() {
+    ATRACE_NAME("SmoMoUpdateState");
+    Mutex::Autolock lock(mStateLock);
+    // Check if smomo instances exist.
+    if (!mSmomoInstances.size()) {
+        return;
+    }
+
+    // Disable smomo if external or virtual is connected.
+    bool enableSmomo = mSmomoInstances.size() == mDisplays.size();
+    uint32_t fps = 0;
+    int content_fps = 0;
+    int numActiveDisplays = 0;
+    for (auto &instance: mSmomoInstances) {
+        SmomoIntf *smoMo = instance.smoMo;
+        sp<DisplayDevice> device = nullptr;
+        for (const auto& [token, displayDevice] : mDisplays) {
+            uint32_t hwcDisplayId;
+            if (!getHwcDisplayId(displayDevice, &hwcDisplayId)) {
+                continue;
             }
+            if (hwcDisplayId == instance.displayId) {
+                device = displayDevice;
+                break;
+            }
+        }
 
+        std::vector<smomo::SmomoLayerStats> layers;
+        if (enableSmomo && instance.active) {
             fps = mRefreshRateConfigs->getCurrentRefreshRate().getFps().getValue();
+            mDrawingState.traverse([&](Layer* layer) {
+               if (layer->findOutputLayerForDisplay(device.get())) {
+                   smomo::SmomoLayerStats layerStats;
+                   layerStats.id = layer->getSequence();
+                   layerStats.name = layer->getName();
+                   layers.push_back(layerStats);
+               }
+            });
         }
 
-        mSmoMo->UpdateSmomoState(layers, fps);
-        int content_fps = mSmoMo->GetFrameRate();
-
-        bool is_valid_content_fps = false;
-        if (content_fps > 0) {
-            if (mLayersWithQueuedFrames.size() > 1) {
-                mUiLayerFrameCount++;
-            } else {
-                mUiLayerFrameCount = 0;
-            }
-
-            is_valid_content_fps = (mUiLayerFrameCount < fps) ? true : false;
-        } else {
-            mUiLayerFrameCount = 0;
+        if (instance.active) {
+            smoMo->UpdateSmomoState(layers, fps);
         }
-
-        setContentFps(is_valid_content_fps ? content_fps : fps);
+        content_fps = smoMo->GetFrameRate();
+        bool active = device->getPowerMode() != hal::PowerMode::OFF;
+        // Cache smommo status.
+        instance.active = active;
+        numActiveDisplays += active;
     }
 
+    setContentFps((content_fps > 0) && (mSmomoInstances.size() == 1) ? content_fps : fps);
 
-    // Even though ATRACE_INT64 already checks if tracing is enabled, it doesn't prevent the
-    // side-effect of getTotalSize(), so we check that again here
-    if (ATRACE_ENABLED()) {
-        // getTotalSize returns the total number of buffers that were allocated by SurfaceFlinger
-        ATRACE_INT64("Total Buffer Size", GraphicBufferAllocator::get().getTotalSize());
+    // Disable DRC if active displays is more than 1.
+    for (auto &instance : mSmomoInstances) {
+        instance.smoMo->SetRefreshRateChangeStatus((numActiveDisplays == 1));
     }
 }
 
@@ -3754,6 +3833,7 @@ void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
         }
     }
 #endif
+    createSmomoInstance(state);
 }
 
 void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
@@ -3766,6 +3846,7 @@ void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
         } else {
             dispatchDisplayHotplugEvent(display->getPhysicalId(), false);
         }
+        destroySmomoInstance(display);
     }
 
     mDisplays.erase(displayToken);
@@ -3837,6 +3918,13 @@ void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
         bool displaySizeChanged = false;
         if (currentState.layerStack != drawingState.layerStack) {
             display->setLayerStack(currentState.layerStack);
+            for (auto &instance: mSmomoInstances) {
+                if ((instance.displayId == currentState.physical->hwcDisplayId) &&
+                    instance.layerStackId == drawingState.layerStack) {
+                    instance.layerStackId = currentState.layerStack;
+                    break;
+                }
+            }
         }
         if ((currentState.orientation != drawingState.orientation) ||
             (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) ||
@@ -4636,10 +4724,20 @@ bool SurfaceFlinger::transactionIsReadyToBeApplied(
                 return false;
             }
 
-            if (mSmoMo) {
-                if (mSmoMo->FrameIsEarly(layer->getSequence(), desiredPresentTime)) {
+            const uint32_t layerStackId = layer->getLayerStack();
+            SmomoIntf *smoMo = nullptr;
+            for (auto &instance: mSmomoInstances) {
+                if (instance.layerStackId == layerStackId) {
+                    smoMo = instance.smoMo;
+                    break;
+                }
+            }
+            if (smoMo) {
+                ATRACE_BEGIN("smomo_begin");
+                if (smoMo->FrameIsEarly(layer->getSequence(), desiredPresentTime)) {
                     return false;
                 }
+                ATRACE_END();
             }
         }
     }
@@ -4767,26 +4865,36 @@ status_t SurfaceFlinger::setTransactionState(
         waitForSynchronousTransaction(*state.transactionCommittedSignal);
     }
 
-    if (mSmoMo) {
-        state.traverseStatesWithBuffers([&](const layer_state_t& state) {
-            sp<Layer> layer = fromHandle(state.surface).promote();
-            if (layer != nullptr) {
-                smomo::SmomoBufferStats bufferStats;
-                const nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
-                bufferStats.id = layer->getSequence();
-                bufferStats.auto_timestamp = isAutoTimestamp;
-                bufferStats.timestamp = now;
-                bufferStats.dequeue_latency = 0;
-                bufferStats.key = desiredPresentTime;
-                mSmoMo->CollectLayerStats(bufferStats);
-
-                const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(now);
-                if (mSmoMo->FrameIsLate(bufferStats.id, stats.vsyncTime)) {
-                    signalImmedLayerUpdate();
+    state.traverseStatesWithBuffers([&](const layer_state_t& state) {
+        sp<Layer> layer = fromHandle(state.surface).promote();
+        if (layer != nullptr) {
+            const uint32_t layerStackId = layer->getLayerStack();
+            SmomoIntf *smoMo = nullptr;
+            for (auto &instance: mSmomoInstances) {
+                 if (instance.layerStackId == layerStackId) {
+                    smoMo = instance.smoMo;
+                    break;
                 }
             }
-        });
-    }
+
+            if (smoMo) {
+               smomo::SmomoBufferStats bufferStats;
+               const nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
+               bufferStats.id = layer->getSequence();
+               bufferStats.auto_timestamp = isAutoTimestamp;
+               bufferStats.timestamp = now;
+               bufferStats.dequeue_latency = 0;
+               bufferStats.key = desiredPresentTime;
+               smoMo->CollectLayerStats(bufferStats);
+
+               const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(now);
+               if (smoMo->FrameIsLate(bufferStats.id, stats.vsyncTime)) {
+                  signalImmedLayerUpdate();
+                }
+            }
+        }
+    });
+
 
     return NO_ERROR;
 }