/* Copyright Statement:
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein is
 * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
 * the prior written permission of MediaTek inc. and/or its licensors, any
 * reproduction, modification, use or disclosure of MediaTek Software, and
 * information contained herein, in whole or in part, shall be strictly
 * prohibited.
 *
 * MediaTek Inc. (C) 2021. All rights reserved.
 *
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
 * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
 * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
 * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
 * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
 * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
 * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
 * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
 * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
 * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
 * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
 * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
 * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
 * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 *
 * The following software/firmware and/or related documentation ("MediaTek
 * Software") have been modified by MediaTek Inc. All revisions are subject to
 * any receiver's applicable license agreements with MediaTek Inc.
 */

#ifndef SF_CPU_POLICY_ADAPTER_H
#define SF_CPU_POLICY_ADAPTER_H
#include "SurfaceFlinger.h"
#include "sf_cpu/SfCpuPolicy.h"
#include "FrameTimeline/FrameTimeline.h"

#ifndef MTK_CUTTLESTONE
#include <ui/gralloc_extra.h>
#endif

#define VPLP_LAYER_UNCHECKED -1
#define VPLP_LAYER_CHECKED_NOT_OK 0
#define VPLP_LAYER_CHECKED_OK 1

#ifdef MTK_COMPOSER_EXT
namespace ComposerExt {
class ClientInterface;
}
#endif

namespace android {

class SfCpuPolicyAdapter: public virtual SfCpuPolicy::PerfMeas{
public:
    static SfCpuPolicyAdapter& getInstance(frametimeline::FrameTimeline & frameTimeline);
    static bool isEnabled();
    SfCpuPolicyAdapter(frametimeline::FrameTimeline & frameTimeline);
    ~SfCpuPolicyAdapter();
    bool needIncreasePerf(nsecs_t startTime, nsecs_t endTime, nsecs_t targetTime); //override
    bool needReducePerf(nsecs_t startTime, nsecs_t endTime, nsecs_t targetTime); //override
    SfCpuPolicy* createSfCpuPolicy();
    void destroySfCpuPolicy();
    void setupConfig(SfCpuPolicy::Config & conf);
    void notifyFrameStart(nsecs_t startTime, int64_t vsyncId);
    void notifySpeedUpRE(int resource);
    void notifyFrameEnd(nsecs_t endTime);
    void notifyClearCorrection(bool clear, bool heavyLoading);
    void notifyResetCalculation();
    void notifyPowerSuspend(bool enable);
    void notifyHwcHwbinderTid(int tid);
    void notifyVpLpEnable(bool enable);
    void notifyLayerConnect(const void * token, const std::string& name);
    void notifyLayerDisconnect(const void * token);
    void notifyLayerSetBuffer(const void * token, const sp<GraphicBuffer>& buffer);
    SfCpuPolicy::EnableReason checkIfNeedSuspend(int rate, bool gpu_comp, bool * sus_mid,  nsecs_t *targetTime);
    nsecs_t calcTargetTime (int fps);
    const static SfCpuPolicy::Config HighPerfCong;
    const static SfCpuPolicy::Config NormalPerfCong;
#ifdef MTK_COMPOSER_EXT
    void setComposerExtIntf(ComposerExt::ClientInterface* intf);
#endif
protected:
    SfCpuPolicy * mCpuPolicy = nullptr;
    frametimeline::FrameTimeline & mFrameTimeline;;
    void* mSoHandle;
    SfCpuPolicy* (*mFnCreateSfCpuPolicy)();
    void (*mFnDestroySfCpuPolicy)(SfCpuPolicy* cpuPolicy);
    void (*mFnSetupConfig)(SfCpuPolicy* cpuPolicy,SfCpuPolicy::Config & conf, bool suspend);
    void (*mFnSetupPerfMeas)(SfCpuPolicy* cpuPolicy, SfCpuPolicy::PerfMeas * perfMeas);
    void (*mFnNotifyFrameStart)(SfCpuPolicy* cpuPolicy, nsecs_t startTime, int64_t vsyncId, bool suspend);
    void (*mFnNotifySpeedUpRE)(SfCpuPolicy* cpuPolicy, int resource, int64_t vsyncId);
    void (*mFnNotifyFrameEnd)(SfCpuPolicy* cpuPolicy, nsecs_t endTime, int64_t vsyncId, bool suspend);
    void (*mFnNotifyClearCorrection)(SfCpuPolicy* cpuPolicy, int64_t vsyncId, bool clear, bool heavyLoading);
    void (*mFnNotifyResetCalculation)(SfCpuPolicy* cpuPolicy, int64_t vsyncId);
    void (*mFnNotifyHwcHwbinderTid)(SfCpuPolicy* cpuPolicy, int tid);
private:
    void InitProp();
    bool getVpLpEnable();
    bool mIsLastFrameFinished = true;
    nsecs_t mLastFrameEndTime = 0;
    int64_t mLastVsyncId = 0;
    bool mPowerSuspend = false;
    bool mSuspendNeed = false;
    bool mSuspend = false;
    float mLastFps = 0.0f;
    bool mVpLpEnable = false;
    bool mVpLpEnableDbg = false;
    mutable std::mutex mMutex;
    std::map<const void *, int>  mVpLpLayers; //value -1 (not checked), 0 (checked, not VP ), 1 (checked, VP layer)
    float mS2sFps = 0;
#ifdef MTK_COMPOSER_EXT
    bool mLastVpLpState = false;
    ComposerExt::ClientInterface* mMtkComposerExtIntf = nullptr;
#endif
};

} // namespace android
#endif