QCamera2/util/QCameraPerf.cpp

/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*     * Redistributions of source code must retain the above copyright
*       notice, this list of conditions and the following disclaimer.
*     * Redistributions in binary form must reproduce the above
*       copyright notice, this list of conditions and the following
*       disclaimer in the documentation and/or other materials provided
*       with the distribution.
*     * Neither the name of The Linux Foundation nor the names of its
*       contributors may be used to endorse or promote products derived
*       from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/

#define LOG_TAG "QCameraPerf"

// To remove
#include <cutils/properties.h>
#include <utils/Errors.h>

// System dependencies
#include <stdlib.h>
#include <dlfcn.h>
#include <utils/Timers.h>
// Camera dependencies
#include "QCameraPerf.h"
#include "QCameraTrace.h"

#include <android-base/properties.h>

extern "C" {
#include "mm_camera_dbg.h"
}

namespace qcamera {

using android::hidl::base::V1_0::IBase;
using android::hardware::hidl_death_recipient;

static std::mutex gPowerHalMutex;
static sp<IPower> gPowerHal = nullptr;
static void getPowerHalLocked();

// struct PowerHalDeathRecipient;
struct PowerHalDeathRecipient : virtual public hidl_death_recipient {
    // hidl_death_recipient interface
    virtual void serviceDied(uint64_t, const wp<IBase>&) override {
        std::lock_guard<std::mutex> lock(gPowerHalMutex);
        ALOGE("PowerHAL just died");
        gPowerHal = nullptr;
        getPowerHalLocked();
    }
};

sp<PowerHalDeathRecipient> gPowerHalDeathRecipient = nullptr;

// The caller must be holding gPowerHalMutex.
static void getPowerHalLocked() {
    if (gPowerHal != nullptr) {
        return;
    }

    gPowerHal = IPower::getService();

    if (gPowerHal == nullptr) {
        ALOGE("Unable to get Power service.");
    } else {
        if (gPowerHalDeathRecipient == nullptr) {
            gPowerHalDeathRecipient = new PowerHalDeathRecipient();
        }
        hardware::Return<bool> linked = gPowerHal->linkToDeath(
            gPowerHalDeathRecipient, 0x451F /* cookie */);
        if (!linked.isOk()) {
            ALOGE("Transaction error in linking to PowerHAL death: %s",
                  linked.description().c_str());
            gPowerHal = nullptr;
        } else if (!linked) {
            ALOGW("Unable to link to PowerHal death notifications");
            gPowerHal = nullptr;
        } else {
            ALOGD("Link to death notification successful");
        }
    }
}

typedef enum {
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_0     = 0x40800000,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_1     = 0x40800010,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_2     = 0x40800020,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_3     = 0x40800030,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_0  = 0x40800100,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_1  = 0x40800110,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_2  = 0x40800120,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_3  = 0x40800130,

    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_0     = 0x40804000,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_1     = 0x40804010,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_2     = 0x40804020,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_3     = 0x40804030,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_0  = 0x40804100,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_1  = 0x40804110,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_2  = 0x40804120,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_3  = 0x40804130,

    MPCTLV3_MIN_ONLINE_CPU_CLUSTER_BIG      = 0x41000000,
    MPCTLV3_MIN_ONLINE_CPU_CLUSTER_LITTLE   = 0x41000100,
    MPCTLV3_MAX_ONLINE_CPU_CLUSTER_BIG      = 0x41004000,
    MPCTLV3_MAX_ONLINE_CPU_CLUSTER_LITTLE   = 0x41004100,

    MPCTLV3_ALL_CPUS_PWR_CLPS_DIS           = 0x40400000,
    MPCTLV3_CPUBW_HWMON_MIN_FREQ            = 0x41800000,
    MPCTLV3_CPUBW_HWMON_HYST_OPT            = 0x4180C000
} perf_lock_params;


static int32_t perfLockParamsOpenCamera[] = {
    // Disable power collapse and set CPU cloks to turbo
    MPCTLV3_ALL_CPUS_PWR_CLPS_DIS,          0x1,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF
};

static int32_t perfLockParamsCloseCamera[] = {
    // Disable power collapse and set CPU cloks to turbo
    MPCTLV3_ALL_CPUS_PWR_CLPS_DIS,          0x1,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF
};

static int32_t perfLockParamsStartPreview[] = {
    // Disable power collapse and set CPU cloks to turbo
    MPCTLV3_ALL_CPUS_PWR_CLPS_DIS,          0x1,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF
};

static int32_t perfLockParamsTakeSnapshot[] = {
    // Disable power collapse and set CPU cloks to turbo
    MPCTLV3_ALL_CPUS_PWR_CLPS_DIS,          0x1,
    MPCTLV3_MAX_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_BIG_CORE_0,    0xFFF,
    MPCTLV3_MAX_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF,
    MPCTLV3_MIN_FREQ_CLUSTER_LITTLE_CORE_0, 0xFFF,
    MPCTLV3_CPUBW_HWMON_HYST_OPT,           0x0,
    MPCTLV3_CPUBW_HWMON_MIN_FREQ,           0x8C
};

PerfLockInfo QCameraPerfLock::mPerfLockInfo[] = {
    { //PERF_LOCK_OPEN_CAMERA
      perfLockParamsOpenCamera,
      sizeof(perfLockParamsOpenCamera)/sizeof(int32_t) },
    { //PERF_LOCK_CLOSE_CAMERA
      perfLockParamsCloseCamera,
      sizeof(perfLockParamsCloseCamera)/sizeof(int32_t) },
    { //PERF_LOCK_START_PREVIEW
      perfLockParamsStartPreview,
      sizeof(perfLockParamsStartPreview)/sizeof(int32_t) },
    { //PERF_LOCK_TAKE_SNAPSHOT
      perfLockParamsTakeSnapshot,
      sizeof(perfLockParamsTakeSnapshot)/sizeof(int32_t) },
    { //PERF_LOCK_POWERHINT_PREVIEW
      NULL, 0},
    { //PERF_LOCK_POWERHINT_ENCODE
      NULL, 0}
    };

Mutex                QCameraPerfLockIntf::mMutex;
QCameraPerfLockIntf* QCameraPerfLockIntf::mInstance = NULL;


/*===========================================================================
 * FUNCTION   : QCameraPerfLockMgr constructor
 *
 * DESCRIPTION: Initialize the perf locks
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
QCameraPerfLockMgr::QCameraPerfLockMgr() :
    mState(LOCK_MGR_STATE_UNINITIALIZED)
{
    for (int i = 0; i < PERF_LOCK_COUNT; ++i) {
        mPerfLock[i] = QCameraPerfLock::create((PerfLockEnum)i);

        if (mPerfLock[i] == NULL) {
            mState = LOCK_MGR_STATE_ERROR;
            LOGE("Could not allocate perf locks");

            // Set the remaining perf locks to NULL
            for (int j = i+1; j < PERF_LOCK_COUNT; ++j) {
                mPerfLock[j] = NULL;
            }
            return;
        }
    }
    mState = LOCK_MGR_STATE_READY;
}


/*===========================================================================
 * FUNCTION   : QCameraPerfLockMgr destructor
 *
 * DESCRIPTION: class destructor
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
QCameraPerfLockMgr::~QCameraPerfLockMgr()
{
    for (int i = 0; i < PERF_LOCK_COUNT; ++i) {
        if (mPerfLock[i]) {
            delete mPerfLock[i];
        }
    }
}


/*===========================================================================
 * FUNCTION   : acquirePerfLock
 *
 * DESCRIPTION: Call acquirePerfLock function for the requested perf lock
 *
 * PARAMETERS :
 * @perfLockType: Perf lock enum
 * @timer:        Timer value in ms
 *
 * RETURN     : true  on success
 *              false on failure
 *==========================================================================*/
bool QCameraPerfLockMgr::acquirePerfLock(
        PerfLockEnum perfLockType,
        uint32_t     timer)
{
    bool ret = false;
    if ((mState == LOCK_MGR_STATE_READY) &&
        isValidPerfLockEnum(perfLockType)) {
        ret = mPerfLock[perfLockType]->acquirePerfLock(true, timer);
    }
    return ret;
}


/*===========================================================================
 * FUNCTION   : acquirePerfLockIfExpired
 *
 * DESCRIPTION: Call acquirePerfLock function for the requested perf lock
 *
 * PARAMETERS :
 * @perfLockType: Type of perf lock
 * @timer:        Timer value in ms
 *
 * RETURN     : true  on success
 *              false on failure
 *==========================================================================*/
bool QCameraPerfLockMgr::acquirePerfLockIfExpired(
        PerfLockEnum perfLockType,
        uint32_t     timer)
{
    bool ret = false;
    if ((mState == LOCK_MGR_STATE_READY) &&
        isValidPerfLockEnum(perfLockType)) {
        ret = mPerfLock[perfLockType]->acquirePerfLock(false, timer);
    }
    return ret;

}


/*===========================================================================
 * FUNCTION   : releasePerfLock
 *
 * DESCRIPTION: Call releasePerfLock function for the requested perf lock
 *
 * PARAMETERS :
 * @perfLockType: Enum of perf lock
 *
 * RETURN     : true  on success
 *              false on failure
 *==========================================================================*/
bool QCameraPerfLockMgr::releasePerfLock(
        PerfLockEnum perfLockType)
{
    bool ret = false;
    if ((mState == LOCK_MGR_STATE_READY) &&
        isValidPerfLockEnum(perfLockType)) {
        ret = mPerfLock[perfLockType]->releasePerfLock();
    }
    return ret;
}


/*===========================================================================
 * FUNCTION   : powerHintInternal
 *
 * DESCRIPTION: Calls the appropriate perf lock's powerHintInternal function
 *
 * PARAMETERS :
 * @perfLockType: Type of perf lock
 * @hint        : Power hint
 * @enable      : Enable power hint if set to 1. Disable if set to 0.
 *
 * RETURN     : void
 *
 *==========================================================================*/
void QCameraPerfLockMgr::powerHintInternal(
        PerfLockEnum perfLockType,
        PowerHint    powerHint,
        int32_t      time_out)
{
    if ((mState == LOCK_MGR_STATE_READY) &&
        isValidPerfLockEnum(perfLockType)) {
        mPerfLock[perfLockType]->powerHintInternal(powerHint, time_out);
    }
}


/*===========================================================================
 * FUNCTION   : create
 *
 * DESCRIPTION: This is a static method to create perf lock object. It calls
 *              protected constructor of the class and only returns a valid object
 *              if it can successfully initialize the perf lock.
 *
 * PARAMETERS : None
 *
 * RETURN     : QCameraPerfLock object pointer on success
 *              NULL on failure
 *
 *==========================================================================*/
QCameraPerfLock* QCameraPerfLock::create(
        PerfLockEnum perfLockType)
{
    QCameraPerfLock *perfLock = NULL;

    if (perfLockType < PERF_LOCK_COUNT) {
        QCameraPerfLockIntf *perfLockIntf = QCameraPerfLockIntf::createSingleton();
        if (perfLockIntf) {
            perfLock = new QCameraPerfLock(perfLockType, perfLockIntf);
        }
    }
    return perfLock;
}


/*===========================================================================
 * FUNCTION   : QCameraPerfLock constructor
 *
 * DESCRIPTION: Initialize member variables
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
QCameraPerfLock::QCameraPerfLock(
        PerfLockEnum         perfLockType,
        QCameraPerfLockIntf *perfLockIntf) :
        mHandle(0),
        mRefCount(0),
        mTimeOut(0),
        mPerfLockType(perfLockType),
        mPerfLockIntf(perfLockIntf)
{
    mIsPerfdEnabled = android::base::GetBoolProperty("persist.camera.perfd.enable", false);
}


/*===========================================================================
 * FUNCTION   : QCameraPerfLock destructor
 *
 * DESCRIPTION: class destructor
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
QCameraPerfLock::~QCameraPerfLock()
{
    if (mHandle > 0) {
        (*mPerfLockIntf->perfLockRel())(mHandle);
    }
    QCameraPerfLockIntf::deleteInstance();
}


/*===========================================================================
 * FUNCTION   : isTimedOut
 *
 * DESCRIPTION: Check if the perf lock is timed out
 *
 * PARAMETERS : None
 *
 * RETURN     : boolean indicating if the perf lock is timed out
 *
 *==========================================================================*/
bool QCameraPerfLock::isTimedOut()
{
    if (mTimeOut && (systemTime() > mTimeOut)) {
        return true;
    }
    return false;
}


/*===========================================================================
 * FUNCTION   : restartTimer
 *
 * DESCRIPTION: Restart the timer for the duration specified
 *
 * PARAMETERS :
 *  @timer    : timer duration in milliseconds
 *
 * RETURN     : void
 *
 *==========================================================================*/
void inline QCameraPerfLock::restartTimer(
        uint32_t timer)
{
    if (timer > 0) {
        mTimeOut = systemTime() + ms2ns(timer);
    }
}


/*===========================================================================
 * FUNCTION   : acquirePerfLock
 *
 * DESCRIPTION: Acquires the perf lock for the duration specified. Do not acquire
 *              the perf lock is reacquire flag is set to false provided the perf
 *              lock is already acquired.
 *
 * PARAMETERS :
 * @forceReaquirePerfLock: Reacquire
 * @timer     : Duration of the perf lock
 *
 * RETURN     : true  on success
 *              false on failure
 *
 *==========================================================================*/
bool QCameraPerfLock::acquirePerfLock(
        bool     forceReaquirePerfLock,
        uint32_t timer)
{
    bool ret = true;
    Mutex::Autolock lock(mMutex);

    switch (mPerfLockType) {
        case PERF_LOCK_POWERHINT_PREVIEW:
        case PERF_LOCK_POWERHINT_ENCODE:
            powerHintInternal(PowerHint::CAMERA_STREAMING, true);
            return true;
        case PERF_LOCK_OPEN_CAMERA:
        case PERF_LOCK_CLOSE_CAMERA:
            powerHintInternal(PowerHint::CAMERA_LAUNCH, timer);
            return true;
        case PERF_LOCK_START_PREVIEW:
            powerHintInternal(PowerHint::CAMERA_SHOT, timer);
            return true;
        case PERF_LOCK_TAKE_SNAPSHOT:
            powerHintInternal(PowerHint::CAMERA_SHOT, timer);
            return true;
        default:
            LOGE("Unknown powerhint %d",(int)mPerfLockType);
            return false;
    }

    if (!mIsPerfdEnabled) return ret;

    if (isTimedOut()) {
        mHandle   = 0;
        mRefCount = 0;
    }

    if ((mRefCount == 0) || forceReaquirePerfLock) {
        mHandle = (*mPerfLockIntf->perfLockAcq())(
            mHandle, timer,
            mPerfLockInfo[mPerfLockType].perfLockParams,
            mPerfLockInfo[mPerfLockType].perfLockParamsCount);

        if (mHandle > 0) {
            ++mRefCount;
            restartTimer(timer);
            LOGD("perfLockHandle %d, updated refCount: %d, perfLockType: %d",
                mHandle, mRefCount, mPerfLockType);
        } else {
            LOGE("Failed to acquire the perf lock");
            ret = false;
        }
    } else {
        LOGD("Perf lock already acquired, not re-aquiring");
    }

    return ret;
}


/*===========================================================================
 * FUNCTION   : releasePerfLock
 *
 * DESCRIPTION: Releases the perf lock
 *
 * PARAMETERS : None
 *
 * RETURN     : true  on success
 *              false on failure
 *
 *==========================================================================*/
bool QCameraPerfLock::releasePerfLock()
{
    bool ret = true;
    Mutex::Autolock lock(mMutex);

    switch (mPerfLockType) {
        case PERF_LOCK_POWERHINT_PREVIEW:
        case PERF_LOCK_POWERHINT_ENCODE:
            powerHintInternal(PowerHint::CAMERA_STREAMING, false);
            return true;
        case PERF_LOCK_OPEN_CAMERA:
        case PERF_LOCK_CLOSE_CAMERA:
            powerHintInternal(PowerHint::CAMERA_LAUNCH, false);
            return true;
        case PERF_LOCK_START_PREVIEW:
            powerHintInternal(PowerHint::CAMERA_SHOT, false);
            return true;
        case PERF_LOCK_TAKE_SNAPSHOT:
            powerHintInternal(PowerHint::CAMERA_SHOT, false);
            return true;
        default:
            LOGE("Unknown powerhint %d",(int)mPerfLockType);
            return false;
    }

    if (!mIsPerfdEnabled) return ret;

    if (mHandle > 0) {
        LOGD("perfLockHandle %d, refCount: %d, perfLockType: %d",
                    mHandle, mRefCount, mPerfLockType);

        if (isTimedOut()) {
            mHandle   = 0;
            mRefCount = 0;
        } else if (--mRefCount == 0) {
            int32_t rc = (*mPerfLockIntf->perfLockRel())(mHandle);
            mHandle = 0;
            mTimeOut = 0;
            if (rc < 0) {
                LOGE("Failed to release the perf lock");
                ret = false;
            }
        }
    } else {
        LOGW("Perf lock %d either not acquired or already released", mPerfLockType);
    }

    return ret;
}


/*===========================================================================
 * FUNCTION   : powerHintInternal
 *
 * DESCRIPTION: Sets the requested power hint and state to power HAL.
 *
 * PARAMETERS :
 * @hint      : Power hint
 * @enable    : Enable power hint if set to 1. Disable if set to 0.
 *
 * RETURN     : void
 *
 *==========================================================================*/
void QCameraPerfLock::powerHintInternal(
        PowerHint    powerHint,
        int32_t      time_out)
{
#ifdef HAS_MULTIMEDIA_HINTS
    if (!mPerfLockIntf->powerHint(powerHint, time_out)) {
        LOGE("Send powerhint to PowerHal failed");
    }
#endif
}


/*===========================================================================
 * FUNCTION   : createSingleton
 *
 * DESCRIPTION: Open the perf lock library, query the function pointers and
 *              create a singleton object upon success
 *
 * PARAMETERS : None
 *
 * RETURN     : QCameraPerfLockIntf object pointer on success
 *              NULL on failure
 *
 *==========================================================================*/
QCameraPerfLockIntf* QCameraPerfLockIntf::createSingleton()
{
    bool error = true;
    Mutex::Autolock lock(mMutex);

    if (mInstance == NULL) {
        // Open perflock library and query for the function pointers
        uint32_t perfLockEnable = 0;
        char value[PROPERTY_VALUE_MAX];

        property_get("persist.camera.perflock.enable", value, "1");
        perfLockEnable = atoi(value);

        if (perfLockEnable) {
            mInstance = new QCameraPerfLockIntf();
            if (mInstance) {
                #ifdef HAS_MULTIMEDIA_HINTS
                std::lock_guard<std::mutex> lock(gPowerHalMutex);
                getPowerHalLocked();
                if (gPowerHal == nullptr) {
                    ALOGE("Couldn't load PowerHAL module");
                }
                else
                #endif
                {
                    /* Retrieve the name of the vendor extension library */
                    void *dlHandle = NULL;
                    if ((property_get("ro.vendor.extension_library", value, NULL) > 0) &&
                        (dlHandle = dlopen(value, RTLD_NOW | RTLD_LOCAL))) {

                        perfLockAcquire pLockAcq = (perfLockAcquire)dlsym(dlHandle, "perf_lock_acq");
                        perfLockRelease pLockRel = (perfLockRelease)dlsym(dlHandle, "perf_lock_rel");

                        if (pLockAcq && pLockRel) {
                            mInstance->mDlHandle    = dlHandle;
                            mInstance->mPerfLockAcq = pLockAcq;
                            mInstance->mPerfLockRel = pLockRel;
                            error = false;
                        } else {
                            LOGE("Failed to link the symbols- perf_lock_acq, perf_lock_rel");
                            bool IsPerfdEnabled = android::base::GetBoolProperty("persist.camera.perfd.enable", false);
                            if (!IsPerfdEnabled) {
                                mInstance->mDlHandle    = nullptr;
                                mInstance->mPerfLockAcq = nullptr;
                                mInstance->mPerfLockRel = nullptr;
                                error = false;
                            }
                        }
                    } else {
                        LOGE("Unable to load lib: %s", value);
                    }
                }
                if (error && mInstance) {
                    delete mInstance;
                    mInstance = NULL;
                }
            }
        }
    }

    if (mInstance) {
        ++(mInstance->mRefCount);
    }

    return mInstance;
}


/*===========================================================================
 * FUNCTION   : deleteInstance
 *
 * DESCRIPTION: Delete the object if refCount is 0
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
void QCameraPerfLockIntf::deleteInstance()
{
    Mutex::Autolock lock(mMutex);

    if (mInstance && (--(mInstance->mRefCount) == 0)) {
        delete mInstance;
        mInstance = NULL;
    }
}


/*===========================================================================
 * FUNCTION   : QCameraPerfLockIntf destructor
 *
 * DESCRIPTION: class destructor
 *
 * PARAMETERS : None
 *
 * RETURN     : void
 *
 *==========================================================================*/
QCameraPerfLockIntf::~QCameraPerfLockIntf()
{
    if (mDlHandle) {
        dlclose(mDlHandle);
    }
}

bool QCameraPerfLockIntf::powerHint(PowerHint hint, int32_t data) {
    std::lock_guard<std::mutex> lock(gPowerHalMutex);
    getPowerHalLocked();
    if (gPowerHal == nullptr) {
        ALOGE("Couldn't do powerHint because of HAL error.");
        return false;
    }
    auto ret = gPowerHal->powerHintAsync_1_2(hint, data);
    if (!ret.isOk()) {
        ALOGE("powerHint failed error: %s", ret.description().c_str());
    }
    return ret.isOk();
}

}; // namespace qcamera